@@ -10,6 +10,15 @@ func WithRefreshDuration(refreshDuration time.Duration) func(o *options) error {
 	}
 }
 
+// WithEventProcessed reports when the watcher has processed a filesystem event.
+// The timestamp is captured immediately before the refresh timer is reset.
+func WithEventProcessed(f func(string, time.Time)) func(o *options) error {
+	return func(o *options) error {
+		o.eventProcessed = f
+		return nil
+	}
+}
+
 // RefreshDuration returns the refresh duration used by the watcher.
 func (w Watcher) RefreshDuration() time.Duration {
 	return w.refreshDuration
 
@@ -35,6 +35,7 @@ type Watcher struct {
 	cmdErr chan error
 
 	refreshDuration time.Duration
+	eventProcessed  func(string, time.Time)
 }
 
 type command struct {
@@ -46,6 +47,7 @@ type command struct {
 // options are the configurable functional options for the watcher.
 type options struct {
 	refreshDuration time.Duration
+	eventProcessed  func(string, time.Time)
 }
 type option func(*options) error
 
@@ -77,6 +79,7 @@ func New(ctx context.Context, initialDirs []string, opts ...option) (*Watcher, e
 		cmdErr: cmdErr,
 
 		refreshDuration: args.refreshDuration,
+		eventProcessed:  args.eventProcessed,
 	}
 
 	go func() {
@@ -284,7 +287,14 @@ func (w *Watcher) watch(ctx context.Context, dirs []string, initError chan<- err
 			}
 
 			// We got a change, so reset the timer to the grace period.
+			var timerResetStarted time.Time
+			if w.eventProcessed != nil {
+				timerResetStarted = time.Now()
+			}
 			refreshTimer.Reset(w.refreshDuration)
+			if w.eventProcessed != nil {
+				w.eventProcessed(event.Name, timerResetStarted)
+			}
 
 		case err, ok := <-fsWatcher.Errors:
 			if ok {
 
@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -193,49 +194,136 @@ func TestWatchDirectory(t *testing.T) {
 func TestRefreshGracePeriod(t *testing.T) {
 	t.Parallel()
 
+	// The scenario asserts that no version bump happened *while still inside* the
+	// grace period. Such an assertion is only meaningful if we reach it before
+	// the grace period elapses, which a loaded machine does not guarantee:
+	// flushing the file system alone can take a sizeable amount of time. Instead
+	// of failing on a slow runner, retry with a longer grace period, keeping the
+	// assertions themselves strict.
+	const maxAttempts = 4
+
+	gracePeriod := time.Second
+	for range maxAttempts {
+		if refreshGracePeriodScenario(t, gracePeriod) {
+			return
+		}
+		gracePeriod *= 2
+	}
+	t.Fatalf("Machine is too slow to observe the refresh grace period reliably, even with a grace period of %s", gracePeriod/2)
+}
+
+type eventTracker struct {
+	mu     sync.Mutex
+	counts map[string]uint64
+	times  map[string]time.Time
+}
+
+func (tracker *eventTracker) notify(path string, processedAt time.Time) {
+	tracker.mu.Lock()
+	defer tracker.mu.Unlock()
+	tracker.counts[path]++
+	tracker.times[path] = processedAt
+}
+
+func (tracker *eventTracker) count(path string) uint64 {
+	tracker.mu.Lock()
+	defer tracker.mu.Unlock()
+	return tracker.counts[path]
+}
+
+func (tracker *eventTracker) waitFor(t *testing.T, path string, previous uint64) time.Time {
+	t.Helper()
+
+	require.Eventually(t, func() bool {
+		return tracker.count(path) > previous
+	}, 30*time.Second, 10*time.Millisecond, "watcher should process event for %s", path)
+
+	tracker.mu.Lock()
+	defer tracker.mu.Unlock()
+	return tracker.times[path]
+}
+
+// refreshGracePeriodScenario checks that the watcher only bumps the GPT.ini
+// version once the given grace period elapsed without any change, and that any
+// new change pushes that deadline back.
+//
+// It reports whether the run was conclusive: when the machine takes longer than
+// the grace period to reach an assertion, a missing bump can’t be told apart
+// from a late one, and the caller should retry with a longer grace period.
+func refreshGracePeriodScenario(t *testing.T, gracePeriod time.Duration) (conclusive bool) {
+	t.Helper()
+
 	dir := "withsubdir"
 	temp := t.TempDir()
 	dest := filepath.Join(temp, dir)
 	testutils.Copy(t, filepath.Join("testdata", dir), dest)
 
+	events := &eventTracker{
+		counts: make(map[string]uint64),
+		times:  make(map[string]time.Time),
+	}
+
 	// Instantiate the object
-	w, err := watcher.New(context.Background(), []string{dest}, watcher.WithRefreshDuration(time.Second))
+	w, err := watcher.New(context.Background(), []string{dest},
+		watcher.WithRefreshDuration(gracePeriod),
+		watcher.WithEventProcessed(events.notify),
+	)
 	require.NoError(t, err, "Setup: Can't create watcher")
 
 	// Start it
 	err = w.Start(mockService{})
 	require.NoError(t, err, "Setup: Can't start watcher")
 	defer w.Stop(mockService{})
 
-	// Modify first file
-	err = os.WriteFile(filepath.Join(temp, dir, "alreadyexists"), []byte("new content"), 0600)
+	// Modify first file: this arms the grace period timer.
+	firstPath := filepath.Join(dest, "alreadyexists")
+	firstEvent := events.count(firstPath)
+	err = os.WriteFile(firstPath, []byte("new content"), 0600)
 	require.NoError(t, err, "Setup: Can't update file")
-
-	testutils.WaitForWrites(t)
+	firstProcessed := events.waitFor(t, firstPath, firstEvent)
 
 	// Wait for half of the grace period
 	time.Sleep(w.RefreshDuration() / 2)
 
 	// GPT.ini version was not changed
-	assertGPTVersionEquals(t, dest, 2)
+	firstVersion, err := gptVersion(dest)
+	require.NoError(t, err, "Can't get GPT.ini version as an integer")
+	if time.Since(firstProcessed) >= gracePeriod {
+		return false
+	}
+	assert.Equal(t, 2, firstVersion, "GPT.ini version is not equal to the expected one")
 
-	// Modify second file
-	err = os.WriteFile(filepath.Join(temp, dir, "alreadyexistsDir", "alreadyexists"), []byte("new content"), 0600)
+	// Modify second file: this must push the deadline back by a whole grace period.
+	secondPath := filepath.Join(dest, "alreadyexistsDir", "alreadyexists")
+	secondEvent := events.count(secondPath)
+	err = os.WriteFile(secondPath, []byte("new content"), 0600)
 	require.NoError(t, err, "Setup: Can't update file")
+	secondProcessed := events.waitFor(t, secondPath, secondEvent)
+	if secondProcessed.Sub(firstProcessed) >= gracePeriod {
+		return false
+	}
 
-	testutils.WaitForWrites(t)
-
-	// Wait for 3/4 of the grace period (to be sure that we waited for more than one whole grace period in total).
-	time.Sleep(time.Duration(float64(w.RefreshDuration()) * 0.75))
+	// Wait for half of the grace period again: we are now past a whole grace
+	// period since the first write, but still within the one opened by the
+	// second write.
+	time.Sleep(w.RefreshDuration() / 2)
 
 	// GPT.ini version was still not changed
-	assertGPTVersionEquals(t, dest, 2)
-
-	// Wait for another 1/2 of the grace period (to be sure that we waited for more than one whole grace period in total).
-	time.Sleep(w.RefreshDuration() / 2)
+	secondVersion, err := gptVersion(dest)
+	require.NoError(t, err, "Can't get GPT.ini version as an integer")
+	if time.Since(secondProcessed) >= gracePeriod || time.Since(firstProcessed) <= gracePeriod {
+		return false
+	}
+	assert.Equal(t, 2, secondVersion, "GPT.ini version is not equal to the expected one")
 
-	// GPT.ini version was updated
+	// GPT.ini version is updated once the grace period elapsed, and only once.
+	require.Eventually(t, func() bool {
+		v, err := gptVersion(dest)
+		return err == nil && v > 2
+	}, 30*time.Second, 10*time.Millisecond, "GPT.ini version should have been bumped after the grace period")
 	assertGPTVersionEquals(t, dest, 3)
+
+	return true
 }
 
 func TestUpdateDirs(t *testing.T) {
@@ -422,15 +510,23 @@ func assertGPTVersionEquals(t *testing.T, path string, version int) {
 	}
 	require.True(t, gptFileExists, "GPT.ini not created")
 
-	cfg, err := ini.Load(gptfile)
-	require.NoError(t, err, "Can't load GPT.ini")
-
-	v, err := cfg.Section("General").Key("Version").Int()
+	v, err := gptVersion(path)
 	require.NoError(t, err, "Can't get GPT.ini version as an integer")
 
 	assert.Equal(t, version, v, "GPT.ini version is not equal to the expected one")
 }
 
+// gptVersion returns the version set in the GPT.ini file of the given directory.
+// It doesn’t assert, so that it can be polled from a testify condition.
+func gptVersion(path string) (int, error) {
+	cfg, err := ini.Load(filepath.Join(path, "GPT.INI"))
+	if err != nil {
+		return 0, err
+	}
+
+	return cfg.Section("General").Key("Version").Int()
+}
+
 func requireGPTVersionError(t *testing.T, path string) {
 	t.Helper()