🤖 fix: eliminate debounce race conditions in ReviewPanel auto-refresh

Refactored the file-modifying tool debounce to prevent stale closures from
causing unreliable refresh behavior.

## Changes

- Moved debounce timer to a ref (debounceTimerRef) so it's accessible from any
  code path without closure capture
- Unified duplicate refresh logic (performRefresh + handleRefreshRef) into a
  single handleRefreshRef that's updated on every render
- Timer callback now invokes through ref to read latest state at execution time
- Removed filters.diffBase from effect dependencies since the ref-based approach
  handles it correctly

## Race condition fixes

1. **Stale closure capture**: Previously, the timer captured `filters.diffBase`
   at schedule time. Now it reads `filters.diffBase` at execution time via ref.

2. **Multiple timers**: The ref-based timer ensures only one timer exists,
   preventing duplicate refreshes when dependencies change during debounce window.

3. **Cleanup reliability**: Timer ref can be cleared from cleanup without
   depending on closure variable still being in scope.

---
_Generated with `mux` • Model: `anthropic:claude-opus-4-5` • Thinking: `high`_

Author: ammar-agent

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

@@ -259,65 +259,86 @@ export const ReviewPanel: React.FC<ReviewPanelProps> = ({
     includeUncommitted: includeUncommitted,
   });
 
-  // Auto-refresh on file-modifying tool completions (debounced 3s).
-  // Respects user interaction - if user is focused on review input, queues refresh for after blur.
-  useEffect(() => {
+  // Stable refresh handler via ref - always reads latest state at execution time.
+  // This avoids stale closure issues when debounced timers fire.
+  const handleRefreshRef = useRef<() => void>(() => {
+    console.debug("ReviewPanel handleRefreshRef called before init");
+  });
+  handleRefreshRef.current = () => {
     if (!api || isCreating) return;
 
-    let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+    // Skip if document not visible (user switched tabs/windows)
+    if (document.hidden) return;
 
-    const performRefresh = () => {
-      // Skip if document not visible (user switched tabs/windows)
-      if (document.hidden) return;
+    // Skip if user is actively entering a review note
+    if (isUserInteractingRef.current) {
+      pendingRefreshRef.current = true;
+      return;
+    }
 
-      // Skip if user is actively entering a review note
-      if (isUserInteractingRef.current) {
-        pendingRefreshRef.current = true;
-        return;
-      }
+    // Skip if already refreshing (for origin/* bases with fetch)
+    if (isRefreshingRef.current) return;
 
-      // Skip if already refreshing (for origin/* bases with fetch)
-      if (isRefreshingRef.current) return;
-
-      // Save scroll position before refresh
-      savedScrollTopRef.current = scrollContainerRef.current?.scrollTop ?? null;
-
-      const originBranch = getOriginBranchForFetch(filters.diffBase);
-      if (originBranch) {
-        // Remote base: fetch before refreshing diff
-        isRefreshingRef.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;
-            setRefreshTrigger((prev) => prev + 1);
-          });
-      } else {
-        // Local base: just refresh diff
-        setRefreshTrigger((prev) => prev + 1);
-      }
-    };
+    // Save scroll position before refresh
+    savedScrollTopRef.current = scrollContainerRef.current?.scrollTop ?? null;
+
+    const originBranch = getOriginBranchForFetch(filters.diffBase);
+    if (originBranch) {
+      isRefreshingRef.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;
+          setRefreshTrigger((prev) => prev + 1);
+        });
+
+      return;
+    }
+
+    setRefreshTrigger((prev) => prev + 1);
+  };
+
+  const handleRefresh = () => {
+    handleRefreshRef.current();
+  };
+
+  // Debounce timer ref - lives outside effect to prevent stale closure issues.
+  // Using a ref allows cleanup from any code path without closure capture.
+  const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  // Auto-refresh on file-modifying tool completions (debounced 3s).
+  // Respects user interaction - if user is focused on review input, queues refresh for after blur.
+  useEffect(() => {
+    if (!api || isCreating) return;
 
     const scheduleRefresh = () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(performRefresh, TOOL_REFRESH_DEBOUNCE_MS);
+      if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
+      // Call through ref to get latest state at execution time
+      debounceTimerRef.current = setTimeout(() => {
+        debounceTimerRef.current = null;
+        handleRefreshRef.current();
+      }, TOOL_REFRESH_DEBOUNCE_MS);
     };
 
     // Subscribe to file-modifying tool completions for this workspace
     const unsubscribe = workspaceStore.subscribeFileModifyingTool(workspaceId, scheduleRefresh);
 
     return () => {
       unsubscribe();
-      if (debounceTimer) clearTimeout(debounceTimer);
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = null;
+      }
     };
-  }, [api, workspaceId, filters.diffBase, isCreating]);
+  }, [api, workspaceId, isCreating]);
 
   // Sync panel focus with interaction tracking; fire pending refresh on blur
   useEffect(() => {
@@ -343,46 +364,6 @@ export const ReviewPanel: React.FC<ReviewPanelProps> = ({
   }, [diffState.status]);
 
   // Focus panel when focusTrigger changes (preserves current hunk selection)
-
-  const handleRefreshRef = useRef<() => void>(() => {
-    console.debug("ReviewPanel handleRefreshRef called before init");
-  });
-  handleRefreshRef.current = () => {
-    if (!api || isCreating) return;
-
-    // Skip if already refreshing (for origin/* bases with fetch)
-    if (isRefreshingRef.current) {
-      setRefreshTrigger((prev) => prev + 1);
-      return;
-    }
-
-    const originBranch = getOriginBranchForFetch(filters.diffBase);
-    if (originBranch) {
-      isRefreshingRef.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;
-          setRefreshTrigger((prev) => prev + 1);
-        });
-
-      return;
-    }
-
-    setRefreshTrigger((prev) => prev + 1);
-  };
-
-  const handleRefresh = () => {
-    handleRefreshRef.current();
-  };
   useEffect(() => {
     if (focusTrigger && focusTrigger > 0) {
       panelRef.current?.focus();