[codex] scope unwatched root polling (#738)

This PR stops the unwatched-root fallback from re-running a global sync every two minutes.

It adds SyncRootsSince, which keeps the existing incremental mtime cutoff behavior while limiting discovery to the roots reported as unwatched by the file watcher. The existing full sync and full resync paths remain unscoped.

The startup poller now uses the recorded last-sync start time with a small safety margin, so watcher-budget exhaustion polls only the affected roots. The watcher-unavailable all sentinel still falls back to the previous global behavior.

Co-authored-by: Jesse Vincent <obra@users.noreply.github.com>

Author: obra

cmd/agentsview/main.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
+	"slices"
 	"syscall"
 	"time"
 	_ "time/tzdata"
@@ -282,7 +283,7 @@ func runServe(cfg config.Config) {
 		)
 		defer stopWatcher()
 		if len(unwatchedDirs) > 0 {
-			go startUnwatchedPoll(engine)
+			go startUnwatchedPoll(engine, unwatchedDirs)
 		}
 	}
 
@@ -513,62 +514,7 @@ func startFileWatcher(
 		return func() {}, []string{"all"}
 	}
 
-	type watchRoot struct {
-		dir     string
-		root    string // actual path passed to WatchRecursive
-		shallow bool   // use shallow watch (root only)
-	}
-
-	var roots []watchRoot
-	seenRoots := make(map[string]struct{})
-	addRoot := func(r watchRoot) {
-		if _, ok := seenRoots[r.root]; ok {
-			return
-		}
-		seenRoots[r.root] = struct{}{}
-		roots = append(roots, r)
-	}
-	for _, def := range parser.Registry {
-		if !def.FileBased {
-			continue
-		}
-		for _, d := range cfg.ResolveDirs(def.Type) {
-			if def.ShallowWatchRootsFunc != nil {
-				for _, watchDir := range def.ShallowWatchRootsFunc(d) {
-					if _, err := os.Stat(watchDir); err == nil {
-						addRoot(watchRoot{d, watchDir, true})
-					}
-				}
-			}
-			if def.WatchRootsFunc != nil {
-				watchDirs := def.WatchRootsFunc(d)
-				if len(watchDirs) == 0 {
-					unwatchedDirs = append(unwatchedDirs, d)
-					continue
-				}
-				for _, watchDir := range watchDirs {
-					if _, err := os.Stat(watchDir); err == nil {
-						addRoot(watchRoot{d, watchDir, def.ShallowWatch})
-						continue
-					}
-					unwatchedDirs = append(unwatchedDirs, d)
-				}
-				continue
-			}
-			if len(def.WatchSubdirs) == 0 {
-				if _, err := os.Stat(d); err == nil {
-					addRoot(watchRoot{d, d, def.ShallowWatch})
-				}
-				continue
-			}
-			for _, sub := range def.WatchSubdirs {
-				watchDir := filepath.Join(d, sub)
-				if _, err := os.Stat(watchDir); err == nil {
-					addRoot(watchRoot{d, watchDir, def.ShallowWatch})
-				}
-			}
-		}
-	}
+	roots, unwatchedDirs := collectWatchRoots(cfg)
 
 	var totalWatched int
 	var shallowWatched int
@@ -579,7 +525,7 @@ func startFileWatcher(
 				shallowWatched++
 				totalWatched++
 			} else {
-				unwatchedDirs = append(unwatchedDirs, r.dir)
+				unwatchedDirs = append(unwatchedDirs, r.dirs...)
 			}
 			continue
 		}
@@ -588,13 +534,13 @@ func startFileWatcher(
 		remaining -= result.Watched
 		if result.Unwatched > 0 || result.BudgetExhausted ||
 			result.ResourceExhausted || result.Err != nil {
-			unwatchedDirs = append(unwatchedDirs, r.dir)
+			unwatchedDirs = append(unwatchedDirs, r.dirs...)
 			log.Printf(
 				"Couldn't watch %d directories under %s, will poll every %s",
-				result.Unwatched, r.dir, unwatchedPollInterval,
+				result.Unwatched, r.root, unwatchedPollInterval,
 			)
 			if result.Err != nil {
-				log.Printf("watching %s: %v", r.dir, result.Err)
+				log.Printf("watching %s: %v", r.root, result.Err)
 			}
 		}
 	}
@@ -620,6 +566,72 @@ func startFileWatcher(
 	return watcher.Stop, unwatchedDirs
 }
 
