feat: condense watcher warnings and add polling fallback for unwatchable dirs

WSL UNC paths can't be watched by fsnotify (ReadDirectoryChangesW fails).
Previously WatchRecursive logged one warning per subdirectory, producing
dozens of noisy lines. Now it returns watched/unwatched counts silently,
the caller prints a single condensed summary per root, and a 2-minute
polling goroutine supplements the 15-minute periodic sync for faster
change detection on unwatchable paths.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 2 people

cmd/agentsview/main.go

@@ -26,10 +26,11 @@ var (
 )
 
 const (
-	periodicSyncInterval = 15 * time.Minute
-	watcherDebounce      = 500 * time.Millisecond
-	browserPollInterval  = 100 * time.Millisecond
-	browserPollAttempts  = 60
+	periodicSyncInterval  = 15 * time.Minute
+	unwatchedPollInterval = 2 * time.Minute
+	watcherDebounce       = 500 * time.Millisecond
+	browserPollInterval   = 100 * time.Millisecond
+	browserPollAttempts   = 60
 )
 
 func main() {
@@ -145,10 +146,13 @@ func runServe(args []string) {
 
 	runInitialSync(engine)
 
-	stopWatcher := startFileWatcher(cfg, engine)
+	stopWatcher, unwatchedDirs := startFileWatcher(cfg, engine)
 	defer stopWatcher()
 
 	go startPeriodicSync(engine)
+	if len(unwatchedDirs) > 0 {
+		go startUnwatchedPoll(engine)
+	}
 
 	port := server.FindAvailablePort(cfg.Host, cfg.Port)
 	if port != cfg.Port {
@@ -244,50 +248,65 @@ func printSyncProgress(p sync.Progress) {
 
 func startFileWatcher(
 	cfg config.Config, engine *sync.Engine,
-) func() {
+) (stopWatcher func(), unwatchedDirs []string) {
 	t := time.Now()
 	onChange := func(paths []string) {
 		engine.SyncPaths(paths)
 	}
 	watcher, err := sync.NewWatcher(watcherDebounce, onChange)
 	if err != nil {
 		log.Printf("warning: file watcher unavailable: %v", err)
-		return func() {}
+		return func() {}, nil
+	}
+
+	type watchRoot struct {
+		dir  string
+		root string // actual path passed to WatchRecursive
 	}
 
-	var dirs int
+	var roots []watchRoot
 	for _, d := range cfg.ResolveClaudeDirs() {
 		if _, err := os.Stat(d); err == nil {
-			n, _ := watcher.WatchRecursive(d)
-			dirs += n
+			roots = append(roots, watchRoot{d, d})
 		}
 	}
 	for _, d := range cfg.ResolveCodexDirs() {
 		if _, err := os.Stat(d); err == nil {
-			n, _ := watcher.WatchRecursive(d)
-			dirs += n
+			roots = append(roots, watchRoot{d, d})
 		}
 	}
 	for _, d := range cfg.ResolveCopilotDirs() {
 		copilotState := filepath.Join(d, "session-state")
 		if _, err := os.Stat(copilotState); err == nil {
-			n, _ := watcher.WatchRecursive(copilotState)
-			dirs += n
+			roots = append(roots, watchRoot{d, copilotState})
 		}
 	}
 	for _, d := range cfg.ResolveGeminiDirs() {
 		geminiTmp := filepath.Join(d, "tmp")
 		if _, err := os.Stat(geminiTmp); err == nil {
-			n, _ := watcher.WatchRecursive(geminiTmp)
-			dirs += n
+			roots = append(roots, watchRoot{d, geminiTmp})
 		}
 	}
+
+	var totalWatched int
+	for _, r := range roots {
+		watched, uw, _ := watcher.WatchRecursive(r.root)
+		totalWatched += watched
+		if uw > 0 {
+			unwatchedDirs = append(unwatchedDirs, r.dir)
+			log.Printf(
+				"Couldn't watch %d directories under %s, will poll every %s",
+				uw, r.dir, unwatchedPollInterval,
+			)
+		}
+	}
+
 	fmt.Printf(
 		"Watching %d directories for changes (%s)\n",
-		dirs, time.Since(t).Round(time.Millisecond),
+		totalWatched, time.Since(t).Round(time.Millisecond),
 	)
 	watcher.Start()
-	return watcher.Stop
+	return watcher.Stop, unwatchedDirs
 }
 
 func startPeriodicSync(engine *sync.Engine) {
@@ -299,6 +318,15 @@ func startPeriodicSync(engine *sync.Engine) {
 	}
 }
 
+func startUnwatchedPoll(engine *sync.Engine) {
+	ticker := time.NewTicker(unwatchedPollInterval)
+	defer ticker.Stop()
+	for range ticker.C {
+		log.Println("Polling unwatched directories...")
+		engine.SyncAll(nil)
+	}
+}
+
 func openBrowser(url string) {
 	for range browserPollAttempts {
 		time.Sleep(browserPollInterval)

internal/sync/watcher.go

@@ -52,27 +52,23 @@ func NewWatcher(
 
 // WatchRecursive walks a directory tree and adds all
 // subdirectories to the watch list. Returns the number
-// of directories added.
-func (w *Watcher) WatchRecursive(root string) (int, error) {
-	var count int
-	err := filepath.WalkDir(root,
+// of directories watched and unwatched (failed to add).
+func (w *Watcher) WatchRecursive(root string) (watched int, unwatched int, err error) {
+	err = filepath.WalkDir(root,
 		func(path string, d fs.DirEntry, err error) error {
 			if err != nil {
 				return nil // skip inaccessible dirs
 			}
 			if d.IsDir() {
 				if addErr := w.watcher.Add(path); addErr != nil {
-					log.Printf(
-						"watcher: cannot watch %s: %v",
-						path, addErr,
-					)
+					unwatched++
 				} else {
-					count++
+					watched++
 				}
 			}
 			return nil
 		})
-	return count, err
+	return watched, unwatched, err
 }
 
 // Start begins processing file events in a goroutine.

internal/sync/watcher_test.go

@@ -24,7 +24,7 @@ func startTestWatcherNoCleanup(
 	if err != nil {
 		t.Fatalf("NewWatcher: %v", err)
 	}
-	if _, err := w.WatchRecursive(dir); err != nil {
+	if _, _, err := w.WatchRecursive(dir); err != nil {
 		t.Fatalf("WatchRecursive: %v", err)
 	}
 	w.Start()