fix(watch): preserve final rapid-write state

watch/events.go

@@ -114,7 +114,7 @@ func (d *Daemon) eventLoop() {
 				continue
 			}
 
-			if debouncer.shouldSkip(event, time.Now()) {
+			if d.shouldSkipEvent(debouncer, event, time.Now()) {
 				continue
 			}
 
@@ -132,6 +132,26 @@ func (d *Daemon) eventLoop() {
 	}
 }
 
+func (d *Daemon) shouldSkipEvent(debouncer *eventDebouncer, event fsnotify.Event, now time.Time) bool {
+	if !debouncer.shouldSkip(event, now) {
+		return false
+	}
+	info, err := os.Stat(event.Name)
+	if err != nil {
+		return false
+	}
+	relPath, err := filepath.Rel(d.root, event.Name)
+	if err != nil {
+		return false
+	}
+
+	d.graph.mu.RLock()
+	cached := d.graph.State[relPath]
+	matches := cached != nil && cached.Size == info.Size()
+	d.graph.mu.RUnlock()
+	return matches
+}
+
 // isSourceFile checks if a file should be tracked.
 // Derives from the canonical extension registry in scanner.
 func (d *Daemon) isSourceFile(path string) bool {

watch/events_debounce_test.go

@@ -1,12 +1,48 @@
 package watch
 
 import (
+	"os"
+	"path/filepath"
 	"testing"
 	"time"
 
 	"github.com/fsnotify/fsnotify"
 )
 
+func TestDaemonDoesNotDebounceWriteWhenCachedSizeIsStale(t *testing.T) {
+	root := t.TempDir()
+	path := filepath.Join(root, "main.go")
+	if err := os.WriteFile(path, []byte("package main\n\nfunc changed() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	d := &Daemon{
+		root: root,
+		graph: &Graph{State: map[string]*FileState{
+			"main.go": {Size: 0},
+		}},
+	}
+	debouncer := newEventDebouncer(100 * time.Millisecond)
+	event := fsnotify.Event{Name: path, Op: fsnotify.Write}
+	base := time.Unix(0, 0)
+
+	if d.shouldSkipEvent(debouncer, event, base) {
+		t.Fatal("first write should not be skipped")
+	}
+	if d.shouldSkipEvent(debouncer, event, base.Add(10*time.Millisecond)) {
+		t.Fatal("final write should refresh stale cached state")
+	}
+
+	info, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	d.graph.State["main.go"].Size = info.Size()
+	if !d.shouldSkipEvent(debouncer, event, base.Add(20*time.Millisecond)) {
+		t.Fatal("duplicate write should be skipped once cached state is current")
+	}
+}
+
 func TestEventDebouncerSkipsRapidWrites(t *testing.T) {
 	debouncer := newEventDebouncer(100 * time.Millisecond)
 	base := time.Unix(0, 0)

watch/more_test.go

@@ -156,7 +156,7 @@ func TestDaemonStartTracksWriteEventsAndState(t *testing.T) {
 
 	waitForWatchCondition(t, 2*time.Second, func() bool {
 		events := d.GetEvents(0)
-		return len(events) > 0
+		return len(events) > 0 && events[len(events)-1].Path == "main.go" && events[len(events)-1].Delta > 0
 	})
 
 	events := d.GetEvents(0)