perf(desktop): key sidebar git-watch off agent activity, not every row

DashboardSidebarWorkspaceStatusProvider called watchGit for every sidebar
row to keep diff-stat caches warm. Verified live against real data in
#6848: opening the dashboard alone (no workspace opened) caused 79 of 90
non-archived workspaces to become watched, since the sidebar is normally
mounted for the whole session — the load and terminal-lag scenario #6729
set out to fix, reintroduced through a different subscriber.

An idle workspace's git state can't change without user interaction, so its
diff count doesn't need to stay live — it only needs to be correct the next
time it's opened, which useDiffStats' normal query fetch already handles.
Non-active rows don't render a diff count today anyway (only the active
row does, per the existing `entries` memo), so losing liveness for an idle
row costs a first-open loading flash, not a wrong number on screen.

Now only workspaces with a currently running/blocked/attention-needing
agent (working/permission/review/failed — any non-idle PaneStatus) or the
active workspace hold live git-watch interest. The signal is already
computed here (bindingRowsByIndex + deriveTerminalAgentStatus, the same
data driving the status dot) — no new plumbing. The full lifecycle-listener
pass (agent:lifecycle/terminal:lifecycle/git:changed) still covers every
row regardless, since that's what detects a row transitioning into
activity in the first place; only the watchGit/unwatchGit calls — the ones
with real host-side cost — are now gated.

Split into two effects so the (still full-coverage, cheap) listener
registration doesn't churn every time an unrelated workspace's terminal
status flips: one for listeners (unchanged, keyed on the full target list),
one for git-watch diffing (new, keyed on a fingerprint-stabilized
"currently worth watching" set), plus the existing final-unmount cleanup.

Verified: typecheck and biome clean; no automated test exists for this
component (none did before this change either). Logic re-reviewed by hand
against the exact structure verified live via CDP against real production
data in #6848, but not independently re-verified live in this follow-up —
happy to spin up a fresh dev session and confirm the watched-workspace
count actually drops if useful before merge.

Follow-up to #6848 / #6729.

Claude-Session: https://claude.ai/code/session_01NmLFihnhebmL9bbbojGYCR

Author: AviPeltz

apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/providers/DashboardSidebarWorkspaceStatusProvider/DashboardSidebarWorkspaceStatusProvider.tsx

@@ -225,26 +225,94 @@ export function DashboardSidebarWorkspaceStatusProvider({
 		combine: (results) => results.map((result) => result.data),
 	});
 
