diff --git a/apps/desktop/src/desktopTray.ts b/apps/desktop/src/desktopTray.ts
index 7e4fcecdb..84fbd6d4f 100644
--- a/apps/desktop/src/desktopTray.ts
+++ b/apps/desktop/src/desktopTray.ts
@@ -14,6 +14,7 @@ type Options = {
 export function createDesktopTray(options: Options) {
   let tray: Tray | null = null;
   let quitting = false;
+  let approvalWaiting = false;
   const available = () => tray !== null && !tray.isDestroyed();
   const invoke = (action: () => Promise<void>) => {
     if (!quitting) void action().catch(options.reportError);
@@ -22,7 +23,14 @@ export function createDesktopTray(options: Options) {
     if (!available()) return;
     const zh = options.isChinese();
     const quittingLabel = zh ? '正在退出…' : 'Quitting…';
-    tray!.setToolTip(quitting ? `PilotDeck — ${quittingLabel}` : 'PilotDeck');
+    const approvalLabel = zh ? '等待授权' : 'Waiting for approval';
+    tray!.setToolTip(
+      quitting
+        ? `PilotDeck — ${quittingLabel}`
+        : approvalWaiting
+          ? `PilotDeck — ${approvalLabel}`
+          : 'PilotDeck',
+    );
     tray!.setContextMenu(options.buildMenu([
       { label: zh ? '打开主界面' : 'Open main window', enabled: !quitting, click: () => invoke(options.open) },
       { type: 'separator' },
@@ -49,5 +57,6 @@ export function createDesktopTray(options: Options) {
   }
   return { available, refreshMenu, dispose,
     setQuitting(value: boolean) { quitting = value; refreshMenu(); },
+    setApprovalWaiting(value: boolean) { if (approvalWaiting !== value) { approvalWaiting = value; refreshMenu(); } },
   };
 }
diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts
index 9160d46f8..0942e1009 100644
--- a/apps/desktop/src/main.ts
+++ b/apps/desktop/src/main.ts
@@ -11,7 +11,7 @@ import { normalizeAppearance, renderLoadingHtml, startupText, type DesktopAppear
 import { saveAppearancePatch, appearanceImagePath, writeAppearanceImage } from './appearanceStorage';
 import { createFilePicker } from './filePicker';
 import { ComputerUseController } from './computerUse';
-import { app, BrowserWindow, dialog, ipcMain, Menu, shell, Tray, nativeImage, powerMonitor, nativeTheme, clipboard, screen } from "electron";
+import { app, BrowserWindow, dialog, ipcMain, Menu, Notification, shell, Tray, nativeImage, powerMonitor, nativeTheme, clipboard, screen } from "electron";
 import { DebUpdater, MacUpdater, NsisUpdater, RpmUpdater } from "electron-updater";
 import { installUpdateDownloadControl } from "./updateDownload";
 import { createUpdateController } from "./updates";
@@ -612,6 +612,12 @@ async function createOrShowWindow(): Promise<void> {
     );
   });
   lifecycle.attachWindow(recoveryWindow);
+  // Focusing the window ends the approval-waiting episode: the user is back
+  // in the app, so the taskbar should stop flashing and the next waiting
+  // transition may raise a fresh toast.
+  recoveryWindow.on("focus", () => {
+    clearApprovalWaitingAlert();
+  });
   // Windows logoff/shutdown does not go through app's normal quit events.
   // Respect the OS session end without displaying a quit confirmation.
   recoveryWindow.on("session-end", () => {
@@ -1239,6 +1245,61 @@ ipcMain.handle('pilotdeck:pick-files', (event, request: unknown) => {
   return pickFiles(mainWindow!, request);
 });
 
+// --- Approval-waiting system alerts (issue #691) -----------------------------
+// The renderer asks for these only when the window is unfocused, so a user
+// watching the in-app banner never gets a redundant toast. One toast per
+// waiting episode; refocusing the window ends it.
+let approvalAlertActive = false;
+
+function logApprovalAlert(message: string, error: unknown): void {
+  const line = `${new Date().toISOString()} [approval-alert] ${message} ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`;
+  void fs.promises.appendFile(path.join(app.getPath("logs"), "renderer.log"), line).catch(() => {});
+}
+
+function presentApprovalWaitingAlert(count: number): void {
+  if (approvalAlertActive) return;
+  approvalAlertActive = true;
+  const zh = readAppearance().language === "zh-CN";
+  desktopTray?.setApprovalWaiting(true);
+  try {
+    const body = count > 1
+      ? zh ? `有 ${count} 项操作等待你的授权。` : `${count} operations are waiting for your approval.`
+      : zh ? "有操作等待你的授权。" : "An operation is waiting for your approval.";
+    const notification = new Notification({ title: "PilotDeck", body, silent: false });
+    notification.on("click", () => { void createOrShowWindow(); });
+    notification.show();
+  } catch (error) {
+    logApprovalAlert("toast failed", error);
+  }
+  try {
+    if (mainWindow && !mainWindow.isDestroyed()) mainWindow.flashFrame(true);
+  } catch (error) {
+    logApprovalAlert("flashFrame failed", error);
+  }
+}
+
+function clearApprovalWaitingAlert(): void {
+  if (!approvalAlertActive) return;
+  approvalAlertActive = false;
+  desktopTray?.setApprovalWaiting(false);
+  try {
+    if (mainWindow && !mainWindow.isDestroyed()) mainWindow.flashFrame(false);
+  } catch (error) {
+    logApprovalAlert("stop flashing failed", error);
+  }
+}
+
+ipcMain.handle("pilotdeck:approval-waiting", (_event, detail: unknown) => {
+  const count = typeof (detail as { count?: unknown } | null)?.count === "number"
+    && Number.isFinite((detail as { count: number }).count)
+    ? Math.max(1, Math.floor((detail as { count: number }).count))
+    : 1;
+  presentApprovalWaitingAlert(count);
+});
+ipcMain.handle("pilotdeck:approval-clear", () => {
+  clearApprovalWaitingAlert();
+});
+
 if (process.platform === "win32") {
   app.setAppUserModelId(APP_ID);
 }
diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.ts
index 9c5cbb45c..30ced6d9c 100644
--- a/apps/desktop/src/preload.ts
+++ b/apps/desktop/src/preload.ts
@@ -49,6 +49,11 @@ contextBridge.exposeInMainWorld("pilotdeckDesktop", {
   },
   retryRuntime: () => ipcRenderer.invoke("pilotdeck:retry-runtime"),
   openRuntimeLog: () => ipcRenderer.invoke("pilotdeck:open-runtime-log"),
+  // Approval-waiting alerts (issue #691): the renderer raises a native toast
+  // and a taskbar flash only when the window is unfocused, and clears them
+  // once the pending approval queue drains.
+  notifyApprovalWaiting: (detail: { count: number }) => ipcRenderer.invoke("pilotdeck:approval-waiting", detail),
+  clearApprovalWaiting: () => ipcRenderer.invoke("pilotdeck:approval-clear"),
   pickFolder: () => ipcRenderer.invoke("pilotdeck:pick-folder"),
   pickFiles: (request: FilePickerRequest) => ipcRenderer.invoke('pilotdeck:pick-files', request) as Promise<FilePickerResult>,
 });
diff --git a/ui/src/components/app-shell/AppShellV2.tsx b/ui/src/components/app-shell/AppShellV2.tsx
index 9ae503c26..cd59793ac 100644
--- a/ui/src/components/app-shell/AppShellV2.tsx
+++ b/ui/src/components/app-shell/AppShellV2.tsx
@@ -31,6 +31,7 @@ import {
   type SessionProvider,
 } from '../../types/app';
 import { api } from '../../utils/api';
+import { APPROVAL_WAITING_EVENT, type ApprovalWaitingDetail } from '../../utils/approvalAlert';
 import { useRejectExternalFileDropOutsideTargets } from '../../utils/externalFileDrop';
 import { resolveMarkdownFileHref } from '../chat/utils/resolveMarkdownFileHref';
 import type { SessionNavigationOptions } from '../main-content/types/types';
@@ -167,6 +168,22 @@ export default function AppShellV2() {
     }
   }), [subscribe, localProcessingSessions, markSessionAsNotProcessing]);
 
+  // Sessions with a tool call waiting for user approval. The chat view owns
+  // the authoritative queue and broadcasts it via `pilotdeck:approval-waiting`
+  // so the badge survives navigating away from the conversation.
+  const [awaitingApprovalSessionIds, setAwaitingApprovalSessionIds] = useState<Set<string>>(() => new Set());
+  useEffect(() => {
+    const handler = (event: Event) => {
+      const detail = (event as CustomEvent<ApprovalWaitingDetail>).detail;
+      const sessionIds = Array.isArray(detail?.sessionIds)
+        ? detail.sessionIds.filter((id): id is string => typeof id === 'string' && id.length > 0)
+        : [];
+      setAwaitingApprovalSessionIds(new Set(sessionIds));
+    };
+    window.addEventListener(APPROVAL_WAITING_EVENT, handler);
+    return () => window.removeEventListener(APPROVAL_WAITING_EVENT, handler);
+  }, []);
+
 
 
   const misroutedFileFromUrl = useMemo(() => {
@@ -691,6 +708,7 @@ export default function AppShellV2() {
       isMobile={isMobile}
       processingSessions={processingSessions}
       unreadSessionIds={unreadSessionIds}
+      awaitingApprovalSessionIds={awaitingApprovalSessionIds}
       onSelectProject={handleSelectProject}
       onSelectSession={handleSelectSession}
       onStartNewSession={handleStartNewSession}
diff --git a/ui/src/components/app-shell/SidebarV2.tsx b/ui/src/components/app-shell/SidebarV2.tsx
index 35578297c..4da9d793f 100644
--- a/ui/src/components/app-shell/SidebarV2.tsx
+++ b/ui/src/components/app-shell/SidebarV2.tsx
@@ -20,6 +20,7 @@ import {
   Pencil,
   GitBranch,
   Trash2,
+  TriangleAlert,
 } from 'lucide-react';
 import type { AppTab, Project, ProjectSession } from '../../types/app';
 import { cn } from '../../lib/utils.js';
@@ -137,7 +138,7 @@ const collectSessionsForProject = (project: Project): FlatSession[] => {
     .sort((a, b) => b.lastActivity - a.lastActivity);
 };
 
-type SessionIndicatorStatus = 'processing' | 'unread' | 'idle';
+type SessionIndicatorStatus = 'awaiting-approval' | 'processing' | 'unread' | 'idle';
 
 export type SidebarV2Props = {
   projects: Project[];
@@ -150,6 +151,7 @@ export type SidebarV2Props = {
   isMobile?: boolean;
   processingSessions?: Set<string>;
   unreadSessionIds?: Set<string>;
+  awaitingApprovalSessionIds?: Set<string>;
   onSelectProject: (project: Project) => void;
   onSelectSession: (project: Project, sessionId: string) => void;
   onStartNewSession: (project: Project) => void;
@@ -269,6 +271,7 @@ export default function SidebarV2({
   isMobile = false,
   processingSessions,
   unreadSessionIds,
+  awaitingApprovalSessionIds,
   onSelectProject,
   onSelectSession,
   onStartNewSession,
@@ -768,13 +771,17 @@ export default function SidebarV2({
         typeof sessionId === 'string' && sessionId.startsWith('new-session-');
       const indicatorStatus: SessionIndicatorStatus = isOptimisticRow
         ? 'processing'
-        : processingSessions?.has(sessionId)
-          ? 'processing'
-          : unreadSessionIds?.has(sessionId)
-            ? 'unread'
-            : 'idle';
+        : awaitingApprovalSessionIds?.has(sessionId)
+          ? 'awaiting-approval'
+          : processingSessions?.has(sessionId)
+            ? 'processing'
+            : unreadSessionIds?.has(sessionId)
+              ? 'unread'
+              : 'idle';
       const indicatorLabel =
-        indicatorStatus === 'processing'
+        indicatorStatus === 'awaiting-approval'
+          ? t('sidebar:sessions.awaitingApproval', { defaultValue: 'Waiting for approval' })
+          : indicatorStatus === 'processing'
           ? t('sidebar:sessions.processing', { defaultValue: 'Agent is running' })
           : indicatorStatus === 'unread'
             ? t('sidebar:sessions.unread', { defaultValue: 'Unread messages' })
@@ -826,7 +833,8 @@ export default function SidebarV2({
               >
                 <span className={cn('session-indicator', options.flat && 'session-indicator-flat')}
                   data-session-indicator={sessionId} data-status={indicatorStatus} aria-label={indicatorLabel} title={indicatorLabel}>
-                  {indicatorStatus === 'processing' ? <Loader2 aria-hidden="true" className="h-3 w-3 animate-spin" />
+                  {indicatorStatus === 'awaiting-approval' ? <TriangleAlert aria-hidden="true" className="h-3 w-3" />
+                    : indicatorStatus === 'processing' ? <Loader2 aria-hidden="true" className="h-3 w-3 animate-spin" />
                     : options.flat && indicatorStatus === 'idle' ? (
                       <svg aria-hidden="true" className="icon" fill="none" height="16" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="1.8" viewBox="0 0 24 24" width="16">
                         <path d="M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z" />
diff --git a/ui/src/components/chat-v2/ChatInterfaceV2.tsx b/ui/src/components/chat-v2/ChatInterfaceV2.tsx
index da7e27eab..ed82a9947 100644
--- a/ui/src/components/chat-v2/ChatInterfaceV2.tsx
+++ b/ui/src/components/chat-v2/ChatInterfaceV2.tsx
@@ -18,6 +18,7 @@ import { useChatProviderState } from '../chat/hooks/useChatProviderState';
 import { useChatSessionState } from '../chat/hooks/useChatSessionState';
 import { useChatRealtimeHandlers } from '../chat/hooks/useChatRealtimeHandlers';
 import { useChatComposerState } from '../chat/hooks/useChatComposerState';
+import { useApprovalWaitingAlert } from '../chat/hooks/useApprovalWaitingAlert';
 import { useSessionInputQueue } from '../chat/hooks/useSessionInputQueue';
 import { isSendingInput } from '../chat/types/queuedInput';
 import {
@@ -450,6 +451,14 @@ function ChatInterfaceV2({
     sessionStore,
   });
 
+  useApprovalWaitingAlert({
+    pendingPermissionRequests,
+    fallbackSessionId: currentSessionId ?? selectedSession?.id ?? null,
+    waitingLabel: t('approvalAlert.documentTitle', {
+      defaultValue: '⚠ Waiting for approval',
+    }) as string,
+  });
+
   useEffect(() => {
     if (!isLoading || !canAbortSession) {
       setIsAbortPending(false);
diff --git a/ui/src/components/chat/hooks/useApprovalWaitingAlert.test.tsx b/ui/src/components/chat/hooks/useApprovalWaitingAlert.test.tsx
new file mode 100644
index 000000000..631e88b40
--- /dev/null
+++ b/ui/src/components/chat/hooks/useApprovalWaitingAlert.test.tsx
@@ -0,0 +1,151 @@
+// @vitest-environment jsdom
+import { act, cleanup, render } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { APPROVAL_WAITING_EVENT, type ApprovalWaitingDetail } from '../../../utils/approvalAlert';
+import { useApprovalWaitingAlert } from './useApprovalWaitingAlert';
+
+const notifyApprovalWaiting = vi.fn<(detail: { count: number }) => Promise<void>>();
+const clearApprovalWaiting = vi.fn<() => Promise<void>>();
+
+const waitingLabel = '⚠ Waiting for approval';
+let fallbackSessionId: string | null = null;
+
+function Harness({ count, sessionIds }: { count: number; sessionIds?: (string | null)[] }) {
+  const requests = Array.from({ length: count }, (_, index) => ({
+    sessionId: sessionIds ? sessionIds[index] ?? null : `session-${index + 1}`,
+  }));
+  useApprovalWaitingAlert({
+    pendingPermissionRequests: requests as never[],
+    fallbackSessionId,
+    waitingLabel,
+  });
+  return null;
+}
+
+function lastDetail(): ApprovalWaitingDetail {
+  const events = recordedEvents();
+  const last = events[events.length - 1];
+  expect(last).toBeDefined();
+  return last;
+}
+
+function recordedEvents(): ApprovalWaitingDetail[] {
+  return (window.__approvalTestEvents ?? []).slice();
+}
+
+declare global {
+  interface Window {
+    __approvalTestEvents?: ApprovalWaitingDetail[];
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  Object.defineProperty(window, 'pilotdeckDesktop', {
+    configurable: true,
+    value: { notifyApprovalWaiting, clearApprovalWaiting },
+  });
+  window.__approvalTestEvents = [];
+  window.addEventListener(APPROVAL_WAITING_EVENT, (event) => {
+    window.__approvalTestEvents!.push((event as CustomEvent<ApprovalWaitingDetail>).detail);
+  });
+  document.title = 'PilotDeck';
+  // jsdom reports a focused document by default.
+  vi.spyOn(document, 'hasFocus').mockReturnValue(true);
+});
+
+afterEach(() => {
+  cleanup();
+  delete window.__approvalTestEvents;
+  vi.restoreAllMocks();
+});
+
+describe('useApprovalWaitingAlert', () => {
+  it('badges the session and updates the title while waiting, without notifying a focused window', () => {
+    const view = render(<Harness count={0} />);
+    expect(recordedEvents()).toEqual([{ sessionIds: [] }]);
+    expect(document.title).toBe('PilotDeck');
+
+    act(() => view.rerender(<Harness count={1} />));
+
+    // A focused window shows the in-app banner, so the desktop toast/flash is skipped.
+    expect(notifyApprovalWaiting).not.toHaveBeenCalled();
+    expect(document.title).toBe('⚠ Waiting for approval — PilotDeck');
+    expect(lastDetail()).toEqual({ sessionIds: ['session-1'] });
+  });
+
+  it('notifies the desktop bridge on the idle→waiting transition when the window is unfocused', () => {
+    vi.spyOn(document, 'hasFocus').mockReturnValue(false);
+    const view = render(<Harness count={0} />);
+
+    act(() => view.rerender(<Harness count={2} />));
+
+    expect(notifyApprovalWaiting).toHaveBeenCalledTimes(1);
+    expect(notifyApprovalWaiting).toHaveBeenCalledWith({ count: 2 });
+    expect(document.title).toBe('⚠ Waiting for approval (2) — PilotDeck');
+    expect(lastDetail()).toEqual({ sessionIds: ['session-1', 'session-2'] });
+  });
+
+  it('clears the desktop alert, restores the title and empties the badge when the queue drains', () => {
+    vi.spyOn(document, 'hasFocus').mockReturnValue(false);
+    const view = render(<Harness count={0} />);
+    act(() => view.rerender(<Harness count={1} />));
+    expect(notifyApprovalWaiting).toHaveBeenCalledTimes(1);
+    expect(document.title).toBe('⚠ Waiting for approval — PilotDeck');
+
+    act(() => view.rerender(<Harness count={0} />));
+
+    expect(clearApprovalWaiting).toHaveBeenCalledTimes(1);
+    expect(document.title).toBe('PilotDeck');
+    expect(lastDetail()).toEqual({ sessionIds: [] });
+  });
+
+  it('does not clear the desktop alert when it never notified (window stayed focused)', () => {
+    const view = render(<Harness count={0} />);
+    act(() => view.rerender(<Harness count={1} />));
+    act(() => view.rerender(<Harness count={0} />));
+
+    expect(notifyApprovalWaiting).not.toHaveBeenCalled();
+    expect(clearApprovalWaiting).not.toHaveBeenCalled();
+    expect(document.title).toBe('PilotDeck');
+    expect(lastDetail()).toEqual({ sessionIds: [] });
+  });
+
+  it('falls back to the optimistic session id for requests without a session id', () => {
+    fallbackSessionId = 'new-session-abc';
+    const view = render(<Harness count={1} sessionIds={[null]} />);
+    expect(lastDetail()).toEqual({ sessionIds: ['new-session-abc'] });
+
+    fallbackSessionId = null;
+    act(() => view.rerender(<Harness count={1} sessionIds={['real-session']} />));
+    expect(lastDetail()).toEqual({ sessionIds: ['real-session'] });
+  });
+
+  it('restores title, badge and desktop alert on unmount mid-waiting', () => {
+    vi.spyOn(document, 'hasFocus').mockReturnValue(false);
+    const view = render(<Harness count={0} />);
+    act(() => view.rerender(<Harness count={1} />));
+    expect(document.title).toBe('⚠ Waiting for approval — PilotDeck');
+    expect(notifyApprovalWaiting).toHaveBeenCalledTimes(1);
+
+    act(() => view.unmount());
+
+    expect(document.title).toBe('PilotDeck');
+    expect(clearApprovalWaiting).toHaveBeenCalledTimes(1);
+    expect(lastDetail()).toEqual({ sessionIds: [] });
+  });
+
+  it('tolerates a missing desktop bridge (plain web build)', () => {
+    const desktop = window.pilotdeckDesktop;
+    delete window.pilotdeckDesktop;
+    try {
+      const view = render(<Harness count={0} />);
+      act(() => view.rerender(<Harness count={1} />));
+      act(() => view.rerender(<Harness count={0} />));
+      expect(document.title).toBe('PilotDeck');
+      expect(lastDetail()).toEqual({ sessionIds: [] });
+    } finally {
+      window.pilotdeckDesktop = desktop;
+    }
+  });
+});
diff --git a/ui/src/components/chat/hooks/useApprovalWaitingAlert.ts b/ui/src/components/chat/hooks/useApprovalWaitingAlert.ts
new file mode 100644
index 000000000..d4bc76b5e
--- /dev/null
+++ b/ui/src/components/chat/hooks/useApprovalWaitingAlert.ts
@@ -0,0 +1,109 @@
+import { useEffect, useRef } from 'react';
+import type { PendingPermissionRequest } from '../types/types';
+import {
+  APPROVAL_WAITING_EVENT,
+  buildApprovalDocumentTitle,
+  getDesktopApprovalBridge,
+  resolveApprovalSessionIds,
+  type ApprovalWaitingDetail,
+} from '../../../utils/approvalAlert';
+
+type UseApprovalWaitingAlertOptions = {
+  pendingPermissionRequests: PendingPermissionRequest[];
+  /**
+   * Session id used for requests that were received before `session_created`
+   * delivered the real id (typically the optimistic `new-session-*` id), so
+   * the sidebar can badge the row the user actually sees.
+   */
+  fallbackSessionId?: string | null;
+  /** Localized "⚠ Waiting for approval" label for the window title. */
+  waitingLabel: string;
+};
+
+/**
+ * Observes the pending tool-approval queue of the viewed session and raises
+ * system-level reminders while the PilotDeck window is in the background:
+ *
+ *  - dispatches `pilotdeck:approval-waiting` so the app shell can badge the
+ *    session in the sidebar;
+ *  - prefixes the window title with the localized waiting label;
+ *  - through the Electron bridge, asks the main process for a native toast
+ *    and a taskbar flash on the idle→waiting transition (only while the
+ *    window is unfocused), and clears both when the queue drains.
+ */
+export function useApprovalWaitingAlert({
+  pendingPermissionRequests,
+  fallbackSessionId,
+  waitingLabel,
+}: UseApprovalWaitingAlertOptions): void {
+  const count = pendingPermissionRequests.length;
+  const previousCountRef = useRef(0);
+  const notifiedRef = useRef(false);
+  const baseTitleRef = useRef<string | null>(null);
+  const fallbackRef = useRef(fallbackSessionId);
+  fallbackRef.current = fallbackSessionId;
+  const waitingLabelRef = useRef(waitingLabel);
+  waitingLabelRef.current = waitingLabel;
+  const sessionIdsKey = resolveApprovalSessionIds(pendingPermissionRequests, fallbackSessionId).join('\n');
+
+  useEffect(() => {
+    const previousCount = previousCountRef.current;
+    previousCountRef.current = count;
+
+    const detail: ApprovalWaitingDetail = {
+      sessionIds: resolveApprovalSessionIds(pendingPermissionRequests, fallbackRef.current),
+    };
+    window.dispatchEvent(new CustomEvent<ApprovalWaitingDetail>(APPROVAL_WAITING_EVENT, { detail }));
+
+    const bridge = getDesktopApprovalBridge();
+    if (bridge) {
+      if (count > 0 && previousCount === 0) {
+        // Only alert when the user cannot see the in-app banner anyway;
+        // a focused window already shows the amber permission banner.
+        if (typeof document.hasFocus !== 'function' || !document.hasFocus()) {
+          notifiedRef.current = true;
+          void Promise.resolve(bridge.notifyApprovalWaiting!({ count })).catch(() => {});
+        }
+      } else if (count === 0 && previousCount > 0) {
+        if (notifiedRef.current) {
+          notifiedRef.current = false;
+          void Promise.resolve(bridge.clearApprovalWaiting!()).catch(() => {});
+        }
+      }
+    }
+    // `pendingPermissionRequests` changes identity on every store update; the
+    // serialized session ids keep the event to real membership changes.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [count, sessionIdsKey]);
+
+  useEffect(() => {
+    if (count > 0) {
+      if (baseTitleRef.current === null) {
+        baseTitleRef.current = document.title || 'PilotDeck';
+      }
+      document.title = buildApprovalDocumentTitle(baseTitleRef.current, count, waitingLabelRef.current);
+      return;
+    }
+    if (baseTitleRef.current !== null) {
+      document.title = baseTitleRef.current;
+      baseTitleRef.current = null;
+    }
+  }, [count]);
+
+  useEffect(() => () => {
+    // Leaving the session (or unmounting the chat view) must not leave a
+    // stuck badge, title, flash or toast behind.
+    window.dispatchEvent(new CustomEvent<ApprovalWaitingDetail>(APPROVAL_WAITING_EVENT, {
+      detail: { sessionIds: [] },
+    }));
+    if (baseTitleRef.current !== null) {
+      document.title = baseTitleRef.current;
+      baseTitleRef.current = null;
+    }
+    const bridge = getDesktopApprovalBridge();
+    if (bridge && notifiedRef.current) {
+      notifiedRef.current = false;
+      void Promise.resolve(bridge.clearApprovalWaiting!()).catch(() => {});
+    }
+  }, []);
+}
diff --git a/ui/src/i18n/locales/en/chat.json b/ui/src/i18n/locales/en/chat.json
index b69dbd041..7472b7195 100644
--- a/ui/src/i18n/locales/en/chat.json
+++ b/ui/src/i18n/locales/en/chat.json
@@ -228,6 +228,9 @@
     "allowSaved": "Allow (saved)",
     "deny": "Deny"
   },
+  "approvalAlert": {
+    "documentTitle": "⚠ Waiting for approval"
+  },
   "todo": {
     "updated": "Todo list has been updated successfully",
     "current": "Current Todo List"
diff --git a/ui/src/i18n/locales/en/sidebar.json b/ui/src/i18n/locales/en/sidebar.json
index 5662a2ffd..43a1261a0 100644
--- a/ui/src/i18n/locales/en/sidebar.json
+++ b/ui/src/i18n/locales/en/sidebar.json
@@ -72,6 +72,7 @@
     "showMoreCount": "Show more ({{count}})",
     "showLess": "Show less",
     "processing": "Agent is running",
+    "awaitingApproval": "Waiting for approval",
     "unread": "Unread messages",
     "idle": "No unread messages",
     "forkedFrom": "Forked from {{parent}}"
diff --git a/ui/src/i18n/locales/zh-CN/chat.json b/ui/src/i18n/locales/zh-CN/chat.json
index 8a54f305f..5a52e30d4 100644
--- a/ui/src/i18n/locales/zh-CN/chat.json
+++ b/ui/src/i18n/locales/zh-CN/chat.json
@@ -228,6 +228,9 @@
     "allowSaved": "允许（已保存）",
     "deny": "拒绝"
   },
+  "approvalAlert": {
+    "documentTitle": "⚠ 等待授权"
+  },
   "todo": {
     "updated": "待办列表已成功更新",
     "current": "当前待办列表"
diff --git a/ui/src/i18n/locales/zh-CN/sidebar.json b/ui/src/i18n/locales/zh-CN/sidebar.json
index f3ccad9e0..43edb196c 100644
--- a/ui/src/i18n/locales/zh-CN/sidebar.json
+++ b/ui/src/i18n/locales/zh-CN/sidebar.json
@@ -72,6 +72,7 @@
     "showMoreCount": "显示更多 ({{count}})",
     "showLess": "收起",
     "processing": "智能体运行中",
+    "awaitingApproval": "等待授权",
     "unread": "有未读消息",
     "idle": "无未读消息",
     "forkedFrom": "从 {{parent}} 分叉"
diff --git a/ui/src/index.css b/ui/src/index.css
index cb982db97..7d5ccca63 100644
--- a/ui/src/index.css
+++ b/ui/src/index.css
@@ -1697,12 +1697,14 @@
     color: #8a84a8;
   }
   .session-indicator-flat { width: 16px; }
+  .session-indicator[data-status="awaiting-approval"] { color: #d97706; }
   .session-indicator[data-status="unread"] .conversation-dot {
     width: 6px;
     height: 6px;
     background: var(--pd-accent, #7060e8);
   }
   .dark .session-indicator { color: #a1a1aa; }
+  .dark .session-indicator[data-status="awaiting-approval"] { color: #fbbf24; }
   .dark .session-indicator[data-status="unread"] .conversation-dot { background: #a78bfa; }
 
   .conversation-dot {
diff --git a/ui/src/types/global.d.ts b/ui/src/types/global.d.ts
index c48e11710..c285915b1 100644
--- a/ui/src/types/global.d.ts
+++ b/ui/src/types/global.d.ts
@@ -50,6 +50,8 @@ declare global {
       }) => void) => () => void;
       retryRuntime: () => Promise<void>;
       openRuntimeLog: () => Promise<void>;
+      notifyApprovalWaiting?: (detail: { count: number }) => Promise<void>;
+      clearApprovalWaiting?: () => Promise<void>;
       pickFolder: () => Promise<string | null>;
       pickFiles?: (request: { inputId: string; accept: string; multiple: boolean; directory: boolean }) => Promise<'selected' | 'canceled' | 'busy'>;
     };
diff --git a/ui/src/utils/approvalAlert.test.ts b/ui/src/utils/approvalAlert.test.ts
new file mode 100644
index 000000000..da04ff44d
--- /dev/null
+++ b/ui/src/utils/approvalAlert.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import {
+  APPROVAL_WAITING_EVENT,
+  buildApprovalDocumentTitle,
+  getDesktopApprovalBridge,
+  resolveApprovalSessionIds,
+} from './approvalAlert';
+
+describe('resolveApprovalSessionIds', () => {
+  it('collects distinct session ids in order', () => {
+    expect(resolveApprovalSessionIds([
+      { sessionId: 'b' },
+      { sessionId: 'a' },
+      { sessionId: 'b' },
+    ])).toEqual(['b', 'a']);
+  });
+
+  it('uses the fallback id at most once for requests without a session id', () => {
+    expect(resolveApprovalSessionIds([{ sessionId: null }, {}], 'optimistic-1')).toEqual(['optimistic-1']);
+  });
+
+  it('ignores the fallback when every request already carries an id', () => {
+    expect(resolveApprovalSessionIds([{ sessionId: 'real' }], 'optimistic-1')).toEqual(['real']);
+  });
+
+  it('returns empty when there is nothing to resolve', () => {
+    expect(resolveApprovalSessionIds([], 'optimistic-1')).toEqual([]);
+    expect(resolveApprovalSessionIds([{}])).toEqual([]);
+  });
+});
+
+describe('buildApprovalDocumentTitle', () => {
+  it('restores the base title when nothing is pending', () => {
+    expect(buildApprovalDocumentTitle('PilotDeck', 0, '⚠ Waiting')).toBe('PilotDeck');
+  });
+
+  it('prefixes the waiting label without a count for a single request', () => {
+    expect(buildApprovalDocumentTitle('PilotDeck', 1, '⚠ Waiting')).toBe('⚠ Waiting — PilotDeck');
+  });
+
+  it('appends the count for several pending requests', () => {
+    expect(buildApprovalDocumentTitle('PilotDeck', 3, '⚠ Waiting')).toBe('⚠ Waiting (3) — PilotDeck');
+  });
+
+  it('falls back to the app name for an empty base title', () => {
+    expect(buildApprovalDocumentTitle('', 1, '⚠ Waiting')).toBe('⚠ Waiting — PilotDeck');
+  });
+});
+
+describe('getDesktopApprovalBridge', () => {
+  it('accepts a bridge exposing the full alert cycle', () => {
+    const bridge = {
+      notifyApprovalWaiting: () => {},
+      clearApprovalWaiting: () => {},
+    };
+    expect(getDesktopApprovalBridge(bridge)).toBe(bridge);
+  });
+
+  it('rejects missing or partial bridges so the DOM channels degrade gracefully', () => {
+    expect(getDesktopApprovalBridge(undefined)).toBeNull();
+    expect(getDesktopApprovalBridge(null)).toBeNull();
+    expect(getDesktopApprovalBridge('desktop')).toBeNull();
+    expect(getDesktopApprovalBridge({ notifyApprovalWaiting: () => {} })).toBeNull();
+    expect(getDesktopApprovalBridge({ clearApprovalWaiting: () => {} })).toBeNull();
+  });
+});
+
+describe('APPROVAL_WAITING_EVENT', () => {
+  it('is a stable namespaced event name', () => {
+    expect(APPROVAL_WAITING_EVENT).toBe('pilotdeck:approval-waiting');
+  });
+});
diff --git a/ui/src/utils/approvalAlert.ts b/ui/src/utils/approvalAlert.ts
new file mode 100644
index 000000000..e4be9557f
--- /dev/null
+++ b/ui/src/utils/approvalAlert.ts
@@ -0,0 +1,81 @@
+/**
+ * Approval-waiting alert plumbing shared by the chat view (producer) and the
+ * app shell (sidebar consumer). A session waiting for tool approval must stay
+ * visible even when the PilotDeck window lost focus, otherwise desktop users
+ * only find out by switching back (see issue #691).
+ *
+ * Three channels are driven from one place:
+ *  - a DOM CustomEvent so any surface (sidebar, shell) can badge the session;
+ *  - `document.title` so the taskbar/alt-tab entry shows the waiting state;
+ *  - the optional Electron bridge for a native toast + taskbar flash.
+ */
+
+export const APPROVAL_WAITING_EVENT = 'pilotdeck:approval-waiting';
+
+export type ApprovalWaitingDetail = {
+  sessionIds: string[];
+};
+
+type PendingApprovalLike = {
+  sessionId?: string | null;
+};
+
+export type DesktopApprovalBridge = {
+  notifyApprovalWaiting?: (detail: { count: number }) => Promise<void> | void;
+  clearApprovalWaiting?: () => Promise<void> | void;
+};
+
+/**
+ * Returns the desktop bridge only when it can express the full alert cycle,
+ * so partially-missing bridges (older desktop builds, plain web) degrade to
+ * the DOM-event/title channels.
+ */
+export function getDesktopApprovalBridge(
+  desktop: unknown = typeof window === 'undefined' ? undefined : window.pilotdeckDesktop,
+): DesktopApprovalBridge | null {
+  if (!desktop || typeof desktop !== 'object') return null;
+  const candidate = desktop as DesktopApprovalBridge;
+  if (typeof candidate.notifyApprovalWaiting !== 'function') return null;
+  if (typeof candidate.clearApprovalWaiting !== 'function') return null;
+  return candidate;
+}
+
+/**
+ * Distinct session ids that currently wait for approval. Requests that have
+ * not learned their session id yet (sent before `session_created`) fall back
+ * to the caller-provided id so the optimistic sidebar row still badges.
+ */
+export function resolveApprovalSessionIds(
+  requests: PendingApprovalLike[],
+  fallbackSessionId?: string | null,
+): string[] {
+  const ids = new Set<string>();
+  let usedFallback = false;
+  for (const request of requests) {
+    const id = typeof request?.sessionId === 'string' && request.sessionId
+      ? request.sessionId
+      : null;
+    if (id) {
+      ids.add(id);
+    } else if (fallbackSessionId && !usedFallback) {
+      ids.add(fallbackSessionId);
+      usedFallback = true;
+    }
+  }
+  if (ids.size === 0 && fallbackSessionId && requests.length > 0) {
+    ids.add(fallbackSessionId);
+  }
+  return [...ids];
+}
+
+/**
+ * Window title while a session waits for approval. The count suffix only
+ * appears when more than one decision is pending to keep the common case
+ * short in the taskbar.
+ */
+export function buildApprovalDocumentTitle(baseTitle: string, count: number, label: string): string {
+  if (count <= 0) return baseTitle;
+  const safeBase = baseTitle.trim() || 'PilotDeck';
+  const countSuffix = count > 1 ? ` (${count})` : '';
+  return `${label}${countSuffix} — ${safeBase}`;
+}