diff --git a/src/web-ui/src/app/components/panels/content-canvas/ContentCanvas.tsx b/src/web-ui/src/app/components/panels/content-canvas/ContentCanvas.tsx
index 036903dd..f2dc4ad8 100644
--- a/src/web-ui/src/app/components/panels/content-canvas/ContentCanvas.tsx
+++ b/src/web-ui/src/app/components/panels/content-canvas/ContentCanvas.tsx
@@ -18,6 +18,8 @@ export interface ContentCanvasProps {
   workspacePath?: string;
   /** App mode */
   mode?: 'agent' | 'project' | 'git';
+  /** Whether the containing scene is currently visible */
+  isSceneActive?: boolean;
   /** Interaction callback */
   onInteraction?: (itemId: string, userInput: string) => Promise<void>;
   /** Before-close callback */
@@ -29,6 +31,7 @@ export interface ContentCanvasProps {
 export const ContentCanvas: React.FC<ContentCanvasProps> = ({
   workspacePath,
   mode = 'agent',
+  isSceneActive = true,
   onInteraction,
   disablePopOut = false,
 }) => {
@@ -114,6 +117,7 @@ export const ContentCanvas: React.FC<ContentCanvasProps> = ({
         <div className="canvas-content-canvas__editor">
           <EditorArea
             workspacePath={workspacePath}
+            isSceneActive={isSceneActive}
             onOpenMissionControl={handleOpenMissionControl}
             onInteraction={onInteraction}
             onTabCloseWithDirtyCheck={handleCloseWithDirtyCheck}
diff --git a/src/web-ui/src/app/components/panels/content-canvas/editor-area/EditorArea.tsx b/src/web-ui/src/app/components/panels/content-canvas/editor-area/EditorArea.tsx
index 3904b32d..2fc751ea 100644
--- a/src/web-ui/src/app/components/panels/content-canvas/editor-area/EditorArea.tsx
+++ b/src/web-ui/src/app/components/panels/content-canvas/editor-area/EditorArea.tsx
@@ -11,6 +11,7 @@ import type {
 import './EditorArea.scss';
 export interface EditorAreaProps {
   workspacePath?: string;
+  isSceneActive?: boolean;
   onOpenMissionControl?: () => void;
   onInteraction?: (itemId: string, userInput: string) => Promise<void>;
   onTabCloseWithDirtyCheck?: (tabId: string, groupId: EditorGroupId) => Promise<boolean>;
@@ -20,6 +21,7 @@ export interface EditorAreaProps {
 
 export const EditorArea: React.FC<EditorAreaProps> = ({
   workspacePath,
+  isSceneActive = true,
   onOpenMissionControl,
   onInteraction,
   onTabCloseWithDirtyCheck,
@@ -125,6 +127,7 @@ export const EditorArea: React.FC<EditorAreaProps> = ({
       groupId={groupId}
       group={group}
       isActive={activeGroupId === groupId}
+      isSceneActive={isSceneActive}
       draggingTabId={draggingTabId}
       draggingFromGroupId={draggingFromGroupId}
       splitMode={layout.splitMode}
diff --git a/src/web-ui/src/app/components/panels/content-canvas/editor-area/EditorGroup.tsx b/src/web-ui/src/app/components/panels/content-canvas/editor-area/EditorGroup.tsx
index b789165c..1044395b 100644
--- a/src/web-ui/src/app/components/panels/content-canvas/editor-area/EditorGroup.tsx
+++ b/src/web-ui/src/app/components/panels/content-canvas/editor-area/EditorGroup.tsx
@@ -24,6 +24,7 @@ export interface EditorGroupProps {
   groupId: EditorGroupId;
   group: EditorGroupState;
   isActive: boolean;
+  isSceneActive?: boolean;
   draggingTabId: string | null;
   draggingFromGroupId: EditorGroupId | null;
   splitMode: SplitMode;
@@ -50,6 +51,7 @@ export const EditorGroup: React.FC<EditorGroupProps> = ({
   groupId,
   group,
   isActive,
+  isSceneActive = true,
   draggingTabId,
   draggingFromGroupId,
   splitMode,
@@ -174,7 +176,7 @@ export const EditorGroup: React.FC<EditorGroupProps> = ({
               >
                 <FlexiblePanel
                   content={tab.content as any}
-                  isActive={group.activeTabId === tab.id}
+                  isActive={isSceneActive && group.activeTabId === tab.id}
                   onContentChange={group.activeTabId === tab.id ? handleContentChange : undefined}
                   onDirtyStateChange={group.activeTabId === tab.id ? handleDirtyStateChange : undefined}
                   onFileMissingFromDiskChange={
diff --git a/src/web-ui/src/app/hooks/useWindowControls.ts b/src/web-ui/src/app/hooks/useWindowControls.ts
index e6c45d7b..3cc77226 100644
--- a/src/web-ui/src/app/hooks/useWindowControls.ts
+++ b/src/web-ui/src/app/hooks/useWindowControls.ts
@@ -3,6 +3,7 @@ import { getCurrentWindow } from '@tauri-apps/api/window';
 import { useWorkspaceContext } from '../../infrastructure/contexts/WorkspaceContext';
 import { notificationService } from '@/shared/notification-system';
 import { createLogger } from '@/shared/utils/logger';
+import { sendDebugProbe } from '@/shared/utils/debugProbe';
 import { useI18n } from '@/infrastructure/i18n';
 
 const log = createLogger('useWindowControls');
@@ -90,15 +91,54 @@ export const useWindowControls = (options?: { isToolbarMode?: boolean }) => {
       }
       
       if (document.visibilityState === 'visible') {
+        sendDebugProbe(
+          'useWindowControls.ts:handleVisibilityChange',
+          'Window became visible',
+          {
+            isToolbarMode,
+          }
+        );
         try {
           const appWindow = getCurrentWindow();
           // Delay update until window fully restores
           setTimeout(async () => {
-            await updateWindowState(appWindow);
-            await restoreMacOSOverlayTitlebar(appWindow);
+            const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+            try {
+              await updateWindowState(appWindow);
+              await restoreMacOSOverlayTitlebar(appWindow);
+              sendDebugProbe(
+                'useWindowControls.ts:handleVisibilityChange',
+                'Window restore sync completed',
+                {
+                  durationMs:
+                    Math.round(
+                      ((typeof performance !== 'undefined' ? performance.now() : Date.now()) -
+                        startedAt) *
+                        10
+                    ) / 10,
+                  isToolbarMode,
+                }
+              );
+            } catch (error) {
+              sendDebugProbe(
+                'useWindowControls.ts:handleVisibilityChange',
+                'Window restore sync failed',
+                {
+                  error: formatErrorMessage(error),
+                  isToolbarMode,
+                }
+              );
+            }
           }, 300);
-        } catch (_error) {
-          // Ignore errors
+        } catch (error) {
+          sendDebugProbe(
+            'useWindowControls.ts:handleVisibilityChange',
+            'Window restore setup failed',
+            {
+              error: formatErrorMessage(error),
+              isToolbarMode,
+            }
+          );
         }
       }
     };
diff --git a/src/web-ui/src/app/scenes/SceneViewport.tsx b/src/web-ui/src/app/scenes/SceneViewport.tsx
index cc2e9e89..4a42ae82 100644
--- a/src/web-ui/src/app/scenes/SceneViewport.tsx
+++ b/src/web-ui/src/app/scenes/SceneViewport.tsx
@@ -84,7 +84,7 @@ const SceneViewport: React.FC<SceneViewportProps> = ({ workspacePath, isEntering
                   ) : null
                 }
               >
-                {renderScene(tab.id, workspacePath, isEntering)}
+                {renderScene(tab.id, workspacePath, isEntering, isActive)}
               </Suspense>
             </div>
           );
@@ -94,16 +94,21 @@ const SceneViewport: React.FC<SceneViewportProps> = ({ workspacePath, isEntering
   );
 };
 
-function renderScene(id: SceneTabId, workspacePath?: string, isEntering?: boolean) {
+function renderScene(
+  id: SceneTabId,
+  workspacePath?: string,
+  isEntering?: boolean,
+  isActive: boolean = false
+) {
   switch (id) {
     case 'welcome':
       return <WelcomeScene />;
     case 'session':
-      return <SessionScene workspacePath={workspacePath} isEntering={isEntering} />;
+      return <SessionScene workspacePath={workspacePath} isEntering={isEntering} isActive={isActive} />;
     case 'terminal':
-      return <TerminalScene />;
+      return <TerminalScene isActive={isActive} />;
     case 'git':
-      return <GitScene workspacePath={workspacePath} />;
+      return <GitScene workspacePath={workspacePath} isActive={isActive} />;
     case 'settings':
       return <SettingsScene />;
     case 'file-viewer':
@@ -125,7 +130,7 @@ function renderScene(id: SceneTabId, workspacePath?: string, isEntering?: boolea
     case 'insights':
       return <InsightsScene />;
     case 'shell':
-      return <ShellScene />;
+      return <ShellScene isActive={isActive} />;
     case 'panel-view':
       return <PanelViewScene workspacePath={workspacePath} />;
     default:
diff --git a/src/web-ui/src/app/scenes/git/GitScene.tsx b/src/web-ui/src/app/scenes/git/GitScene.tsx
index e17685be..fa6cf439 100644
--- a/src/web-ui/src/app/scenes/git/GitScene.tsx
+++ b/src/web-ui/src/app/scenes/git/GitScene.tsx
@@ -16,9 +16,13 @@ import './GitScene.scss';
 
 interface GitSceneProps {
   workspacePath?: string;
+  isActive?: boolean;
 }
 
-const GitScene: React.FC<GitSceneProps> = ({ workspacePath: workspacePathProp }) => {
+const GitScene: React.FC<GitSceneProps> = ({
+  workspacePath: workspacePathProp,
+  isActive = true,
+}) => {
   const { workspace } = useCurrentWorkspace();
   const workspacePath = workspacePathProp ?? workspace?.rootPath ?? '';
   const { t } = useTranslation('panels/git');
@@ -33,13 +37,16 @@ const GitScene: React.FC<GitSceneProps> = ({ workspacePath: workspacePathProp })
     refresh,
   } = useGitState({
     repositoryPath: workspacePath,
-    isActive: true,
+    isActive,
     refreshOnMount: true,
     layers: ['basic', 'status'],
   });
 
   const repoLoading = statusLoading && !isRepository;
-  const handleRefresh = useCallback(() => refresh({ force: true, layers: ['basic', 'status'], reason: 'manual' }), [refresh]);
+  const handleRefresh = useCallback(
+    () => refresh({ force: true, layers: ['basic', 'status'], reason: 'manual' }),
+    [refresh]
+  );
 
   useEffect(() => {
     if (repoLoading || statusLoading) {
@@ -65,6 +72,22 @@ const GitScene: React.FC<GitSceneProps> = ({ workspacePath: workspacePathProp })
     globalEventBus.emit('fill-chat-input', { content: t('init.chatPrompt') });
   }, [t]);
 
+  const renderView = useCallback(() => {
+    switch (activeView) {
+      case 'branches':
+        return <BranchesView workspacePath={workspacePath} />;
+      case 'graph':
+        return <GraphView workspacePath={workspacePath} />;
+      case 'working-copy':
+      default:
+        return <WorkingCopyView workspacePath={workspacePath} isActive={isActive} />;
+    }
+  }, [activeView, isActive, workspacePath]);
+
+  if (!isActive) {
+    return <div className="bitfun-git-scene" aria-hidden="true" />;
+  }
+
   if (!repoLoading && !isRepository) {
     return (
       <div className="bitfun-git-scene bitfun-git-scene--not-repository">
@@ -120,18 +143,6 @@ const GitScene: React.FC<GitSceneProps> = ({ workspacePath: workspacePathProp })
     );
   }
 
-  const renderView = () => {
-    switch (activeView) {
-      case 'branches':
-        return <BranchesView workspacePath={workspacePath} />;
-      case 'graph':
-        return <GraphView workspacePath={workspacePath} />;
-      case 'working-copy':
-      default:
-        return <WorkingCopyView workspacePath={workspacePath} />;
-    }
-  };
-
   return <div className="bitfun-git-scene">{renderView()}</div>;
 };
 
diff --git a/src/web-ui/src/app/scenes/git/views/WorkingCopyView.tsx b/src/web-ui/src/app/scenes/git/views/WorkingCopyView.tsx
index 5ce331d7..46166f67 100644
--- a/src/web-ui/src/app/scenes/git/views/WorkingCopyView.tsx
+++ b/src/web-ui/src/app/scenes/git/views/WorkingCopyView.tsx
@@ -52,9 +52,13 @@ const FILE_LIST_WIDTH_MAX = 560;
 
 interface WorkingCopyViewProps {
   workspacePath?: string;
+  isActive?: boolean;
 }
 
-const WorkingCopyView: React.FC<WorkingCopyViewProps> = ({ workspacePath }) => {
+const WorkingCopyView: React.FC<WorkingCopyViewProps> = ({
+  workspacePath,
+  isActive = true,
+}) => {
   const { t } = useTranslation('panels/git');
   const notification = useNotification();
 
@@ -76,7 +80,7 @@ const WorkingCopyView: React.FC<WorkingCopyViewProps> = ({ workspacePath }) => {
     refresh,
   } = useGitState({
     repositoryPath: workspacePath ?? '',
-    isActive: true,
+    isActive,
     refreshOnMount: true,
     layers: ['basic', 'status'],
   });
diff --git a/src/web-ui/src/app/scenes/session/AuxPane.tsx b/src/web-ui/src/app/scenes/session/AuxPane.tsx
index dd5be27f..b8c14db2 100644
--- a/src/web-ui/src/app/scenes/session/AuxPane.tsx
+++ b/src/web-ui/src/app/scenes/session/AuxPane.tsx
@@ -26,10 +26,11 @@ export interface AuxPaneRef {
 
 interface AuxPaneProps {
   workspacePath?: string;
+  isSceneActive?: boolean;
 }
 
 const AuxPane = forwardRef<AuxPaneRef, AuxPaneProps>(
-  ({ workspacePath }, ref) => {
+  ({ workspacePath, isSceneActive = true }, ref) => {
     const {
       addTab,
       switchToTab,
@@ -124,6 +125,7 @@ const AuxPane = forwardRef<AuxPaneRef, AuxPaneProps>(
         <ContentCanvas
           workspacePath={workspacePath}
           mode="agent"
+          isSceneActive={isSceneActive}
           onInteraction={handleInteraction}
           onBeforeClose={handleBeforeClose}
         />
diff --git a/src/web-ui/src/app/scenes/session/SessionScene.tsx b/src/web-ui/src/app/scenes/session/SessionScene.tsx
index d99677a0..7c3ac2e8 100644
--- a/src/web-ui/src/app/scenes/session/SessionScene.tsx
+++ b/src/web-ui/src/app/scenes/session/SessionScene.tsx
@@ -36,11 +36,13 @@ import './SessionScene.scss';
 interface SessionSceneProps {
   workspacePath?: string;
   isEntering?: boolean;
+  isActive?: boolean;
 }
 
 const SessionScene: React.FC<SessionSceneProps> = ({
   workspacePath,
   isEntering = false,
+  isActive = true,
 }) => {
   const { t } = useTranslation('flow-chat');
   const { state, updateRightPanelWidth, toggleRightPanel } = useApp();
@@ -296,6 +298,7 @@ const SessionScene: React.FC<SessionSceneProps> = ({
         <AuxPane
           ref={auxPaneRef}
           workspacePath={workspacePath}
+          isSceneActive={isActive}
         />
       </div>
     </div>
diff --git a/src/web-ui/src/app/scenes/shell/ShellScene.tsx b/src/web-ui/src/app/scenes/shell/ShellScene.tsx
index 9bd8b8f5..a6e898dc 100644
--- a/src/web-ui/src/app/scenes/shell/ShellScene.tsx
+++ b/src/web-ui/src/app/scenes/shell/ShellScene.tsx
@@ -3,10 +3,14 @@ import './ShellScene.scss';
 
 const TerminalScene = lazy(() => import('../terminal/TerminalScene'));
 
-const ShellScene: React.FC = () => (
+interface ShellSceneProps {
+  isActive?: boolean;
+}
+
+const ShellScene: React.FC<ShellSceneProps> = ({ isActive = true }) => (
   <div className="bitfun-shell-scene">
     <Suspense fallback={<div className="bitfun-shell-scene__loading" />}>
-      <TerminalScene />
+      <TerminalScene isActive={isActive} />
     </Suspense>
   </div>
 );
diff --git a/src/web-ui/src/app/scenes/terminal/TerminalScene.tsx b/src/web-ui/src/app/scenes/terminal/TerminalScene.tsx
index 59506d82..87deb411 100644
--- a/src/web-ui/src/app/scenes/terminal/TerminalScene.tsx
+++ b/src/web-ui/src/app/scenes/terminal/TerminalScene.tsx
@@ -13,7 +13,11 @@ import { useTerminalSceneStore } from '../../stores/terminalSceneStore';
 import ConnectedTerminal from '../../../tools/terminal/components/ConnectedTerminal';
 import './TerminalScene.scss';
 
-const TerminalScene: React.FC = () => {
+interface TerminalSceneProps {
+  isActive?: boolean;
+}
+
+const TerminalScene: React.FC<TerminalSceneProps> = ({ isActive = true }) => {
   const { activeSessionId, setActiveSession } = useTerminalSceneStore();
   const { t } = useTranslation('panels/terminal');
 
@@ -25,6 +29,10 @@ const TerminalScene: React.FC = () => {
     setActiveSession(null);
   }, [setActiveSession]);
 
+  if (!isActive) {
+    return <div className="bitfun-terminal-scene" aria-hidden="true" />;
+  }
+
   return (
     <div className="bitfun-terminal-scene">
       {activeSessionId ? (
diff --git a/src/web-ui/src/shared/utils/debugProbe.ts b/src/web-ui/src/shared/utils/debugProbe.ts
new file mode 100644
index 00000000..7024e4a2
--- /dev/null
+++ b/src/web-ui/src/shared/utils/debugProbe.ts
@@ -0,0 +1,41 @@
+import { createLogger } from './logger';
+
+type DebugProbeData = Record<string, unknown>;
+
+const log = createLogger('RestoreProbe');
+
+function serializeProbeValue(value: unknown): unknown {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+    };
+  }
+
+  if (value instanceof Set) {
+    return Array.from(value);
+  }
+
+  if (value instanceof Map) {
+    return Object.fromEntries(value);
+  }
+
+  return value;
+}
+
+export function sendDebugProbe(
+  location: string,
+  message: string,
+  data?: DebugProbeData
+): void {
+  const serializedData = data
+    ? Object.fromEntries(
+        Object.entries(data).map(([key, value]) => [key, serializeProbeValue(value)])
+      )
+    : undefined;
+
+  log.info(message, {
+    location,
+    ...serializedData,
+  });
+}
diff --git a/src/web-ui/src/tools/editor/components/CodeEditor.tsx b/src/web-ui/src/tools/editor/components/CodeEditor.tsx
index f498651d..46ddb3ea 100644
--- a/src/web-ui/src/tools/editor/components/CodeEditor.tsx
+++ b/src/web-ui/src/tools/editor/components/CodeEditor.tsx
@@ -24,6 +24,7 @@ import { EditorConfig as EditorConfigType } from '@/infrastructure/config/types'
 import { CubeLoading } from '@/component-library';
 import { getMonacoLanguage } from '@/infrastructure/language-detection';
 import { createLogger } from '@/shared/utils/logger';
+import { sendDebugProbe } from '@/shared/utils/debugProbe';
 import { isSamePath } from '@/shared/utils/pathUtils';
 import {
   diskContentMatchesEditorForExternalSync,
@@ -99,6 +100,14 @@ const LARGE_FILE_EXPANSION_LABELS = ['show more', '显示更多', '展开更多'
 /** Poll disk metadata for open file; only while tab is active (see isActiveTab). */
 const FILE_SYNC_POLL_INTERVAL_MS = 1000;
 
+function getPollOffsetMs(filePath: string): number {
+  let hash = 0;
+  for (let i = 0; i < filePath.length; i++) {
+    hash = ((hash << 5) - hash + filePath.charCodeAt(i)) | 0;
+  }
+  return Math.abs(hash) % 400;
+}
+
 function hasVeryLongLine(content: string, maxLineLength: number): boolean {
   let currentLineLength = 0;
   for (let i = 0; i < content.length; i++) {
@@ -1565,9 +1574,14 @@ const CodeEditor: React.FC<CodeEditorProps> = ({
     }
 
     isCheckingFileRef.current = true;
+    const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    let outcome = 'started';
+    let usedHashFallback = false;
+    let probeError: string | null = null;
 
     try {
       if (typeof document !== 'undefined' && document.visibilityState !== 'visible') {
+        outcome = 'skipped-hidden';
         return;
       }
 
@@ -1576,22 +1590,26 @@ const CodeEditor: React.FC<CodeEditorProps> = ({
         request: { path: filePath }
       });
       if (isFileMissingFromMetadata(fileInfo)) {
+        outcome = 'missing-on-disk';
         reportFileMissingFromDisk(true);
         return;
       }
       reportFileMissingFromDisk(false);
       const currentVersion = diskVersionFromMetadata(fileInfo);
       if (!currentVersion) {
+        outcome = 'missing-version';
         return;
       }
 
       const baseline = diskVersionRef.current;
       if (!baseline) {
         diskVersionRef.current = currentVersion;
+        outcome = 'initialized-baseline';
         return;
       }
 
       if (!diskVersionsDiffer(currentVersion, baseline)) {
+        outcome = 'no-change';
         return;
       }
 
@@ -1608,16 +1626,19 @@ const CodeEditor: React.FC<CodeEditorProps> = ({
           editorMid !== undefined &&
           bufferBeforeRead !== editorMid
         ) {
+          outcome = 'editor-changed-before-hash';
           return;
         }
         if (diskHash && editorMid !== undefined) {
           const editorHash = await editorSyncContentSha256Hex(editorMid);
           if (editorHash === diskHash) {
             diskVersionRef.current = currentVersion;
+            outcome = 'hash-match';
             return;
           }
         }
       } catch (hashErr) {
+        usedHashFallback = true;
         log.warn('get_file_editor_sync_hash failed, falling back to full read', {
           filePath,
           error: hashErr,
@@ -1631,15 +1652,18 @@ const CodeEditor: React.FC<CodeEditorProps> = ({
         editorBuffer !== undefined &&
         bufferBeforeRead !== editorBuffer
       ) {
+        outcome = 'editor-changed-before-read';
         return;
       }
       if (editorBuffer === undefined) {
+        outcome = 'missing-editor-buffer';
         return;
       }
 
       const fileContent = await workspaceAPI.readFileContent(filePath);
       if (diskContentMatchesEditorForExternalSync(fileContent, editorBuffer)) {
         diskVersionRef.current = currentVersion;
+        outcome = 'content-match';
         return;
       }
 
@@ -1656,17 +1680,38 @@ const CodeEditor: React.FC<CodeEditorProps> = ({
         });
         if (!shouldReload) {
           diskVersionRef.current = currentVersion;
+          outcome = 'kept-local-changes';
           return;
         }
       }
 
       applyDiskSnapshotToEditor(fileContent, currentVersion);
+      outcome = 'reloaded-from-disk';
     } catch (err) {
+      outcome = 'error';
+      probeError = err instanceof Error ? err.message : String(err);
       if (isLikelyFileNotFoundError(err)) {
         reportFileMissingFromDisk(true);
       }
       log.error('Failed to check file modification', err);
     } finally {
+      const durationMs =
+        Math.round(
+          ((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt) * 10
+        ) / 10;
+      if (probeError || outcome !== 'no-change' || durationMs >= 80) {
+        sendDebugProbe(
+          'CodeEditor.tsx:checkFileModification',
+          'Code editor disk sync completed',
+          {
+            filePath,
+            outcome,
+            durationMs,
+            usedHashFallback,
+            error: probeError,
+          }
+        );
+      }
       isCheckingFileRef.current = false;
     }
   }, [applyDiskSnapshotToEditor, filePath, isActiveTab, reportFileMissingFromDisk, t]);
@@ -1694,13 +1739,18 @@ const CodeEditor: React.FC<CodeEditorProps> = ({
     const tick = () => {
       void checkFileModification();
     };
-
-    const intervalId = window.setInterval(tick, FILE_SYNC_POLL_INTERVAL_MS);
-    document.addEventListener('visibilitychange', tick);
+    const pollOffsetMs = getPollOffsetMs(filePath);
+    let intervalId: number | null = null;
+    const timeoutId = window.setTimeout(() => {
+      tick();
+      intervalId = window.setInterval(tick, FILE_SYNC_POLL_INTERVAL_MS + pollOffsetMs);
+    }, 250 + pollOffsetMs);
 
     return () => {
-      window.clearInterval(intervalId);
-      document.removeEventListener('visibilitychange', tick);
+      window.clearTimeout(timeoutId);
+      if (intervalId !== null) {
+        window.clearInterval(intervalId);
+      }
     };
   }, [checkFileModification, filePath, isActiveTab]);
 
diff --git a/src/web-ui/src/tools/editor/components/MarkdownEditor.tsx b/src/web-ui/src/tools/editor/components/MarkdownEditor.tsx
index 17dddd84..41485c87 100644
--- a/src/web-ui/src/tools/editor/components/MarkdownEditor.tsx
+++ b/src/web-ui/src/tools/editor/components/MarkdownEditor.tsx
@@ -11,6 +11,7 @@ import type { EditorInstance } from '../meditor';
 import { analyzeMarkdownEditability, type MarkdownEditabilityAnalysis } from '../meditor/utils/tiptapMarkdown';
 import { AlertCircle } from 'lucide-react';
 import { createLogger } from '@/shared/utils/logger';
+import { sendDebugProbe } from '@/shared/utils/debugProbe';
 import { globalEventBus } from '@/infrastructure/event-bus';
 import { CubeLoading, Button } from '@/component-library';
 import { useI18n } from '@/infrastructure/i18n';
@@ -35,6 +36,14 @@ const log = createLogger('MarkdownEditor');
 
 const FILE_SYNC_POLL_INTERVAL_MS = 1000;
 
+function getPollOffsetMs(filePath: string): number {
+  let hash = 0;
+  for (let i = 0; i < filePath.length; i++) {
+    hash = ((hash << 5) - hash + filePath.charCodeAt(i)) | 0;
+  }
+  return Math.abs(hash) % 400;
+}
+
 export interface MarkdownEditorProps {
   /** File path - loads from file if provided, otherwise uses initialContent */
   filePath?: string;
@@ -267,6 +276,9 @@ const MarkdownEditor: React.FC<MarkdownEditorProps> = ({
     }
 
     isCheckingDiskRef.current = true;
+    const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    let outcome = 'started';
+    let probeError: string | null = null;
     try {
       const { workspaceAPI } = await import('@/infrastructure/api');
       const { invoke } = await import('@tauri-apps/api/core');
@@ -274,31 +286,37 @@ const MarkdownEditor: React.FC<MarkdownEditorProps> = ({
         request: { path: filePath },
       });
       if (isFileMissingFromMetadata(fileInfo)) {
+        outcome = 'missing-on-disk';
         reportFileMissingFromDisk(true);
         return;
       }
       reportFileMissingFromDisk(false);
       const currentVersion = diskVersionFromMetadata(fileInfo);
       if (!currentVersion) {
+        outcome = 'missing-version';
         return;
       }
       const baseline = diskVersionRef.current;
       if (!baseline) {
         diskVersionRef.current = currentVersion;
+        outcome = 'initialized-baseline';
         return;
       }
       if (!diskVersionsDiffer(currentVersion, baseline)) {
+        outcome = 'no-change';
         return;
       }
 
       const localBefore = contentRef.current;
       const raw = await workspaceAPI.readFileContent(filePath);
       if (localBefore !== contentRef.current) {
+        outcome = 'editor-changed-before-read';
         return;
       }
       const { nextEditability, nextContent } = toNormalizedMarkdown(raw);
       if (nextContent === contentRef.current) {
         diskVersionRef.current = currentVersion;
+        outcome = 'content-match';
         return;
       }
 
@@ -313,6 +331,7 @@ const MarkdownEditor: React.FC<MarkdownEditorProps> = ({
         });
         if (!shouldReload) {
           diskVersionRef.current = currentVersion;
+          outcome = 'kept-local-changes';
           return;
         }
       }
@@ -340,12 +359,31 @@ const MarkdownEditor: React.FC<MarkdownEditorProps> = ({
           diskVersionRef.current = vAfter;
         }
       }
+      outcome = 'reloaded-from-disk';
     } catch (e) {
+      outcome = 'error';
+      probeError = e instanceof Error ? e.message : String(e);
       if (isLikelyFileNotFoundError(e)) {
         reportFileMissingFromDisk(true);
       }
       log.error('Markdown disk sync check failed', e);
     } finally {
+      const durationMs =
+        Math.round(
+          ((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt) * 10
+        ) / 10;
+      if (probeError || outcome !== 'no-change' || durationMs >= 80) {
+        sendDebugProbe(
+          'MarkdownEditor.tsx:checkMarkdownDisk',
+          'Markdown editor disk sync completed',
+          {
+            filePath,
+            outcome,
+            durationMs,
+            error: probeError,
+          }
+        );
+      }
       isCheckingDiskRef.current = false;
     }
   }, [filePath, isActiveTab, reportFileMissingFromDisk, t, toNormalizedMarkdown]);
@@ -364,11 +402,17 @@ const MarkdownEditor: React.FC<MarkdownEditorProps> = ({
     const tick = () => {
       void checkMarkdownDisk();
     };
-    const intervalId = window.setInterval(tick, FILE_SYNC_POLL_INTERVAL_MS);
-    document.addEventListener('visibilitychange', tick);
+    const pollOffsetMs = getPollOffsetMs(filePath);
+    let intervalId: number | null = null;
+    const timeoutId = window.setTimeout(() => {
+      tick();
+      intervalId = window.setInterval(tick, FILE_SYNC_POLL_INTERVAL_MS + pollOffsetMs);
+    }, 250 + pollOffsetMs);
     return () => {
-      window.clearInterval(intervalId);
-      document.removeEventListener('visibilitychange', tick);
+      window.clearTimeout(timeoutId);
+      if (intervalId !== null) {
+        window.clearInterval(intervalId);
+      }
     };
   }, [checkMarkdownDisk, filePath, isActiveTab, pollMarkdownDisk]);
 
diff --git a/src/web-ui/src/tools/git/hooks/useGitState.ts b/src/web-ui/src/tools/git/hooks/useGitState.ts
index dfc3bb79..3bd27d29 100644
--- a/src/web-ui/src/tools/git/hooks/useGitState.ts
+++ b/src/web-ui/src/tools/git/hooks/useGitState.ts
@@ -30,6 +30,7 @@
 
 import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
 import { gitStateManager } from '../state/GitStateManager';
+import { sendDebugProbe } from '@/shared/utils/debugProbe';
 import {
   GitState,
   UseGitStateOptions,
@@ -41,6 +42,7 @@ export function useGitState(options: UseGitStateOptions): UseGitStateReturn {
   const {
     repositoryPath,
     isActive = true,
+    participateInWindowFocusRefresh = true,
     selector,
     refreshOnMount = true,
     refreshOnActive = true,
@@ -105,19 +107,31 @@ export function useGitState(options: UseGitStateOptions): UseGitStateReturn {
 
   const isFirstMountRef = useRef(true);
 
+  useEffect(() => {
+    if (!normalizedPath || !isActive || !participateInWindowFocusRefresh) {
+      return;
+    }
+
+    return gitStateManager.registerWindowFocusRefresh(normalizedPath);
+  }, [isActive, normalizedPath, participateInWindowFocusRefresh]);
+
   useEffect(() => {
     if (!normalizedPath) return;
 
     const isFirstMount = isFirstMountRef.current;
     isFirstMountRef.current = false;
 
-    gitStateManager.setVisibility(normalizedPath, isActive);
-
     const shouldRefresh = 
       (isFirstMount && refreshOnMount) ||
       (!isFirstMount && isActive && !prevActiveRef.current && refreshOnActive);
 
     if (shouldRefresh) {
+      sendDebugProbe('useGitState.ts:visibilityEffect', 'Git refresh requested', {
+        repositoryPath: normalizedPath,
+        isActive,
+        reason: isFirstMount ? 'mount' : 'visibility',
+        layers: layersRef.current || ['basic', 'status'],
+      });
       gitStateManager.refresh(normalizedPath, {
         layers: layersRef.current || ['basic', 'status'],
         reason: isFirstMount ? 'mount' : 'visibility',
@@ -125,10 +139,6 @@ export function useGitState(options: UseGitStateOptions): UseGitStateReturn {
     }
 
     prevActiveRef.current = isActive;
-
-    return () => {
-      gitStateManager.setVisibility(normalizedPath, false);
-    };
   }, [isActive, normalizedPath, refreshOnMount, refreshOnActive]);
 
   const refresh = useCallback(
@@ -188,6 +198,7 @@ export function useGitBasicInfo(repositoryPath: string) {
   return useGitState({
     repositoryPath,
     isActive: true,
+    participateInWindowFocusRefresh: false,
     layers: ['basic'],
     refreshOnMount: true,
     refreshOnActive: false,
diff --git a/src/web-ui/src/tools/git/state/GitStateManager.ts b/src/web-ui/src/tools/git/state/GitStateManager.ts
index 340d50e3..2beef1c4 100644
--- a/src/web-ui/src/tools/git/state/GitStateManager.ts
+++ b/src/web-ui/src/tools/git/state/GitStateManager.ts
@@ -32,6 +32,7 @@ import {
   GitStateChangedEventData,
 } from './types';
 import { createLogger } from '@/shared/utils/logger';
+import { sendDebugProbe } from '@/shared/utils/debugProbe';
 import { i18nService } from '@/infrastructure/i18n';
 
 const log = createLogger('GitStateManager');
@@ -54,7 +55,7 @@ export class GitStateManager {
 
   private states = new Map<string, GitState>();
   private subscribers = new Map<string, Set<SubscriberEntry>>();
-  private visibleRepositories = new Set<string>();
+  private windowFocusRefreshCounts = new Map<string, number>();
   private refreshDebounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private refreshLocks = new Map<string, Promise<void>>();
   private pendingRefreshes = new Map<string, PendingRefresh>();
@@ -155,31 +156,22 @@ export class GitStateManager {
   }
 
   /**
-   * Track panel visibility for a repository.
-   *
-   * Note: this does not trigger a refresh. Refresh scheduling is owned by `useGitState`
-   * to avoid duplicate refreshes.
+   * Register a consumer that wants automatic refresh on window focus.
+   * Multiple concurrent consumers for the same repository are reference-counted.
    */
-  setVisibility(repositoryPath: string, visible: boolean): void {
+  registerWindowFocusRefresh(repositoryPath: string): () => void {
     const normalizedPath = this.normalizePath(repositoryPath);
-    const wasVisible = this.visibleRepositories.has(normalizedPath);
+    const nextCount = (this.windowFocusRefreshCounts.get(normalizedPath) ?? 0) + 1;
+    this.windowFocusRefreshCounts.set(normalizedPath, nextCount);
 
-    if (visible) {
-      if (!wasVisible) {
-        this.visibleRepositories.add(normalizedPath);
-      }
-    } else {
-      if (wasVisible) {
-        this.visibleRepositories.delete(normalizedPath);
+    return () => {
+      const currentCount = this.windowFocusRefreshCounts.get(normalizedPath) ?? 0;
+      if (currentCount <= 1) {
+        this.windowFocusRefreshCounts.delete(normalizedPath);
+        return;
       }
-    }
-  }
-
-  /**
-   * Whether the repository is currently visible.
-   */
-  isVisible(repositoryPath: string): boolean {
-    return this.visibleRepositories.has(this.normalizePath(repositoryPath));
+      this.windowFocusRefreshCounts.set(normalizedPath, currentCount - 1);
+    };
   }
 
   /**
@@ -227,7 +219,7 @@ export class GitStateManager {
 
     this.states.clear();
 
-    this.visibleRepositories.clear();
+    this.windowFocusRefreshCounts.clear();
   }
 
   // -------------------------------------------------------------------------
@@ -341,6 +333,11 @@ export class GitStateManager {
       return;
     }
 
+    const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    const shouldProbeReason =
+      reason === 'window-focus' || reason === 'visibility' || reason === 'mount';
+    let probeError: string | null = null;
+    let probeOutcome = 'completed';
 
     let state = this.getOrCreateState(repositoryPath);
     const prevState = { ...state };
@@ -352,6 +349,15 @@ export class GitStateManager {
       : layers.filter((layer) => this.isCacheExpired(state, layer, now));
 
     if (layersToRefresh.length === 0) {
+      if (shouldProbeReason) {
+        sendDebugProbe('GitStateManager.ts:doRefresh', 'Git refresh skipped by cache', {
+          repositoryPath,
+          reason,
+          force,
+          silent,
+          requestedLayers: layers,
+        });
+      }
       return;
     }
 
@@ -401,6 +407,8 @@ export class GitStateManager {
         this.emitStateChanged(repositoryPath, finalState, layersToRefresh, reason);
 
       } catch (error) {
+        probeOutcome = 'error';
+        probeError = error instanceof Error ? error.message : String(error);
         const errorMessage = error instanceof Error ? error.message : i18nService.t('panels/git:errors.refreshFailed');
         log.error('Refresh failed', { repositoryPath, layersToRefresh, error });
 
@@ -412,6 +420,24 @@ export class GitStateManager {
 
         throw error;
       } finally {
+        const durationMs =
+          Math.round(
+            ((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt) *
+              10
+          ) / 10;
+        if (probeError || shouldProbeReason || durationMs >= 80) {
+          sendDebugProbe('GitStateManager.ts:doRefresh', 'Git refresh completed', {
+            repositoryPath,
+            reason,
+            force,
+            silent,
+            requestedLayers: layers,
+            refreshedLayers: layersToRefresh,
+            durationMs,
+            outcome: probeOutcome,
+            error: probeError,
+          });
+        }
         this.refreshLocks.delete(repositoryPath);
       }
     })();
@@ -644,7 +670,12 @@ export class GitStateManager {
   }
 
   private handleWindowFocus = (): void => {
-    for (const repoPath of this.visibleRepositories) {
+    const repositories = Array.from(this.windowFocusRefreshCounts.keys());
+    sendDebugProbe('GitStateManager.ts:handleWindowFocus', 'Git window focus refresh queued', {
+      participatingRepositoryCount: repositories.length,
+      repositories,
+    });
+    for (const repoPath of repositories) {
       this.refresh(repoPath, {
         layers: ['basic', 'status'],
         reason: 'window-focus',
diff --git a/src/web-ui/src/tools/git/state/types.ts b/src/web-ui/src/tools/git/state/types.ts
index 2a480d98..b8497a4a 100644
--- a/src/web-ui/src/tools/git/state/types.ts
+++ b/src/web-ui/src/tools/git/state/types.ts
@@ -111,6 +111,12 @@ export interface UseGitStateOptions {
   
   /** Whether the component is active/visible */
   isActive?: boolean;
+
+  /**
+   * Whether this consumer should participate in global window-focus refresh.
+   * Disable for passive consumers such as sidebar branch badges.
+   */
+  participateInWindowFocusRefresh?: boolean;
   
   /** Optional selector to reduce re-renders */
   selector?: <T>(state: GitState) => T;
diff --git a/src/web-ui/src/tools/terminal/components/Terminal.tsx b/src/web-ui/src/tools/terminal/components/Terminal.tsx
index c27e165e..675e8f0a 100644
--- a/src/web-ui/src/tools/terminal/components/Terminal.tsx
+++ b/src/web-ui/src/tools/terminal/components/Terminal.tsx
@@ -18,6 +18,7 @@ import {
 import { systemAPI } from '@/infrastructure/api/service-api/SystemAPI';
 import { themeService } from '@/infrastructure/theme/core/ThemeService';
 import { createLogger } from '@/shared/utils/logger';
+import { sendDebugProbe } from '@/shared/utils/debugProbe';
 import '@xterm/xterm/css/xterm.css';
 import './Terminal.scss';
 
@@ -189,6 +190,8 @@ const Terminal = forwardRef<TerminalRef, TerminalProps>(({
   const wasVisibleRef = useRef(false);
   const lastBackendSizeRef = useRef<{ cols: number; rows: number } | null>(null);
   const autoFocusRef = useRef(autoFocus);
+  const terminalIdRef = useRef(terminalId);
+  const sessionIdRef = useRef(sessionId);
   const onDataRef = useRef(onData);
   const onBinaryRef = useRef(onBinary);
   const onTitleChangeRef = useRef(onTitleChange);
@@ -214,6 +217,8 @@ const Terminal = forwardRef<TerminalRef, TerminalProps>(({
   const initialFontWeightsRef = useRef(initialFontWeights);
 
   autoFocusRef.current = autoFocus;
+  terminalIdRef.current = terminalId;
+  sessionIdRef.current = sessionId;
   onDataRef.current = onData;
   onBinaryRef.current = onBinary;
   onTitleChangeRef.current = onTitleChange;
@@ -560,6 +565,7 @@ const Terminal = forwardRef<TerminalRef, TerminalProps>(({
       isVisibleRef.current = isVisible;
 
       if (isVisible && !wasVisibleRef.current) {
+        const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
         requestAnimationFrame(() => {
           resizeDebouncerRef.current?.flush();
           
@@ -575,6 +581,23 @@ const Terminal = forwardRef<TerminalRef, TerminalProps>(({
                 term.focus();
               }
             }
+            sendDebugProbe(
+              'Terminal.tsx:intersectionObserver',
+              'Terminal visibility restore completed',
+              {
+                terminalId: terminalIdRef.current,
+                sessionId: sessionIdRef.current,
+                autoFocus: autoFocusRef.current,
+                durationMs:
+                  Math.round(
+                    ((typeof performance !== 'undefined' ? performance.now() : Date.now()) -
+                      startedAt) *
+                      10
+                  ) / 10,
+                cols: term?.cols ?? null,
+                rows: term?.rows ?? null,
+              }
+            );
           });
         });
       }