-	// One lifecycle/git subscription pass for the whole sidebar (the per-row
-	// hooks used to register these per workspace, several times over). The
-	// git:changed invalidation keeps diff-stats caches fresh for rows that
-	// aren't currently displaying them (staleTime is Infinity there, so a
-	// missed invalidation would freeze counts on the next activation).
-	//
-	// GitWatcher only watches a workspace while someone holds interest
-	// (#6729) — this call site talks to the bus directly rather than through
-	// useWorkspaceEvent, so it must drive watchGit/unwatchGit itself. This
-	// registers every workspace row shown in the sidebar, which for a heavy
-	// user is most/all of their non-archived workspaces — preserves today's
-	// "every row's diff count stays live" behavior exactly, but means this
-	// provider alone can keep a large fraction of the workspace population
-	// watched whenever the dashboard is open. Worth revisiting (e.g.
-	// staleTime-based refetch for non-active rows instead of a live watch)
-	// as a follow-up.
+	// Only the active row renders diff stats, so one query serves the sidebar.
+	const activeDiffStats = useDiffStats(activeWorkspaceId ?? "", {
+		enabled: activeWorkspaceId !== null,
+	});
+
+	const manualUnread = useV2NotificationStore((state) => state.manualUnread);
+	const terminalSeenAt = useV2NotificationStore(
+		(state) => state.terminalSeenAt,
+	);
+
+	// Per-target terminal statuses — shared by the git-watch gating below and
+	// the entries memo further down, so the two never drift.
+	const statusesByIndex = useMemo(
+		() =>
+			targets.map((_target, index) => {
+				const bindingRows = bindingRowsByIndex[index] ?? [];
+				const statuses = new Map<string, PaneStatus>();
+				for (const binding of bindingRows) {
+					statuses.set(
+						binding.terminalId,
+						deriveTerminalAgentStatus({
+							lastEventType: binding.lastEventType,
+							lastEventAt: binding.lastEventAt,
+							lastSeenAt: terminalSeenAt[binding.terminalId],
+						}),
+					);
+				}
+				return statuses;
+			}),
+		[targets, bindingRowsByIndex, terminalSeenAt],
+	);
+
+	// Only workspaces with a currently running/blocked/attention-needing
+	// agent (or the active workspace) are worth a live git:changed watch —
+	// see #6729/#6848. An idle workspace's diff count can't change without
+	// user interaction, so it's fine for it to refresh only when actually
+	// opened (useDiffStats' normal query fetch) instead of paying for a live
+	// host-side watcher (DB lookup + git subprocess + fs.watch attach) on
+	// the chance the user clicks into it next. Non-active rows never render
+	// a diff count today anyway (see `entries` below) — losing liveness here
+	// only means a first-open loading flash instead of an instant number.
+	const computedGitWatchTargets = useMemo(() => {
+		const result: Array<{ workspaceId: string; hostUrl: string }> = [];
+		targets.forEach((target, index) => {
+			if (!target.hostUrl) return;
+			const isActive = target.workspaceId === activeWorkspaceId;
+			const statuses = statusesByIndex[index];
+			const hasActiveTerminal = statuses
+				? [...statuses.values()].some((status) => status !== "idle")
+				: false;
+			if (isActive || hasActiveTerminal) {
+				result.push({
+					workspaceId: target.workspaceId,
+					hostUrl: target.hostUrl,
+				});
+			}
+		});
+		return result;
+	}, [targets, statusesByIndex, activeWorkspaceId]);
+	// Fingerprint-stabilized for the same reason `targets` is above: this
+	// must only change identity when the watch set actually changes, not on
+	// every unrelated bindingRows refetch.
+	const previousGitWatchTargetsRef = useRef<{
+		fingerprint: string;
+		targets: Array<{ workspaceId: string; hostUrl: string }>;
+	} | null>(null);
+	const gitWatchTargets = useMemo(() => {
+		const fingerprint = JSON.stringify(computedGitWatchTargets);
+		const previous = previousGitWatchTargetsRef.current;
+		if (previous?.fingerprint === fingerprint) return previous.targets;
+		previousGitWatchTargetsRef.current = {
+			fingerprint,
+			targets: computedGitWatchTargets,
+		};
+		return computedGitWatchTargets;
+	}, [computedGitWatchTargets]);
+
+	// One lifecycle/git-listener subscription pass for the whole sidebar
+	// (the per-row hooks used to register these per workspace, several
+	// times over). Covers every row, not just `gitWatchTargets` — this is
+	// what detects a row transitioning into activity in the first place
+	// (agent:lifecycle/terminal:lifecycle), and a git:changed listener for a
+	// workspace nobody's watching simply never fires. Cheap to tear down
+	// and redo every render, unlike the watchGit/unwatchGit calls in the
+	// effect below.
 	useEffect(() => {
 		const cleanups: Array<() => void> = [];
 		const retainedHostUrls = new Set<string>();
-		const nextGitWatched = new Map<string, string>();
 		for (const { workspaceId, hostUrl } of targets) {
 			if (!hostUrl) continue;
 			const bus = getHostEventBus(hostUrl);
@@ -268,17 +336,25 @@ export function DashboardSidebarWorkspaceStatusProvider({
 					});
 				}),
 			);
-			nextGitWatched.set(workspaceId, hostUrl);
 		}
+		return () => {
+			for (const cleanup of cleanups) cleanup();
+		};
+	}, [targets, queryClient]);
 