+type watchRoot struct {
+	dirs    []string
+	root    string // actual path passed to WatchRecursive
+	shallow bool   // use shallow watch (root only)
+}
+
+func collectWatchRoots(cfg config.Config) (roots []watchRoot, unwatchedDirs []string) {
+	rootIndexes := make(map[string]int)
+	addRoot := func(dir, root string, shallow bool) {
+		if idx, ok := rootIndexes[root]; ok {
+			if !slices.Contains(roots[idx].dirs, dir) {
+				roots[idx].dirs = append(roots[idx].dirs, dir)
+			}
+			return
+		}
+		rootIndexes[root] = len(roots)
+		roots = append(roots, watchRoot{
+			dirs:    []string{dir},
+			root:    root,
+			shallow: shallow,
+		})
+	}
+	for _, def := range parser.Registry {
+		if !def.FileBased {
+			continue
+		}
+		for _, d := range cfg.ResolveDirs(def.Type) {
+			if def.ShallowWatchRootsFunc != nil {
+				for _, watchDir := range def.ShallowWatchRootsFunc(d) {
+					if _, err := os.Stat(watchDir); err == nil {
+						addRoot(d, watchDir, true)
+					}
+				}
+			}
+			if def.WatchRootsFunc != nil {
+				watchDirs := def.WatchRootsFunc(d)
+				if len(watchDirs) == 0 {
+					unwatchedDirs = append(unwatchedDirs, d)
+					continue
+				}
+				for _, watchDir := range watchDirs {
+					if _, err := os.Stat(watchDir); err == nil {
+						addRoot(d, watchDir, def.ShallowWatch)
+						continue
+					}
+					unwatchedDirs = append(unwatchedDirs, d)
+				}
+				continue
+			}
+			if len(def.WatchSubdirs) == 0 {
+				if _, err := os.Stat(d); err == nil {
+					addRoot(d, d, def.ShallowWatch)
+				}
+				continue
+			}
+			for _, sub := range def.WatchSubdirs {
+				watchDir := filepath.Join(d, sub)
+				if _, err := os.Stat(watchDir); err == nil {
+					addRoot(d, watchDir, def.ShallowWatch)
+				}
+			}
+		}
+	}
+	return roots, unwatchedDirs
+}
+
 func startPeriodicSync(
 	engine *sync.Engine, database *db.DB,
 ) {
@@ -659,11 +671,21 @@ func recomputePendingSessions(
 	}
 }
 
-func startUnwatchedPoll(engine *sync.Engine) {
+type unwatchedPollSyncer interface {
+	SyncRootsSince(
+		context.Context, []string, time.Time, sync.ProgressFunc,
+	) sync.SyncStats
+}
+
+func startUnwatchedPoll(engine unwatchedPollSyncer, roots []string) {
 	ticker := time.NewTicker(unwatchedPollInterval)
 	defer ticker.Stop()
 	for range ticker.C {
 		log.Println("Polling unwatched directories...")
-		engine.SyncAll(context.Background(), nil)
+		pollUnwatchedRootsOnce(engine, roots)
 	}
 }
+
+func pollUnwatchedRootsOnce(engine unwatchedPollSyncer, roots []string) {
+	engine.SyncRootsSince(context.Background(), roots, time.Time{}, nil)
+}

cmd/agentsview/main_test.go

@@ -2,17 +2,20 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"errors"
 	"io"
 	"log"
 	"os"
 	"path/filepath"
 	"syscall"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.kenn.io/agentsview/internal/config"
+	"go.kenn.io/agentsview/internal/parser"
 	"go.kenn.io/agentsview/internal/sync"
 )
 
@@ -225,6 +228,60 @@ func TestTruncateLogFileSymlink(t *testing.T) {
 	assert.Len(t, data, 1024, "symlink target was truncated")
 }
 
+type fakeUnwatchedPollSyncer struct {
+	roots     []string
+	since     time.Time
+	calls     int
+	callRoots [][]string
+	callSince []time.Time
+}
+
+func (f *fakeUnwatchedPollSyncer) SyncRootsSince(
+	ctx context.Context, roots []string, since time.Time,
+	onProgress sync.ProgressFunc,
+) sync.SyncStats {
+	f.calls++
+	f.roots = append([]string(nil), roots...)
+	f.since = since
+	f.callRoots = append(f.callRoots, append([]string(nil), roots...))
+	f.callSince = append(f.callSince, since)
+	return sync.SyncStats{}
+}
+
+func TestPollUnwatchedRootsOnceUsesScopedFullSync(t *testing.T) {
+	fake := &fakeUnwatchedPollSyncer{}
+	roots := []string{"/tmp/claude", "/tmp/codex"}
+
+	pollUnwatchedRootsOnce(fake, roots)
+	pollUnwatchedRootsOnce(fake, roots)
+
+	require.Equal(t, 2, fake.calls)
+	assert.Equal(t, roots, fake.callRoots[0])
+	assert.True(t, fake.callSince[0].IsZero(), "first poll cutoff = %v", fake.callSince[0])
+	assert.Equal(t, roots, fake.callRoots[1])
+	assert.True(t, fake.callSince[1].IsZero(), "second poll cutoff = %v", fake.callSince[1])
+}
+
+func TestCollectWatchRootsPreservesDirsSharingWatchRoot(t *testing.T) {
+	parent := filepath.Join(t.TempDir(), "codex-state")
+	require.NoError(t, os.Mkdir(parent, 0o755), "mkdir parent")
+
+	sessionsDir := filepath.Join(parent, "sessions")
+	archivedDir := filepath.Join(parent, "archived_sessions")
+	cfg := config.Config{
+		AgentDirs: map[parser.AgentType][]string{
+			parser.AgentCodex: {sessionsDir, archivedDir},
+		},
+	}
+
+	roots, unwatchedDirs := collectWatchRoots(cfg)
+
+	require.Empty(t, unwatchedDirs, "unwatched dirs before watcher setup")
+	require.Len(t, roots, 1, "shared watch root should be represented once")
+	assert.Equal(t, parent, roots[0].root)
+	assert.ElementsMatch(t, []string{sessionsDir, archivedDir}, roots[0].dirs)
+}
+
 func TestResyncCoversSignals(t *testing.T) {
 	tests := []struct {
 		name     string