perf: 1s debounce for active workspace git status

Active workspace now uses 1s debounce for git status refresh after
file-modifying tools complete, while background workspaces keep 3s.

This makes the visible git indicators feel more responsive without
adding load from background workspace refreshes.

Author: ammar-agent

src/browser/App.tsx

@@ -17,6 +17,7 @@ import { buildSortedWorkspacesByProject } from "./utils/ui/workspaceFiltering";
 import { useResumeManager } from "./hooks/useResumeManager";
 import { useUnreadTracking } from "./hooks/useUnreadTracking";
 import { useWorkspaceStoreRaw, useWorkspaceRecency } from "./stores/WorkspaceStore";
+import { setActiveWorkspace } from "./stores/GitStatusStore";
 
 import { useStableReference, compareMaps } from "./hooks/useStableReference";
 import { CommandRegistryProvider, useCommandRegistry } from "./contexts/CommandRegistryContext";
@@ -133,6 +134,11 @@ function AppInner() {
     prevWorkspaceRef.current = selectedWorkspace;
   }, [selectedWorkspace, telemetry]);
 
+  // Tell GitStatusStore which workspace is active (for prioritized 1s refresh)
+  useEffect(() => {
+    setActiveWorkspace(selectedWorkspace?.workspaceId ?? null);
+  }, [selectedWorkspace?.workspaceId]);
+
   // Track last-read timestamps for unread indicators
   const { lastReadTimestamps, onToggleUnread } = useUnreadTracking(selectedWorkspace);
 

src/browser/components/RightSidebar/CodeReview/ReviewPanel.tsx

@@ -94,6 +94,31 @@ type DiffState =
 const REVIEW_PANEL_CACHE_MAX_ENTRIES = 20;
 const REVIEW_PANEL_CACHE_MAX_SIZE_BYTES = 20 * 1024 * 1024; // 20MB
 