-		// Diff against the previous run's watched set: only call
-		// watchGit/unwatchGit for rows that actually changed. Unlike the
-		// on() listener registrations above (cheap to tear down and redo
-		// every render), watchGit/unwatchGit carry real host-side cost — a
-		// DB lookup, a git subprocess, and a live fs.watch attach/teardown.
-		// Blindly unwatching then rewatching every row whenever a single
-		// unrelated workspace is created, renamed, or reassigned a host
-		// would reintroduce exactly the fan-out storm #6729 set out to fix.
+	// GitWatcher only watches a workspace while someone holds interest
+	// (#6729) — this call site talks to the bus directly rather than
+	// through useWorkspaceEvent, so it must drive watchGit/unwatchGit
+	// itself. Diffs against the previous run's watched set: only calls
+	// watchGit/unwatchGit for rows that actually entered or left
+	// `gitWatchTargets`, since — unlike the listener registrations above —
+	// these carry real host-side cost (a DB lookup, a git subprocess, and a
+	// live fs.watch attach/teardown). Blindly unwatching then rewatching
+	// everything on every change would reintroduce a fan-out storm.
+	useEffect(() => {
+		const nextGitWatched = new Map(
+			gitWatchTargets.map(({ workspaceId, hostUrl }) => [workspaceId, hostUrl]),
+		);
 		const prevGitWatched = gitWatchedRef.current;
 		for (const [workspaceId, hostUrl] of prevGitWatched) {
 			if (nextGitWatched.get(workspaceId) !== hostUrl) {
@@ -291,16 +367,12 @@ export function DashboardSidebarWorkspaceStatusProvider({
 			}
 		}
 		gitWatchedRef.current = nextGitWatched;
-
-		return () => {
-			for (const cleanup of cleanups) cleanup();
-		};
-	}, [targets, queryClient]);
+	}, [gitWatchTargets]);
 
 	// Release git-watch interest for every currently-watched row on final
 	// unmount. Deliberately a separate, dep-less effect: its cleanup only
-	// runs once, at unmount, so an intermediate targets change (handled by
-	// the diffing above) can't trip this and undo it.
+	// runs once, at unmount, so an intermediate gitWatchTargets change
+	// (handled by the diffing above) can't trip this and undo it.
 	useEffect(() => {
 		return () => {
 			for (const [workspaceId, hostUrl] of gitWatchedRef.current) {
@@ -310,16 +382,6 @@ export function DashboardSidebarWorkspaceStatusProvider({
 		};
 	}, []);
 
-	// Only the active row renders diff stats, so one query serves the sidebar.
-	const activeDiffStats = useDiffStats(activeWorkspaceId ?? "", {
-		enabled: activeWorkspaceId !== null,
-	});
-
-	const manualUnread = useV2NotificationStore((state) => state.manualUnread);
-	const terminalSeenAt = useV2NotificationStore(
-		(state) => state.terminalSeenAt,
-	);
-
 	const previousEntriesRef = useRef(
 		new Map<string, SidebarWorkspaceStatusEntry>(),
 	);
@@ -329,18 +391,10 @@ export function DashboardSidebarWorkspaceStatusProvider({
 		targets.forEach((target, index) => {
 			const bindingRows = bindingRowsByIndex[index] ?? [];
 			const bindings = new Map<string, TerminalAgentBinding>();
-			const statuses = new Map<string, PaneStatus>();
 			for (const binding of bindingRows) {
 				bindings.set(binding.terminalId, binding);
-				statuses.set(
-					binding.terminalId,
-					deriveTerminalAgentStatus({
-						lastEventType: binding.lastEventType,
-						lastEventAt: binding.lastEventAt,
-						lastSeenAt: terminalSeenAt[binding.terminalId],
-					}),
-				);
 			}
+			const statuses = statusesByIndex[index] ?? new Map<string, PaneStatus>();
 			const hasManualUnread = Boolean(manualUnread[target.workspaceId]);
 			let hasAttentionTerminal = false;
 			for (const status of statuses.values()) {
@@ -373,8 +427,8 @@ export function DashboardSidebarWorkspaceStatusProvider({
 	}, [
 		targets,
 		bindingRowsByIndex,
+		statusesByIndex,
 		manualUnread,
-		terminalSeenAt,
 		activeWorkspaceId,
 		activeDiffStats,
 	]);