fix: restore trailing debounce in EventWatcher

The rewritten debounce fired a fixed 50ms after the first change rather than
after changes stopped arriving, turning it into a throttle. A sustained burst
of appends therefore produced one callback per 50ms window instead of one per
quiet period, which is what TestEventWatcher_DebounceCollapses caught under
the race detector.

Reset the window on every new change, as the original per-session timers did,
and cap the total deferral at 500ms so a continuously active session still
refreshes instead of having its window extended forever.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: dac50159-d2c8-4ade-920a-333a51fc9ce3

Author: jongio

internal/data/eventwatcher.go

@@ -12,11 +12,16 @@ import (
 	"github.com/jongio/dispatch/internal/validate"
 )
 
-// eventWatcherDebounce is the minimum interval between re-classifications
-// of the same session after a file change. Rapid writes (e.g. multiple
-// events.jsonl appends in quick succession) are collapsed into one callback.
+// eventWatcherDebounce is how long the watcher waits for changes to stop
+// arriving before re-classifying. Rapid writes (e.g. multiple events.jsonl
+// appends in quick succession) are collapsed into one callback.
 const eventWatcherDebounce = 50 * time.Millisecond
 
+// eventWatcherMaxDelay caps how long classification can be deferred while
+// changes keep arriving. Without it, a continuously active session would
+// reset the debounce window forever and never refresh in the UI.
+const eventWatcherMaxDelay = 500 * time.Millisecond
+
 // EventWatcher monitors the Copilot CLI session-state directory for changes
 // using OS-level file system notifications (fsnotify). When events.jsonl or
 // lock files change, it re-classifies just the affected session and fires
@@ -265,11 +270,33 @@ func (ew *EventWatcher) debounceLoop(stateDir string) {
 		case <-ew.wake:
 		}
 
+		// Trailing debounce: keep extending the window while changes are
+		// still arriving, but never past eventWatcherMaxDelay.
+		deadline := time.Now().Add(eventWatcherMaxDelay)
 		timer.Reset(eventWatcherDebounce)
-		select {
-		case <-ew.stop:
-			return
-		case <-timer.C:
+
+	settle:
+		for {
+			select {
+			case <-ew.stop:
+				return
+
+			case <-ew.wake:
+				if !timer.Stop() {
+					<-timer.C
+				}
+				wait := eventWatcherDebounce
+				if remaining := time.Until(deadline); remaining < wait {
+					wait = remaining
+				}
+				if wait <= 0 {
+					break settle
+				}
+				timer.Reset(wait)
+
+			case <-timer.C:
+				break settle
+			}
 		}
 
 		ew.mu.Lock()