+/**
+ * Preserve object references for unchanged hunks to prevent re-renders.
+ * Compares by ID and content - if a hunk exists in prev with same content, reuse it.
+ */
+function preserveHunkReferences(prev: DiffHunk[], next: DiffHunk[]): DiffHunk[] {
+  if (prev.length === 0) return next;
+
+  const prevById = new Map(prev.map((h) => [h.id, h]));
+  let allSame = prev.length === next.length;
+
+  const result = next.map((hunk, i) => {
+    const prevHunk = prevById.get(hunk.id);
+    // Fast path: same ID and content means unchanged (content hash is part of ID)
+    if (prevHunk && prevHunk.content === hunk.content) {
+      if (allSame && prev[i]?.id !== hunk.id) allSame = false;
+      return prevHunk;
+    }
+    allSame = false;
+    return hunk;
+  });
+
+  // If all hunks are reused in same order, return prev array to preserve top-level reference
+  return allSame ? prev : result;
+}
+
 interface ReviewPanelDiffCacheValue {
   hunks: DiffHunk[];
   truncationWarning: string | null;
@@ -458,10 +483,19 @@ export const ReviewPanel: React.FC<ReviewPanelProps> = ({
         if (cancelled) return;
 
         setDiagnosticInfo(data.diagnosticInfo);
-        setDiffState({
-          status: "loaded",
-          hunks: data.hunks,
-          truncationWarning: data.truncationWarning,
+
+        // Preserve object references for unchanged hunks to prevent unnecessary re-renders.
+        // HunkViewer is memoized on hunk object identity, so reusing references avoids
+        // re-rendering (and re-highlighting) hunks that haven't actually changed.
+        setDiffState((prev) => {
+          const prevHunks =
+            prev.status === "loaded" || prev.status === "refreshing" ? prev.hunks : [];
+          const hunks = preserveHunkReferences(prevHunks, data.hunks);
+          return {
+            status: "loaded",
+            hunks,
+            truncationWarning: data.truncationWarning,
+          };
         });
 
         if (data.hunks.length > 0) {

src/browser/hooks/useReviewRefreshController.ts

@@ -1,6 +1,7 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, useMemo } from "react";
 import { workspaceStore } from "@/browser/stores/WorkspaceStore";
 import type { APIClient } from "@/browser/contexts/API";
+import { RefreshController } from "@/browser/utils/RefreshController";
 
 /** Debounce delay for auto-refresh after tool completion */
 const TOOL_REFRESH_DEBOUNCE_MS = 3000;
@@ -47,229 +48,80 @@ export interface ReviewRefreshController {
 /**
  * Controls ReviewPanel auto-refresh triggered by file-modifying tool completions.
  *
- * Handles:
- * - Debouncing rapid tool completions (3s window)
- * - Pausing while user is interacting (review note input focused)
- * - Pausing while tab is hidden (flush on visibility change)
- * - Coalescing requests while origin fetch is in-flight
- * - Preserving scroll position across refreshes
- *
- * Architecture:
- * - All refresh logic flows through a single ref-based handler to avoid stale closures
- * - Pending flags track deferred refreshes for various pause conditions
- * - visibilitychange listener ensures hidden-tab refreshes aren't lost
+ * Delegates debouncing, visibility/focus handling, and in-flight guards to RefreshController.
+ * Keeps ReviewPanel-specific logic:
+ * - Origin branch fetch before refresh
+ * - Scroll position preservation
+ * - User interaction pause state
  */
 export function useReviewRefreshController(
   options: UseReviewRefreshControllerOptions
 ): ReviewRefreshController {
   const { workspaceId, api, isCreating, onRefresh, scrollContainerRef, onGitStatusRefresh } =
     options;
 
-  // Store diffBase in a ref so we always read the latest value
+  // Refs for values that executeRefresh needs at call time (avoid stale closures)
   const diffBaseRef = useRef(options.diffBase);
   diffBaseRef.current = options.diffBase;
 
-  // Store onGitStatusRefresh in a ref to avoid stale closures
   const onGitStatusRefreshRef = useRef(onGitStatusRefresh);
   onGitStatusRefreshRef.current = onGitStatusRefresh;
 
-  // State refs (avoid re-renders, just track state for refresh logic)
-  const isRefreshingRef = useRef(false);
-  const isInteractingRef = useRef(false);
-  const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  // Pending flags - track why refresh was deferred
-  const pendingBecauseHiddenRef = useRef(false);
-  const pendingBecauseInteractingRef = useRef(false);
-  const pendingBecauseInFlightRef = useRef(false);
-
   // Scroll position to restore after refresh
   const savedScrollTopRef = useRef<number | null>(null);
 
-  // Expose isRefreshing for UI (e.g. disable refresh button)
-  // We use a ref but also track in a simple way for the return value
-  const isRefreshingForReturn = useRef(false);
-
-  /**
-   * Core refresh execution - handles origin fetch if needed, then triggers onRefresh.
-   * Always reads latest state from refs at execution time.
-   */
-  const executeRefresh = useRef(() => {
-    if (!api || isCreating) return;
-
-    // Save scroll position before refresh
-    savedScrollTopRef.current = scrollContainerRef.current?.scrollTop ?? null;
-
-    const originBranch = getOriginBranchForFetch(diffBaseRef.current);
-    if (originBranch) {
-      isRefreshingRef.current = true;
-      isRefreshingForReturn.current = true;
-
-      api.workspace
-        .executeBash({
-          workspaceId,
-          script: `git fetch origin ${originBranch} --quiet || true`,
-          options: { timeout_secs: 30 },
-        })
-        .catch((err) => {
-          console.debug("ReviewPanel origin fetch failed", err);
-        })
-        .finally(() => {
-          isRefreshingRef.current = false;
-          isRefreshingForReturn.current = false;
-          onRefresh();
-          onGitStatusRefreshRef.current?.();
-
-          // If another refresh was requested while we were fetching, do it now
-          if (pendingBecauseInFlightRef.current) {
-            pendingBecauseInFlightRef.current = false;
-            // Use setTimeout to avoid recursive call stack
-            setTimeout(() => tryRefresh("in-flight-followup"), 0);
-          }
-        });
-
-      return;
-    }
-
-    // Local base - just trigger refresh immediately
-    onRefresh();
-    onGitStatusRefreshRef.current?.();
-  });
-
-  // Update executeRefresh closure dependencies
-  executeRefresh.current = () => {
-    if (!api || isCreating) return;
-
-    savedScrollTopRef.current = scrollContainerRef.current?.scrollTop ?? null;
-
-    const originBranch = getOriginBranchForFetch(diffBaseRef.current);
-    if (originBranch) {
-      isRefreshingRef.current = true;
-      isRefreshingForReturn.current = true;
-
-      api.workspace
-        .executeBash({
-          workspaceId,
-          script: `git fetch origin ${originBranch} --quiet || true`,
-          options: { timeout_secs: 30 },
-        })
-        .catch((err) => {
-          console.debug("ReviewPanel origin fetch failed", err);
-        })
-        .finally(() => {
-          isRefreshingRef.current = false;
-          isRefreshingForReturn.current = false;
-          onRefresh();
-          onGitStatusRefreshRef.current?.();
+  // User interaction state (pauses auto-refresh)
+  const isInteractingRef = useRef(false);
 
-          if (pendingBecauseInFlightRef.current) {
-            pendingBecauseInFlightRef.current = false;
-            setTimeout(() => tryRefresh("in-flight-followup"), 0);
+  // Create RefreshController once, with stable callbacks via refs
+  const controller = useMemo(() => {
+    const ctrl = new RefreshController({
+      debounceMs: TOOL_REFRESH_DEBOUNCE_MS,
+      isPaused: () => isInteractingRef.current,
+      onRefresh: async () => {
+        if (!api || isCreating) return;
+
+        // Save scroll position before refresh
+        savedScrollTopRef.current = scrollContainerRef.current?.scrollTop ?? null;
+
+        const originBranch = getOriginBranchForFetch(diffBaseRef.current);
+        if (originBranch) {
+          try {
+            await api.workspace.executeBash({
+              workspaceId,
+              script: `git fetch origin ${originBranch} --quiet || true`,
+              options: { timeout_secs: 30 },
+            });
+          } catch (err) {
+            console.debug("ReviewPanel origin fetch failed", err);
           }
-        });
-
-      return;
-    }
-
-    onRefresh();
-    onGitStatusRefreshRef.current?.();
-  };
-
-  /**
-   * Attempt to refresh, respecting all pause conditions.
-   * If paused, sets the appropriate pending flag.
-   */
-  const tryRefresh = (_reason: string) => {
-    if (!api || isCreating) return;
-
-    // Check pause conditions in order of priority
-
-    // 1. Tab hidden - queue for visibility change
-    if (document.hidden) {
-      pendingBecauseHiddenRef.current = true;
-      return;
-    }
-
-    // 2. User interacting - queue for blur
-    if (isInteractingRef.current) {
-      pendingBecauseInteractingRef.current = true;
-      return;
-    }
-
-    // 3. Already refreshing (origin fetch in-flight) - queue for completion
-    if (isRefreshingRef.current) {
-      pendingBecauseInFlightRef.current = true;
-      return;
-    }
-
-    // All clear - execute refresh
-    executeRefresh.current();
-  };
-
-  /**
-   * Schedule a debounced refresh (for tool completions).
-   */
-  const scheduleRefresh = () => {
-    if (debounceTimerRef.current) {
-      clearTimeout(debounceTimerRef.current);
-    }
-    debounceTimerRef.current = setTimeout(() => {
-      debounceTimerRef.current = null;
-      tryRefresh("tool-completion");
-    }, TOOL_REFRESH_DEBOUNCE_MS);
-  };
-
-  /**
-   * Flush any pending refresh (called when pause condition clears).
-   */
-  const flushPending = (clearedCondition: "hidden" | "interacting") => {
-    if (clearedCondition === "hidden" && pendingBecauseHiddenRef.current) {
-      pendingBecauseHiddenRef.current = false;
-      tryRefresh("visibility-restored");
-    } else if (clearedCondition === "interacting" && pendingBecauseInteractingRef.current) {
-      pendingBecauseInteractingRef.current = false;
-      tryRefresh("interaction-ended");
-    }
-  };
+        }
+
+        onRefresh();
+        onGitStatusRefreshRef.current?.();
+      },
+    });
+    ctrl.bindListeners();
+    return ctrl;
+    // workspaceId/api/isCreating changes require new controller with updated closure
+  }, [workspaceId, api, isCreating, onRefresh, scrollContainerRef]);
+
+  // Cleanup on unmount or when controller changes
+  useEffect(() => {
+    return () => controller.dispose();
+  }, [controller]);
 
   // Subscribe to file-modifying tool completions
   useEffect(() => {
     if (!api || isCreating) return;
 
-    const unsubscribe = workspaceStore.subscribeFileModifyingTool(scheduleRefresh, workspaceId);
-
-    return () => {
-      unsubscribe();
-      if (debounceTimerRef.current) {
-        clearTimeout(debounceTimerRef.current);
-        debounceTimerRef.current = null;
-      }
-    };
-    // scheduleRefresh is stable (only uses refs internally)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [api, workspaceId, isCreating]);
+    const unsubscribe = workspaceStore.subscribeFileModifyingTool(
+      () => controller.schedule(),
+      workspaceId
+    );
 
-  // Handle visibility/focus changes - flush pending refresh when user returns.
-  // Uses both visibilitychange (for browser tab hidden state) and window focus
-  // (for Electron app focus) since visibilitychange alone is unreliable in Electron
-  // when the app is behind other windows or on a different desktop/space.
-  useEffect(() => {
-    const handleReturn = () => {
-      // Only flush if document is actually visible
-      if (!document.hidden) {
-        flushPending("hidden");
-      }
-    };
-
-    document.addEventListener("visibilitychange", handleReturn);
-    window.addEventListener("focus", handleReturn);
-    return () => {
-      document.removeEventListener("visibilitychange", handleReturn);
-      window.removeEventListener("focus", handleReturn);
-    };
-    // flushPending is stable (only uses refs internally)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
+    return unsubscribe;
+  }, [api, workspaceId, isCreating, controller]);
 
   // Public API
   const setInteracting = (interacting: boolean) => {
@@ -278,24 +130,19 @@ export function useReviewRefreshController(
 
     // If interaction ended, flush any pending refresh
     if (wasInteracting && !interacting) {
-      flushPending("interacting");
+      controller.notifyUnpaused();
     }
   };
 
   const requestManualRefresh = () => {
-    // Manual refresh bypasses debounce but still respects in-flight check
-    if (isRefreshingRef.current) {
-      pendingBecauseInFlightRef.current = true;
-      return;
-    }
-    executeRefresh.current();
+    controller.requestImmediate();
   };
 
   return {
     requestManualRefresh,
     setInteracting,
     get isRefreshing() {
-      return isRefreshingForReturn.current;
+      return controller.isRefreshing;
     },
   };
 }