From c6c2b63c60199417d5eca1378092f7611918b488 Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 14:29:09 +0800
Subject: [PATCH 01/11] =?UTF-8?q?feat(desktop):=20=E6=9B=B4=E6=96=B0?=
 =?UTF-8?q?=E9=87=8D=E5=90=AF=E5=8F=AA=E5=9C=A8=E6=9C=89=E4=BB=BB=E5=8A=A1?=
 =?UTF-8?q?=E8=BF=90=E8=A1=8C=E6=97=B6=E6=89=8D=E4=BA=8C=E6=AC=A1=E7=A1=AE?=
 =?UTF-8?q?=E8=AE=A4=EF=BC=8C=E5=B9=B6=E6=94=B9=E6=88=90=E4=B8=AD=E6=96=AD?=
 =?UTF-8?q?=E8=AD=A6=E5=91=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

侧栏 UpdateBanner 的重启入口原来是无条件「就地两段式」：点「立即重启」先切
确认态，再点「确认重启」才真重启。没有任何任务在跑时，第二步只有一句「应用会
自动重启」——不带信息量，纯粹多要一次点击。

改成与关窗链路（WindowControls.handleCloseClick）同一套判定：点入口先查
anySessionInTurn()，没有任务在跑就直接重启；只有真的有任务时才拦一次。探针
失败（桥不可用 / handler 未注册）按「没有任务」处理，与关窗链路一致。

因此 confirming 态的语义从「泛化二次确认」收窄为「有任务在运行，重启会打断它」
的中断警告：标题点明状态、副标题讲后果（警告色，不再有分支）、主按钮改为
「仍要重启」。退役无信息量的 confirmHint，四语言同步。

- 入口点击加 ref 防重入：探针在飞时的连点不会重复探针或重复重启
- 收起 / rail 态共用同一判定；那里没有文案位置，中断提示落在 ✓ 的 tooltip 上
- 测试随语义更名为 updateBannerRelaunchEntry.test.tsx，覆盖 busy 拦一次、非
  busy 一击直达、探针抛错、连点防重入、收起态同判定

验证：pnpm test:unit、desktop typecheck、check:i18n-glossary、check:i18n 全绿。
更新链路改动已与 owner 确认；未触及 updateService.ts 与 cindy-updater。
实机：dev 下更新链路被 isDev() 短路，拿不到真实 ready 态，双模式目检未在真实
ready 态下完成；本次未新增样式与颜色，确认态仍复用既有 --warning-fg /
--update-btn-* 语义 token。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../__tests__/updateBannerBusyHint.test.tsx   | 108 --------------
 .../updateBannerRelaunchEntry.test.tsx        | 141 ++++++++++++++++++
 .../updateBannerReleaseNotesLink.test.tsx     |  25 +++-
 .../components/sidebar/UpdateBanner.tsx       | 106 +++++++------
 .../src/renderer/i18n/locales/en/common.json  |  11 +-
 .../src/renderer/i18n/locales/ja/common.json  |  11 +-
 .../src/renderer/i18n/locales/ko/common.json  |  11 +-
 .../renderer/i18n/locales/zh-CN/common.json   |  11 +-
 8 files changed, 235 insertions(+), 189 deletions(-)
 delete mode 100644 apps/desktop/src/renderer/__tests__/updateBannerBusyHint.test.tsx
 create mode 100644 apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx

diff --git a/apps/desktop/src/renderer/__tests__/updateBannerBusyHint.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerBusyHint.test.tsx
deleted file mode 100644
index 2ea2ca9fef3..00000000000
--- a/apps/desktop/src/renderer/__tests__/updateBannerBusyHint.test.tsx
+++ /dev/null
@@ -1,108 +0,0 @@
-// @vitest-environment jsdom
-
-import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const { anySessionInTurn, relaunchToUpdate } = vi.hoisted(() => ({
-  anySessionInTurn: vi.fn<() => Promise<boolean>>(),
-  relaunchToUpdate: vi.fn(),
-}));
-
-vi.mock('react-i18next', () => ({
-  useTranslation: () => ({
-    t: (key: string) => key,
-  }),
-}));
-
-vi.mock('@/hooks/useUpdateStatus', () => ({
-  useUpdateStatus: () => ({
-    status: 'ready',
-    version: '1.2.3',
-    errorCode: null,
-  }),
-}));
-
-vi.mock('@/hooks/useUpdateBannerDismiss', () => ({
-  useUpdateBannerDismiss: () => ({
-    dismissed: false,
-    dismiss: vi.fn(),
-    restore: vi.fn(),
-    isNewUpdateAfterDismiss: vi.fn(() => false),
-  }),
-}));
-
-vi.mock('@/components/ui/tooltip', () => ({
-  Tip: ({ children }: { children: React.ReactNode }) => children,
-}));
-
-import { UpdateBanner } from '@/components/sidebar/UpdateBanner';
-
-beforeEach(() => {
-  anySessionInTurn.mockReset();
-  relaunchToUpdate.mockReset();
-  Object.defineProperty(window, 'electronAPI', {
-    configurable: true,
-    value: {
-      anySessionInTurn,
-      relaunchToUpdate,
-      clientEndpoints: { websiteUrl: 'https://cindy.ai' },
-    } as unknown as Window['electronAPI'],
-  });
-});
-
-afterEach(cleanup);
-
-describe('UpdateBanner busy-turn restart hint', () => {
-  it('shows the warning hint in the semantic warning color while any turn is running', async () => {
-    anySessionInTurn.mockResolvedValue(true);
-    render(<UpdateBanner isCollapsed={false} />);
-
-    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-
-    const hint = await screen.findByText('update.banner.confirmBusyHint');
-    expect(anySessionInTurn).toHaveBeenCalledTimes(1);
-    expect(hint.className).toContain('text-[var(--warning-fg)]');
-  });
-
-  it('keeps the existing neutral hint when no turn is running', async () => {
-    anySessionInTurn.mockResolvedValue(false);
-    render(<UpdateBanner isCollapsed={false} />);
-
-    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-
-    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
-    const hint = screen.getByText('update.banner.confirmHint');
-    expect(hint.className).toContain('text-sidebar-muted');
-    expect(hint.className).not.toContain('text-[var(--warning-fg)]');
-  });
-
-  it('keeps relaunch behavior unchanged while the text-only snapshot is pending', async () => {
-    let resolveTurnCheck!: (busy: boolean) => void;
-    anySessionInTurn.mockImplementation(
-      () => new Promise<boolean>((resolve) => { resolveTurnCheck = resolve; }),
-    );
-    render(<UpdateBanner isCollapsed={false} />);
-
-    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
-
-    const confirmButton = screen.getByRole('button', { name: 'update.banner.confirmAria' });
-    expect((confirmButton as HTMLButtonElement).disabled).toBe(false);
-    fireEvent.click(confirmButton);
-    expect(relaunchToUpdate).toHaveBeenCalledTimes(1);
-
-    resolveTurnCheck(false);
-  });
-
-  it('keeps the neutral hint when the one-shot probe throws synchronously', async () => {
-    anySessionInTurn.mockImplementation(() => {
-      throw new Error('electron bridge is not registered');
-    });
-    render(<UpdateBanner isCollapsed={false} />);
-
-    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-
-    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
-    expect(screen.getByText('update.banner.confirmHint')).toBeTruthy();
-  });
-});
diff --git a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
new file mode 100644
index 00000000000..50b3dbd2cb1
--- /dev/null
+++ b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
@@ -0,0 +1,141 @@
+// @vitest-environment jsdom
+
+/**
+ * UpdateBanner 的重启入口判定 —— 与关窗链路(WindowControls.handleCloseClick)同构:
+ * 点入口先查 anySessionInTurn(),没有任务在跑就直接重启,有才拦一次并说明「会打断
+ * 进行中的任务」。探针失败按「没有任务」处理。
+ */
+
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { anySessionInTurn, relaunchToUpdate } = vi.hoisted(() => ({
+  anySessionInTurn: vi.fn<() => Promise<boolean>>(),
+  relaunchToUpdate: vi.fn(),
+}));
+
+vi.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string) => key,
+  }),
+}));
+
+vi.mock('@/hooks/useUpdateStatus', () => ({
+  useUpdateStatus: () => ({
+    status: 'ready',
+    version: '1.2.3',
+    errorCode: null,
+  }),
+}));
+
+vi.mock('@/hooks/useUpdateBannerDismiss', () => ({
+  useUpdateBannerDismiss: () => ({
+    dismissed: false,
+    dismiss: vi.fn(),
+    restore: vi.fn(),
+    isNewUpdateAfterDismiss: vi.fn(() => false),
+  }),
+}));
+
+vi.mock('@/components/ui/tooltip', () => ({
+  Tip: ({ children }: { children: React.ReactNode }) => children,
+}));
+
+import { UpdateBanner } from '@/components/sidebar/UpdateBanner';
+
+beforeEach(() => {
+  anySessionInTurn.mockReset();
+  relaunchToUpdate.mockReset();
+  Object.defineProperty(window, 'electronAPI', {
+    configurable: true,
+    value: {
+      anySessionInTurn,
+      relaunchToUpdate,
+      clientEndpoints: { websiteUrl: 'https://cindy.ai' },
+    } as unknown as Window['electronAPI'],
+  });
+});
+
+afterEach(cleanup);
+
+describe('UpdateBanner relaunch entry', () => {
+  it('warns about the interruption instead of relaunching while a turn is running', async () => {
+    anySessionInTurn.mockResolvedValue(true);
+    render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+
+    const hint = await screen.findByText('update.banner.confirmBusyHint');
+    expect(anySessionInTurn).toHaveBeenCalledTimes(1);
+    expect(hint.className).toContain('text-[var(--warning-fg)]');
+    // 拦住的这一步不能顺手把 app 重启了 —— 是否打断任务由用户拍板。
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.confirmAria' }));
+    expect(relaunchToUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it('relaunches on the first click when no turn is running', async () => {
+    anySessionInTurn.mockResolvedValue(false);
+    render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+
+    await waitFor(() => expect(relaunchToUpdate).toHaveBeenCalledTimes(1));
+    expect(anySessionInTurn).toHaveBeenCalledTimes(1);
+    // 没有任务在跑时不该再出现第二步 —— 那句「应用会自动重启」不带任何信息量。
+    expect(screen.queryByRole('button', { name: 'update.banner.confirmAria' })).toBeNull();
+    expect(screen.queryByText('update.banner.confirmBusyHint')).toBeNull();
+  });
+
+  it('relaunches when the busy probe throws synchronously (bridge unavailable)', async () => {
+    anySessionInTurn.mockImplementation(() => {
+      throw new Error('electron bridge is not registered');
+    });
+    render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+
+    await waitFor(() => expect(relaunchToUpdate).toHaveBeenCalledTimes(1));
+    expect(screen.queryByText('update.banner.confirmBusyHint')).toBeNull();
+  });
+
+  it('ignores repeat clicks while the busy probe is still in flight', async () => {
+    let resolveTurnCheck!: (busy: boolean) => void;
+    anySessionInTurn.mockImplementation(
+      () => new Promise<boolean>((resolve) => { resolveTurnCheck = resolve; }),
+    );
+    render(<UpdateBanner isCollapsed={false} />);
+
+    const entry = screen.getByRole('button', { name: 'update.banner.ariaExpanded' });
+    fireEvent.click(entry);
+    fireEvent.click(entry);
+    fireEvent.click(entry);
+
+    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+
+    resolveTurnCheck(false);
+    await waitFor(() => expect(relaunchToUpdate).toHaveBeenCalledTimes(1));
+  });
+
+  it('applies the same judgement to the collapsed / rail entry', async () => {
+    anySessionInTurn.mockResolvedValue(false);
+    const { unmount } = render(<UpdateBanner isCollapsed />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaCollapsed' }));
+    await waitFor(() => expect(relaunchToUpdate).toHaveBeenCalledTimes(1));
+    expect(screen.queryByRole('button', { name: 'update.banner.confirmAria' })).toBeNull();
+
+    unmount();
+    relaunchToUpdate.mockClear();
+    anySessionInTurn.mockResolvedValue(true);
+    render(<UpdateBanner isCollapsed />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaCollapsed' }));
+    // 收起态没有文案位置,拦下来的形态是 ✓ / ✕ 两键。
+    await screen.findByRole('button', { name: 'update.banner.confirmAria' });
+    expect(screen.getByRole('button', { name: 'update.banner.cancelAria' })).toBeTruthy();
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
index 794f2118d85..742ac9fc3c4 100644
--- a/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
@@ -3,7 +3,7 @@
 /**
  * UpdateBanner「查看更新公告」文字链 —— 方案 A。
  *
- * 覆盖入口的四条判定:CDN 有公告才显示、点击带的是待装版本号、confirming 两步确认期
+ * 覆盖入口的四条判定:CDN 有公告才显示、点击带的是待装版本号、confirming 中断警告期
  * 让位、superseding 态不给入口(那时的 version 指向上一个已就绪补丁,不是正在下的新版)。
  */
 
@@ -38,10 +38,28 @@ const NOTES = { version: '1.4.2', date: '2026-07-28', contributors: [], sections
 
 const LINK = 'update.banner.viewNotes';
 
+// 入口按钮现在先查 busy 探针再决定「直接重启 vs 进中断警告态」,所以这个文件也需要
+// 一个 electronAPI 桩;默认没有任务在跑(本文件只关心文字链,不关心重启)。
+const { anySessionInTurn, relaunchToUpdate } = vi.hoisted(() => ({
+  anySessionInTurn: vi.fn<() => Promise<boolean>>(),
+  relaunchToUpdate: vi.fn(),
+}));
+
 beforeEach(() => {
   updateStatus.current = { status: 'ready', version: '1.4.2' };
   fetchReleaseNotes.mockReset();
   fetchReleaseNotes.mockResolvedValue(NOTES);
+  anySessionInTurn.mockReset();
+  anySessionInTurn.mockResolvedValue(false);
+  relaunchToUpdate.mockReset();
+  Object.defineProperty(window, 'electronAPI', {
+    configurable: true,
+    value: {
+      anySessionInTurn,
+      relaunchToUpdate,
+      clientEndpoints: { websiteUrl: 'https://cindy.ai' },
+    } as unknown as Window['electronAPI'],
+  });
 });
 
 afterEach(() => {
@@ -68,13 +86,14 @@ describe('UpdateBanner release-notes link', () => {
     expect(screen.queryByText(LINK)).toBeNull();
   });
 
-  it('hides the link while the two-step relaunch confirmation is showing', async () => {
+  it('hides the link while the busy-turn interruption warning is showing', async () => {
+    anySessionInTurn.mockResolvedValue(true);
     render(<UpdateBanner isCollapsed={false} onOpenVersionNotice={vi.fn()} />);
     await screen.findByText(LINK);
 
     fireEvent.click(screen.getByText('update.banner.button'));
 
-    expect(screen.getByText('update.banner.confirmButton')).toBeTruthy();
+    expect(await screen.findByText('update.banner.confirmButton')).toBeTruthy();
     expect(screen.queryByText(LINK)).toBeNull();
   });
 
diff --git a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
index c3d834052bc..edf9c29960e 100644
--- a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
+++ b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
@@ -6,17 +6,22 @@
  * of the already-ready patch (status === 'superseding'). Sits between the upper
  * content slot and UserInfoSection in the Sidebar shell.
  *
- * 更新确认改为「就地两段式」—— 不再弹出屏幕中央的 ConfirmDialog。用户点「立即重启」
- * 后,banner 自身原地切换成确认态:主按钮「确认重启」占据入口按钮原位(鼠标零位移),
- * 「取消」置于其下(次级、需刻意移动),从而在保持左下角、减少视线/鼠标移动的同时,
- * 用两步显式点击防止误更新。
+ * 点「立即重启」不再无条件多要一次确认:先查 anySessionInTurn(),**只有真的有任务在跑
+ * 时**才就地切换成确认态,没有任务就直接重启。这与关窗链路(WindowControls 的
+ * handleCloseClick)是同一套判定 —— 探针为 false(含桥不可用的 catch 兜底)就直接执行,
+ * 为 true 才拦一次。原先那句「应用会自动重启」的中性二次确认纯属多一次点击、不带信息,
+ * 已退役。
+ *
+ * 因此 confirming 态的语义收窄为**「有任务在进行中,重启会打断它」的中断警告**:标题点明
+ * 状态、副标题讲后果(警告色)、主按钮「仍要重启」占据入口按钮原位(鼠标零位移),「取消」
+ * 置于其下(次级、需刻意移动)。
  *
  * 「查看更新公告」文字链:ready 态在副标题下给一条 ghost 文字链,点开 UpdateNoticeDialog
  * 预览**待安装版本**的公告,让用户在「现在重启 vs 稍后」之间有据可依(装完后的自动弹窗
  * 只解决装完之后的事)。跨版本时会把「已装版本 → 待装版本」之间跳过的每一版聚合进同一个
  * 弹窗(useUpdateNotice 的 onOpenVersion),普通单版本升级就只有一块。三条刻意的边界:
  *   - 只在 ready 态出现。superseding 态顶部刻意不显示版本号(新版还在下),没有可信的
- *     版本可查,confirming 态则要保持两步确认的干净,两者都不给入口。
+ *     版本可查,confirming 态则要保持中断警告的干净,两者都不给入口。
  *   - CDN 上没有该版本公告(或内容不可渲染)时不显示入口 —— 用挂载时的 fetch 探测,
  *     宁可没有入口,也不给一个点了报错的链接。探测结果被 release-notes 双层缓存复用,
  *     真正点开时不会再打一次网。
@@ -24,10 +29,10 @@
  *     也只能看 <= 当前已装版本的历史,看不到待装版本。这是本方案已知的取舍。
  *
  *   - Expanded ready:        Flame 36px → "Updated to {v}" → "Relaunch to apply" → notes link → Relaunch pill
- *   - Expanded confirming:   Flame 36px → "Restart to update?" → hint → Confirm pill / Cancel (下方,ghost)
+ *   - Expanded confirming:   Flame 36px → "A task is still running" → 警告色 hint → "Restart anyway" pill / Cancel (下方,ghost)
  *   - Expanded superseding:  Loader2 36px (spin) → "Newer version found" → "Updating…" → disabled pill with spinner
- *   - Collapsed ready:       Flame 20px, click → confirming(就地展开 ✓ / ✕)
- *   - Collapsed confirming:  Check 20px (确认,占原位) 叠 X 20px (取消)
+ *   - Collapsed ready:       Flame 20px, click → 有任务才展开 ✓ / ✕,否则直接重启
+ *   - Collapsed confirming:  Check 20px (仍要重启,占原位) 叠 X 20px (取消)
  *   - Collapsed superseding: Loader2 20px (spin), click is a noop
  *
  * superseding 状态下 banner 顶部刻意不显示新版本号 —— 新版还在下,显示版本号等于撒谎;
@@ -63,14 +68,15 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   // status/version 变化时下面 effect 会自动 restore,新一版更新到达时 banner
   // 重新出现,不会被上一版的 dismiss 状态吞掉。
   const { dismissed, dismiss, restore, isNewUpdateAfterDismiss } = useUpdateBannerDismiss();
-  // 就地确认态:替代原先的屏幕中央 ConfirmDialog。
+  // 就地中断警告态:只在点击入口时探到「有任务在跑」才进入。
   const [confirming, setConfirming] = useState(false);
-  // 复用关闭窗口保护链路的权威 busy 探针：只统计仍在执行的逻辑 turn，
-  // 不把 keepalive、已结束但仍在渲染收尾的状态误判为运行中任务。
-  const [hasSessionInTurn, setHasSessionInTurn] = useState(false);
+  // 入口点击的 busy 探针在飞标记 —— 防重入。探针是一次 IPC round trip(毫秒级),所以
+  // 刻意不给 loading UI(几毫秒的 spinner 只会闪一下),只用 ref 挡住连点导致的
+  // 重复探针 / 重复重启。与 WindowControls 的关窗入口保持同样的「无 loading 态」处理。
+  const relaunchProbeRef = useRef(false);
   // 进入确认态后把焦点移到「取消」按钮 —— 键盘用户点入口键后原触发元素会卸载,
-  // 若不主动聚焦,焦点会丢失、无法继续操作。刻意聚焦「取消」而非「确认」:让默认落在
-  // 安全动作上,避免再按一次 Enter/Space 就直接更新的误操作(即 Radix 对破坏性操作
+  // 若不主动聚焦,焦点会丢失、无法继续操作。刻意聚焦「取消」而非「仍要重启」:让默认落在
+  // 安全动作上,避免再按一次 Enter/Space 就打断进行中的任务(即 Radix 对破坏性操作
   // 的默认焦点策略)。展开态与收起态共用同一个 ref(同一时刻只渲染其一)。
   const cancelBtnRef = useRef<HTMLButtonElement>(null);
   // 入口「立即重启」按钮的 ref:取消确认态后把焦点还给它,避免键盘用户退出两步流程时
@@ -101,38 +107,11 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   }, [isTranslocated]);
 
   // 一旦不再是 ready(如被 superseding 顶掉 / 出错),复位确认态,避免残留一个
-  // 指向旧补丁的「确认重启」。
+  // 指向旧补丁的「仍要重启」。
   useEffect(() => {
     if (status !== 'ready') setConfirming(false);
   }, [status]);
 
-  // 每次进入确认态都重新查询，避免沿用上一次打开弹层时的 busy 结果。
-  // handler 在 splash / login 阶段尚未注册时可能 reject；此 banner 只会在
-  // ready 主界面出现，但仍与 WindowControls 保持同样的安全兜底语义。
-  useEffect(() => {
-    if (!confirming) {
-      setHasSessionInTurn(false);
-      return;
-    }
-
-    let cancelled = false;
-    setHasSessionInTurn(false);
-    // Start the probe in a microtask so a synchronously unavailable IPC bridge
-    // is converted into a rejected promise and handled by the same fallback.
-    void Promise.resolve()
-      .then(() => window.electronAPI.anySessionInTurn())
-      .then((busy) => {
-        if (!cancelled) setHasSessionInTurn(busy);
-      })
-      .catch(() => {
-        if (!cancelled) setHasSessionInTurn(false);
-      });
-
-    return () => {
-      cancelled = true;
-    };
-  }, [confirming]);
-
   // 新更新到达时自动 restore:isNewUpdateAfterDismiss 先检查当前 status 是否为
   // active update 态(ready / superseding),再对比 dismiss 时的快照——两个条件
   // 都满足才 restore(),从而避免 remount 时 useUpdateStatus() 经历 idle→ready
@@ -208,6 +187,26 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
     window.electronAPI.relaunchToUpdate(theme);
   };
 
+  // 入口「立即重启」/ 收起态火焰按钮的点击。展开态与收起态共用一份判定:
+  //   - 有任务在跑 → 进 confirming 态,把「会打断进行中的任务」这件事说清楚,由用户拍板;
+  //   - 没有        → 直接重启,不再多要一次无信息量的确认。
+  // 探针失败(splash / login 阶段 handler 未注册,或桥同步 throw)按 false 处理 —— 与
+  // WindowControls.handleCloseClick 完全同构;banner 只在主界面出现,那时 handler 早已注册。
+  const handleRelaunchClick = async (): Promise<void> => {
+    if (relaunchProbeRef.current) return;
+    relaunchProbeRef.current = true;
+    let hasInFlight = false;
+    try {
+      hasInFlight = await window.electronAPI.anySessionInTurn();
+    } catch {
+      hasInFlight = false;
+    } finally {
+      relaunchProbeRef.current = false;
+    }
+    if (hasInFlight) setConfirming(true);
+    else handleRelaunch();
+  };
+
   const handleMoveToApplications = () => {
     setShowTranslocatedDialog(false);
     window.electronAPI.moveToApplicationsFolder();
@@ -273,7 +272,8 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
 
   // ── Collapsed state: icon only ──
   if (isCollapsed) {
-    // 确认态:上方 ✓(确认,占据原 Flame 图标位置,鼠标零位移),下方 ✕(取消)。
+    // 确认态(仅在有任务在跑时出现):上方 ✓(仍要重启,占据原 Flame 图标位置,鼠标零位移),
+    // 下方 ✕(取消)。收起态没有文案位置,「会打断进行中的任务」只能落在 ✓ 的 tooltip 上。
     if (confirming && !isPreparing) {
       return (
         <div className="flex flex-col items-center gap-0.5 border-t border-sidebar-border py-1.5">
@@ -318,7 +318,7 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
         >
           <button
             ref={relaunchTriggerRef}
-            onClick={() => { if (!isPreparing) setConfirming(true); }}
+            onClick={() => { if (!isPreparing) void handleRelaunchClick(); }}
             disabled={isPreparing}
             aria-label={isPreparing
               ? t('update.banner.preparingAria')
@@ -381,10 +381,11 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
             延伸而不是第三段独立文案;没有链接时这个 wrapper 只有一个子元素,布局与
             加链接前完全一致。 */}
         <div className="flex flex-col items-center gap-1">
+          {/* confirming 态一律是「有任务在跑」才进来的,所以警告色与 busy 文案不再分支。 */}
           <p
             className={cn(
               'text-center text-xs',
-              !isPreparing && confirming && hasSessionInTurn
+              !isPreparing && confirming
                 ? 'text-[var(--warning-fg)]'
                 : 'text-sidebar-muted',
             )}
@@ -392,11 +393,7 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
             {isPreparing
               ? t('update.banner.preparingSubtitle')
               : confirming
-                ? t(
-                    hasSessionInTurn
-                      ? 'update.banner.confirmBusyHint'
-                      : 'update.banner.confirmHint',
-                  )
+                ? t('update.banner.confirmBusyHint')
                 : t('update.banner.subtitle')}
           </p>
           {notesVersion && (
@@ -415,9 +412,10 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
 
         {/* Actions.
             - superseding: disabled pill + spinner.
-            - confirming:  竖排 —— 主按钮「确认重启」占入口按钮原位(鼠标零位移),
-                           「取消」在其下,次级 ghost,需刻意移动 → 防误更新。
-            - ready:       单个「立即重启」入口 pill,点击进入确认态(不再直接重启)。 */}
+            - confirming:  竖排 —— 主按钮「仍要重启」占入口按钮原位(鼠标零位移),
+                           「取消」在其下,次级 ghost,需刻意移动 → 打断任务前的最后一道闸。
+            - ready:       单个「立即重启」入口 pill,点击后按 busy 探针决定直接重启还是
+                           先进中断警告态。 */}
         {isPreparing ? (
           <button
             disabled
@@ -462,7 +460,7 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
         ) : (
           <button
             ref={relaunchTriggerRef}
-            onClick={() => setConfirming(true)}
+            onClick={() => { void handleRelaunchClick(); }}
             aria-label={t('update.banner.ariaExpanded', { version: version ?? '' })}
             className={cn(
               'flex w-full items-center justify-center gap-2 rounded-full border py-2',
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index c2092b155a5..6d4ff3ecf83 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -4146,14 +4146,13 @@
       "preparingButton": "Preparing",
       "preparingTooltip": "Preparing newer version…",
       "preparingAria": "Preparing newer version, please wait",
-      "confirmTitle": "Restart to update?",
-      "confirmHint": "The app will restart automatically",
-      "confirmBusyHint": "A task is still running. Restarting will interrupt it",
-      "confirmButton": "Restart now",
+      "confirmTitle": "A task is still running",
+      "confirmBusyHint": "Restarting will interrupt it",
+      "confirmButton": "Restart anyway",
       "cancel": "Cancel",
-      "confirmTooltip": "Confirm restart to apply the update",
+      "confirmTooltip": "A task is still running — restarting will interrupt it",
       "cancelTooltip": "Cancel",
-      "confirmAria": "Confirm restart to apply the update",
+      "confirmAria": "Restart anyway and apply the update, interrupting the running task",
       "cancelAria": "Cancel update",
       "dismiss": "Later",
       "dismissAria": "Dismiss update banner for now"
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index dde63967f44..854408d445e 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -4145,14 +4145,13 @@
       "preparingButton": "準備中",
       "preparingTooltip": "新しいバージョンを準備中…",
       "preparingAria": "新しいバージョンを準備中、お待ちください",
-      "confirmTitle": "再起動して更新?",
-      "confirmHint": "アプリが自動的に再起動します",
-      "confirmBusyHint": "実行中のタスクがあります。再起動すると中断されます",
-      "confirmButton": "再起動",
+      "confirmTitle": "実行中のタスクがあります",
+      "confirmBusyHint": "再起動すると中断されます",
+      "confirmButton": "それでも再起動",
       "cancel": "キャンセル",
-      "confirmTooltip": "再起動して更新を適用",
+      "confirmTooltip": "実行中のタスクがあります — 再起動すると中断されます",
       "cancelTooltip": "キャンセル",
-      "confirmAria": "再起動して更新を適用",
+      "confirmAria": "それでも再起動して更新を適用（実行中のタスクは中断されます）",
       "cancelAria": "更新をキャンセル",
       "dismiss": "後で",
       "dismissAria": "更新通知を一時的に閉じる"
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 3ad0929c17e..4a2dcf412d8 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -4145,14 +4145,13 @@
       "preparingButton": "준비 중",
       "preparingTooltip": "새 버전 준비 중…",
       "preparingAria": "새 버전 준비 중입니다. 잠시만 기다려 주세요",
-      "confirmTitle": "재시작하여 업데이트?",
-      "confirmHint": "앱이 자동으로 재시작됩니다",
-      "confirmBusyHint": "아직 실행 중인 작업이 있습니다. 재시작하면 작업이 중단됩니다",
-      "confirmButton": "재시작",
+      "confirmTitle": "아직 실행 중인 작업이 있습니다",
+      "confirmBusyHint": "재시작하면 작업이 중단됩니다",
+      "confirmButton": "그래도 재시작",
       "cancel": "취소",
-      "confirmTooltip": "재시작하여 업데이트 적용",
+      "confirmTooltip": "아직 실행 중인 작업이 있습니다 — 재시작하면 중단됩니다",
       "cancelTooltip": "취소",
-      "confirmAria": "재시작하여 업데이트 적용",
+      "confirmAria": "그래도 재시작하여 업데이트를 적용하고 실행 중인 작업을 중단",
       "cancelAria": "업데이트 취소",
       "dismiss": "나중에",
       "dismissAria": "업데이트 알림 일시 숨김"
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
index c163d543fb3..fe3f94c097c 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -4145,14 +4145,13 @@
       "preparingButton": "准备中",
       "preparingTooltip": "正在准备新版本…",
       "preparingAria": "正在准备新版本，请稍候",
-      "confirmTitle": "确认重启更新？",
-      "confirmHint": "应用会自动重启",
-      "confirmBusyHint": "当前仍有任务在执行，重启会直接中断",
-      "confirmButton": "确认重启",
+      "confirmTitle": "仍有任务在运行中",
+      "confirmBusyHint": "重启会中断运行中的任务",
+      "confirmButton": "仍要重启",
       "cancel": "取消",
-      "confirmTooltip": "确认重启并应用更新",
+      "confirmTooltip": "仍有任务在运行中，重启会中断它",
       "cancelTooltip": "取消",
-      "confirmAria": "确认重启并应用更新",
+      "confirmAria": "仍要重启并应用更新，会中断运行中的任务",
       "cancelAria": "取消更新",
       "dismiss": "稍后再说",
       "dismissAria": "关闭更新提示，稍后再决定"

From c9100d10fa3fc46a6f3b7d9c2aa924c248c507ae Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 17:08:59 +0800
Subject: [PATCH 02/11] =?UTF-8?q?fix(desktop):=20=E9=87=8D=E5=90=AF?=
 =?UTF-8?q?=E6=8E=A2=E9=92=88=E7=9A=84=E7=BB=93=E8=AE=BA=E5=8F=AA=E5=9C=A8?=
 =?UTF-8?q?=E8=BF=99=E6=AC=A1=E7=82=B9=E5=87=BB=E4=BB=8D=E7=84=B6=E6=9C=89?=
 =?UTF-8?q?=E6=95=88=E6=97=B6=E6=89=8D=E7=94=9F=E6=95=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

review 指出 handleRelaunchClick 的 await 之后缺少失效保护。归族后是同一条
不变量：**一次点击的探针结论，只有在这次点击仍然有效时才能驱动副作用**。
三条对称路径在探针在飞期间都会让它失效，之前一条都没管：

- 用户点「稍后再说」→ 探针 resolve 后仍会重启（点了稍后却突然重启），或
  setConfirming(true) 残留，下次被火焰按钮唤回时直接落在第二步；
- 已就绪补丁被 superseding 顶掉 → 仍按旧快照重启，装回旧补丁；
- 组件卸载 → 仍会真的把 app 重启掉。

修法是一个点击有效性令牌（relaunchEpochRef）：dismiss、卸载、status 离开
ready 都让它前进，在飞的 continuation 靠 epoch 不匹配自我作废。status 变化
额外再读一次 statusRef —— effect 打点会晚一拍，「已 setState 未跑 effect」
那段窗口里探针恰好 resolve 会读到过期的 ready，所以 continuation 直接读最新
值关掉它。两道判定针对同一不变量的不同触发路径，不是防御性冗余。

测试补齐四条对称用例（dismiss、dismiss+busy 结果的状态残留、superseding、
卸载）。每条都验证过能区分错误修法：临时移除两道判定后四条全红，恢复后全绿。
其中「dismiss + busy」初版写成了永远通过的无效断言（dismiss 后 banner 本就
return null），已改成模拟「点 X → 火焰按钮 restore 唤回」来真正暴露残留的
confirming state。

验证：pnpm test:unit（56 workspace PASS / 0 FAIL）、desktop typecheck 通过。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../updateBannerRelaunchEntry.test.tsx        | 129 ++++++++++++++++--
 .../components/sidebar/UpdateBanner.tsx       |  38 +++++-
 2 files changed, 150 insertions(+), 17 deletions(-)

diff --git a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
index 50b3dbd2cb1..3bd4e3a4c0a 100644
--- a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
@@ -4,14 +4,29 @@
  * UpdateBanner 的重启入口判定 —— 与关窗链路(WindowControls.handleCloseClick)同构:
  * 点入口先查 anySessionInTurn(),没有任务在跑就直接重启,有才拦一次并说明「会打断
  * 进行中的任务」。探针失败按「没有任务」处理。
+ *
+ * 另一半是**不变量:一次点击的探针结论,只有在这次点击仍然有效时才能驱动副作用**。
+ * 探针在飞期间 dismiss、组件卸载、status 离开 ready 都必须让它作废 —— 三条对称路径
+ * 各有一条用例,少任何一条都会漏掉「点了稍后却重启」「装回旧补丁」「confirming 残留」。
  */
 
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-const { anySessionInTurn, relaunchToUpdate } = vi.hoisted(() => ({
+const { anySessionInTurn, relaunchToUpdate, updateStatus, dismissState } = vi.hoisted(() => ({
   anySessionInTurn: vi.fn<() => Promise<boolean>>(),
   relaunchToUpdate: vi.fn(),
+  updateStatus: {
+    current: { status: 'ready', version: '1.2.3', errorCode: null } as {
+      status: string;
+      version?: string;
+      errorCode: string | null;
+    },
+  },
+  // dismissed 必须可控且由 dismiss() 真正翻转:要测「confirming 残留到下次唤回」,就得能
+  // 模拟「点 X 隐藏 → 火焰按钮 restore 重新显示」这条路径,而 restore 不会卸载组件,
+  // 残留的 state 正是靠它暴露出来的。
+  dismissState: { dismissed: false },
 }));
 
 vi.mock('react-i18next', () => ({
@@ -21,19 +36,15 @@ vi.mock('react-i18next', () => ({
 }));
 
 vi.mock('@/hooks/useUpdateStatus', () => ({
-  useUpdateStatus: () => ({
-    status: 'ready',
-    version: '1.2.3',
-    errorCode: null,
-  }),
+  useUpdateStatus: () => updateStatus.current,
 }));
 
 vi.mock('@/hooks/useUpdateBannerDismiss', () => ({
   useUpdateBannerDismiss: () => ({
-    dismissed: false,
-    dismiss: vi.fn(),
-    restore: vi.fn(),
-    isNewUpdateAfterDismiss: vi.fn(() => false),
+    dismissed: dismissState.dismissed,
+    dismiss: () => { dismissState.dismissed = true; },
+    restore: () => { dismissState.dismissed = false; },
+    isNewUpdateAfterDismiss: () => false,
   }),
 }));
 
@@ -43,9 +54,20 @@ vi.mock('@/components/ui/tooltip', () => ({
 
 import { UpdateBanner } from '@/components/sidebar/UpdateBanner';
 
+/** 返回一个手动 settle 的探针,用于把「点击后、resolve 前」这段窗口撑开。 */
+function deferredProbe(): (busy: boolean) => void {
+  let settle!: (busy: boolean) => void;
+  anySessionInTurn.mockImplementation(
+    () => new Promise<boolean>((resolve) => { settle = resolve; }),
+  );
+  return (busy: boolean) => settle(busy);
+}
+
 beforeEach(() => {
   anySessionInTurn.mockReset();
   relaunchToUpdate.mockReset();
+  updateStatus.current = { status: 'ready', version: '1.2.3', errorCode: null };
+  dismissState.dismissed = false;
   Object.defineProperty(window, 'electronAPI', {
     configurable: true,
     value: {
@@ -101,10 +123,7 @@ describe('UpdateBanner relaunch entry', () => {
   });
 
   it('ignores repeat clicks while the busy probe is still in flight', async () => {
-    let resolveTurnCheck!: (busy: boolean) => void;
-    anySessionInTurn.mockImplementation(
-      () => new Promise<boolean>((resolve) => { resolveTurnCheck = resolve; }),
-    );
+    const settle = deferredProbe();
     render(<UpdateBanner isCollapsed={false} />);
 
     const entry = screen.getByRole('button', { name: 'update.banner.ariaExpanded' });
@@ -115,7 +134,7 @@ describe('UpdateBanner relaunch entry', () => {
     await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
     expect(relaunchToUpdate).not.toHaveBeenCalled();
 
-    resolveTurnCheck(false);
+    settle(false);
     await waitFor(() => expect(relaunchToUpdate).toHaveBeenCalledTimes(1));
   });
 
@@ -138,4 +157,84 @@ describe('UpdateBanner relaunch entry', () => {
     expect(screen.getByRole('button', { name: 'update.banner.cancelAria' })).toBeTruthy();
     expect(relaunchToUpdate).not.toHaveBeenCalled();
   });
+
+  // ── 不变量:探针结论只在这次点击仍然有效时才生效 ──
+  // 三条路径都会在探针在飞期间让点击失效,少任何一条都是一个真实缺陷。
+
+  it('discards the probe when the user dismisses the banner while it is in flight', async () => {
+    const settle = deferredProbe();
+    const { rerender } = render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+
+    // 用户点「稍后再说」= 明确表达现在不要重启。
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.dismissAria' }));
+    rerender(<UpdateBanner isCollapsed={false} />);
+    settle(false);
+
+    // 给 continuation 足够的微任务窗口跑完,再断言它什么都没做。
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+  });
+
+  it('leaves no confirming state behind when dismissed mid-probe with a busy result', async () => {
+    const settle = deferredProbe();
+    const { rerender } = render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.dismissAria' }));
+    rerender(<UpdateBanner isCollapsed={false} />);
+    expect(screen.queryByRole('button', { name: 'update.banner.ariaExpanded' })).toBeNull();
+
+    settle(true);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    // 火焰按钮唤回(restore 不卸载组件,残留的 state 会原样显示出来)。confirming 若被
+    // 那个已作废的探针置位,用户没再点过入口就会直接落在第二步。
+    dismissState.dismissed = false;
+    rerender(<UpdateBanner isCollapsed={false} />);
+
+    expect(screen.getByRole('button', { name: 'update.banner.ariaExpanded' })).toBeTruthy();
+    expect(screen.queryByRole('button', { name: 'update.banner.confirmAria' })).toBeNull();
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+  });
+
+  it('discards the probe when the ready patch gets superseded while it is in flight', async () => {
+    const settle = deferredProbe();
+    const { rerender } = render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+
+    // 新版本下载完成,已就绪补丁被顶掉:此时重启会装回旧补丁。
+    updateStatus.current = { status: 'superseding', version: '1.2.3', errorCode: null };
+    rerender(<UpdateBanner isCollapsed={false} />);
+    settle(false);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+    // superseding 态本身仍正常渲染(准备中),不该被这次作废影响。
+    expect(screen.getByText('update.banner.preparingButton')).toBeTruthy();
+  });
+
+  it('discards the probe when the component unmounts while it is in flight', async () => {
+    const settle = deferredProbe();
+    const { unmount } = render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+
+    unmount();
+    settle(false);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+  });
 });
diff --git a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
index edf9c29960e..34a31187305 100644
--- a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
+++ b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
@@ -74,6 +74,18 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   // 刻意不给 loading UI(几毫秒的 spinner 只会闪一下),只用 ref 挡住连点导致的
   // 重复探针 / 重复重启。与 WindowControls 的关窗入口保持同样的「无 loading 态」处理。
   const relaunchProbeRef = useRef(false);
+  // 一次点击的有效性令牌。探针是异步的,点击那一刻成立的前提在 resolve 时可能已经不成立:
+  // 用户点了右上角「稍后再说」、新版本把已就绪补丁顶成 superseding、组件被卸载,或用户
+  // 又点了一次入口。任一情况都让 epoch 前进,在飞的 continuation 靠 epoch 不匹配自我作废。
+  // 不作废会有三个真实后果:①点了「稍后」却突然重启;②superseding 期间重启并装回旧补丁;
+  // ③dismiss 之后 setConfirming(true) 残留,下次被火焰按钮唤回时直接落在第二步(用户
+  // 并没有再点入口)。
+  const relaunchEpochRef = useRef(0);
+  // continuation 里必须读「当前」status,不能读点击时闭包捕获的旧值。刻意在 render 期间
+  // 同步镜像而不是用 effect —— effect 会晚一拍,「status 已 setState 但 effect 未执行」的
+  // 区间里探针恰好 resolve 就会读到过期的 'ready'。这个 ref 只做最新值镜像,不参与渲染输出。
+  const statusRef = useRef(status);
+  statusRef.current = status;
   // 进入确认态后把焦点移到「取消」按钮 —— 键盘用户点入口键后原触发元素会卸载,
   // 若不主动聚焦,焦点会丢失、无法继续操作。刻意聚焦「取消」而非「仍要重启」:让默认落在
   // 安全动作上,避免再按一次 Enter/Space 就打断进行中的任务(即 Radix 对破坏性操作
@@ -107,11 +119,18 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   }, [isTranslocated]);
 
   // 一旦不再是 ready(如被 superseding 顶掉 / 出错),复位确认态,避免残留一个
-  // 指向旧补丁的「仍要重启」。
+  // 指向旧补丁的「仍要重启」;同时作废在飞的探针 —— 它的结论建立在「当前补丁可装」之上。
   useEffect(() => {
-    if (status !== 'ready') setConfirming(false);
+    if (status !== 'ready') {
+      relaunchEpochRef.current += 1;
+      setConfirming(false);
+    }
   }, [status]);
 
+  // 卸载时同样作废在飞的探针。卸载后 setConfirming 只是一次无效更新,但 handleRelaunch
+  // 会真的把 app 重启掉 —— 这条 cleanup 不是防 React 警告,是防意外重启。
+  useEffect(() => () => { relaunchEpochRef.current += 1; }, []);
+
   // 新更新到达时自动 restore:isNewUpdateAfterDismiss 先检查当前 status 是否为
   // active update 态(ready / superseding),再对比 dismiss 时的快照——两个条件
   // 都满足才 restore(),从而避免 remount 时 useUpdateStatus() 经历 idle→ready
@@ -167,7 +186,10 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   // 直接落在「确认重启」界面(那是两步流程的第二步,越过第一步显示不合适)。
   // 传入当前 status/version 让 store 记录快照,用于后续区分「同一更新 remount」
   // 与「真正新更新到达」,避免导航到 /settings 再回来时误 restore。
+  // 同时作废在飞的探针:用户点「稍后再说」就是明确表达「现在不要重启」,几毫秒后 resolve
+  // 的探针结论不能反过来推翻它(否则轻则 confirming 残留、重则直接重启)。
   const handleDismiss = () => {
+    relaunchEpochRef.current += 1;
     setConfirming(false);
     dismiss(status, version ?? null);
   };
@@ -192,9 +214,16 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   //   - 没有        → 直接重启,不再多要一次无信息量的确认。
   // 探针失败(splash / login 阶段 handler 未注册,或桥同步 throw)按 false 处理 —— 与
   // WindowControls.handleCloseClick 完全同构;banner 只在主界面出现,那时 handler 早已注册。
+  // main 侧的 anySessionInTurn 是纯同步 snapshot(maker-ipc/register.ts),不会因运行期
+  // 状态切换而 reject。
+  //
+  // await 之后的两道复核是必需的,不是防御性冗余:探针在飞期间用户可能 dismiss、组件可能
+  // 卸载、已就绪补丁可能被 superseding 顶掉。少了它们,「点了稍后却重启」「装回旧补丁」
+  // 「confirming 残留到下次唤回」三种都会真实发生。
   const handleRelaunchClick = async (): Promise<void> => {
     if (relaunchProbeRef.current) return;
     relaunchProbeRef.current = true;
+    const epoch = relaunchEpochRef.current;
     let hasInFlight = false;
     try {
       hasInFlight = await window.electronAPI.anySessionInTurn();
@@ -203,6 +232,11 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
     } finally {
       relaunchProbeRef.current = false;
     }
+    // 这次点击是否仍然有效(未被 dismiss / 卸载 / status 离开 ready 作废)。
+    if (epoch !== relaunchEpochRef.current) return;
+    // status 变化的作废由上面那个 effect 打点,但 effect 会晚一拍;这里直接读最新值,
+    // 关掉「已 setState 未跑 effect」的那段窗口。两道判定针对同一不变量的不同触发路径。
+    if (statusRef.current !== 'ready') return;
     if (hasInFlight) setConfirming(true);
     else handleRelaunch();
   };

From fd8dd0aa1d10945e08c9da9d7facf3ca1d4c72cf Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 17:29:33 +0800
Subject: [PATCH 03/11] =?UTF-8?q?fix(desktop):=20=E9=87=8D=E5=90=AF?=
 =?UTF-8?q?=E6=8E=A2=E9=92=88=E6=8B=BF=E4=B8=8D=E5=88=B0=E7=AD=94=E6=A1=88?=
 =?UTF-8?q?=E6=97=B6=20fail=20closed=EF=BC=8C=E5=B9=B6=E7=BB=99=E7=A1=AE?=
 =?UTF-8?q?=E8=AE=A4=E6=8C=89=E9=92=AE=E8=A1=A5=E4=B8=8A=E5=AE=BE=E8=AF=AD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

两条 review 反馈，都采纳：

1. 探针失败不再当作「没有任务」。上一版把 catch 兜底写成 false，论证是「与
   WindowControls.handleCloseClick 同构」——那个论证只看了半个仓库。
   bootstrap-electron.ts 的托盘退出路径对同一个探针是 fail closed 的，注释写得
   很明确：「A failed busy probe must not turn the tray into an unguarded exit
   path.」重启会不可撤销地杀掉 in-flight turn，跟托盘退出同属破坏性入口，所以
   跟的是这条口径，不是关窗那条更宽松的一半。「无法确认」不能当成「确认没有」。
   代价只有探针真失败时多出来的一次确认；正常路径（handler 已注册、main 侧是
   纯同步 snapshot）不受影响。初值也从 false 改成 true，让所有「没拿到可信答案」
   的路径都落在保守那侧，而不是只补 catch 分支。

2. 确认按钮补上动作对象并改 Title Case：Restart anyway → Restart App Anyway，
   仍要重启 → 仍要重启应用，ja/ko 同步。DESIGN.md §11.1 明确要求确认对话的主
   按钮带宾语（好让它脱离上下文也读得通），§11.2 要求英文按钮 Title Case。上一版
   在 PR 描述里把「沿用同 banner 内既有 sentence case」写成刻意偏离，但既有文案
   本身就是欠的债，不构成新写的文案继续欠的理由。入口按钮（Relaunch / 立即重启）
   与 cancel 属既有 key，不在本 PR 范围内动。

测试：探针 throw 的用例从「直接重启」改为「进入中断警告且不重启」，并补一条
reject 路径（此前只覆盖同步 throw）。

验证：pnpm test:unit（56 PASS / 0 FAIL）、desktop typecheck、check:i18n-glossary、
check:i18n 全绿。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../updateBannerRelaunchEntry.test.tsx        | 24 +++++++++++++-----
 .../components/sidebar/UpdateBanner.tsx       | 25 +++++++++++--------
 .../src/renderer/i18n/locales/en/common.json  |  2 +-
 .../src/renderer/i18n/locales/ja/common.json  |  2 +-
 .../src/renderer/i18n/locales/ko/common.json  |  2 +-
 .../renderer/i18n/locales/zh-CN/common.json   |  2 +-
 6 files changed, 37 insertions(+), 20 deletions(-)

diff --git a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
index 3bd4e3a4c0a..7f5c981e966 100644
--- a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
@@ -1,9 +1,9 @@
 // @vitest-environment jsdom
 
 /**
- * UpdateBanner 的重启入口判定 —— 与关窗链路(WindowControls.handleCloseClick)同构:
- * 点入口先查 anySessionInTurn(),没有任务在跑就直接重启,有才拦一次并说明「会打断
- * 进行中的任务」。探针失败按「没有任务」处理。
+ * UpdateBanner 的重启入口判定:点入口先查 anySessionInTurn(),确认没有任务在跑才直接重启,
+ * 有任务(或探针拿不到可信答案)就拦一次并说明「会打断进行中的任务」。探针失败刻意 fail
+ * closed —— 重启会不可撤销地杀掉 in-flight turn,「无法确认」不能当成「确认没有」。
  *
  * 另一半是**不变量:一次点击的探针结论,只有在这次点击仍然有效时才能驱动副作用**。
  * 探针在飞期间 dismiss、组件卸载、status 离开 ready 都必须让它作废 —— 三条对称路径
@@ -110,7 +110,9 @@ describe('UpdateBanner relaunch entry', () => {
     expect(screen.queryByText('update.banner.confirmBusyHint')).toBeNull();
   });
 
-  it('relaunches when the busy probe throws synchronously (bridge unavailable)', async () => {
+  // 探针拿不到可信答案时 fail closed:「无法确认」不能当成「确认没有」,重启会不可撤销地
+  // 杀掉 in-flight turn。口径同 main 侧托盘退出路径的 hasActiveTurn(catch → true)。
+  it('falls back to the warning state when the busy probe throws synchronously', async () => {
     anySessionInTurn.mockImplementation(() => {
       throw new Error('electron bridge is not registered');
     });
@@ -118,8 +120,18 @@ describe('UpdateBanner relaunch entry', () => {
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
 
-    await waitFor(() => expect(relaunchToUpdate).toHaveBeenCalledTimes(1));
-    expect(screen.queryByText('update.banner.confirmBusyHint')).toBeNull();
+    await screen.findByText('update.banner.confirmBusyHint');
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+  });
+
+  it('falls back to the warning state when the busy probe rejects', async () => {
+    anySessionInTurn.mockRejectedValue(new Error('ipc channel closed'));
+    render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+
+    await screen.findByText('update.banner.confirmBusyHint');
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
   });
 
   it('ignores repeat clicks while the busy probe is still in flight', async () => {
diff --git a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
index 34a31187305..5deee41d03f 100644
--- a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
+++ b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
@@ -7,10 +7,11 @@
  * content slot and UserInfoSection in the Sidebar shell.
  *
  * 点「立即重启」不再无条件多要一次确认:先查 anySessionInTurn(),**只有真的有任务在跑
- * 时**才就地切换成确认态,没有任务就直接重启。这与关窗链路(WindowControls 的
- * handleCloseClick)是同一套判定 —— 探针为 false(含桥不可用的 catch 兜底)就直接执行,
- * 为 true 才拦一次。原先那句「应用会自动重启」的中性二次确认纯属多一次点击、不带信息,
- * 已退役。
+ * 时**才就地切换成确认态,确认没有任务就直接重启。原先那句「应用会自动重启」的中性二次
+ * 确认纯属多一次点击、不带信息,已退役。
+ *
+ * 探针拿不到可信答案时 fail closed(当作有任务),因为重启会杀掉 in-flight turn:「无法确认」
+ * 不能当成「确认没有」。这条口径跟的是 main 侧托盘退出路径,而不是 WindowControls 关窗那半。
  *
  * 因此 confirming 态的语义收窄为**「有任务在进行中,重启会打断它」的中断警告**:标题点明
  * 状态、副标题讲后果(警告色)、主按钮「仍要重启」占据入口按钮原位(鼠标零位移),「取消」
@@ -212,10 +213,13 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   // 入口「立即重启」/ 收起态火焰按钮的点击。展开态与收起态共用一份判定:
   //   - 有任务在跑 → 进 confirming 态,把「会打断进行中的任务」这件事说清楚,由用户拍板;
   //   - 没有        → 直接重启,不再多要一次无信息量的确认。
-  // 探针失败(splash / login 阶段 handler 未注册,或桥同步 throw)按 false 处理 —— 与
-  // WindowControls.handleCloseClick 完全同构;banner 只在主界面出现,那时 handler 早已注册。
-  // main 侧的 anySessionInTurn 是纯同步 snapshot(maker-ipc/register.ts),不会因运行期
-  // 状态切换而 reject。
+  // 探针失败 = **无法确认**,不等于「没有任务」。重启会杀掉 in-flight turn,属于不可撤销的
+  // 破坏性动作,所以这里 fail closed:退化成中断警告让用户自己拍板,而不是静默重启。口径对齐
+  // main 侧托盘退出路径(bootstrap-electron.ts 的 hasActiveTurn:「A failed busy probe must
+  // not turn the tray into an unguarded exit path.」)—— 同样是「破坏性入口 + 探针不可确认」。
+  // 代价只有探针真失败时多出来的一次确认;正常路径(handler 已注册,main 侧是纯同步 snapshot)
+  // 不受影响。注意 WindowControls.handleCloseClick 的 catch 走的是 false,那条是既有行为,
+  // 本 PR 不改它,但新入口不跟随更宽松的那一半。
   //
   // await 之后的两道复核是必需的,不是防御性冗余:探针在飞期间用户可能 dismiss、组件可能
   // 卸载、已就绪补丁可能被 superseding 顶掉。少了它们,「点了稍后却重启」「装回旧补丁」
@@ -224,11 +228,12 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
     if (relaunchProbeRef.current) return;
     relaunchProbeRef.current = true;
     const epoch = relaunchEpochRef.current;
-    let hasInFlight = false;
+    // 初值取 true:探针没给出可信答案的任何路径(reject、桥同步 throw)都落在保守的那一侧。
+    let hasInFlight = true;
     try {
       hasInFlight = await window.electronAPI.anySessionInTurn();
     } catch {
-      hasInFlight = false;
+      hasInFlight = true;
     } finally {
       relaunchProbeRef.current = false;
     }
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index 6d4ff3ecf83..fba63cda442 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -4148,7 +4148,7 @@
       "preparingAria": "Preparing newer version, please wait",
       "confirmTitle": "A task is still running",
       "confirmBusyHint": "Restarting will interrupt it",
-      "confirmButton": "Restart anyway",
+      "confirmButton": "Restart App Anyway",
       "cancel": "Cancel",
       "confirmTooltip": "A task is still running — restarting will interrupt it",
       "cancelTooltip": "Cancel",
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 854408d445e..dadafb86ea7 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -4147,7 +4147,7 @@
       "preparingAria": "新しいバージョンを準備中、お待ちください",
       "confirmTitle": "実行中のタスクがあります",
       "confirmBusyHint": "再起動すると中断されます",
-      "confirmButton": "それでも再起動",
+      "confirmButton": "それでもアプリを再起動",
       "cancel": "キャンセル",
       "confirmTooltip": "実行中のタスクがあります — 再起動すると中断されます",
       "cancelTooltip": "キャンセル",
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 4a2dcf412d8..e9ede5004c6 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -4147,7 +4147,7 @@
       "preparingAria": "새 버전 준비 중입니다. 잠시만 기다려 주세요",
       "confirmTitle": "아직 실행 중인 작업이 있습니다",
       "confirmBusyHint": "재시작하면 작업이 중단됩니다",
-      "confirmButton": "그래도 재시작",
+      "confirmButton": "그래도 앱 재시작",
       "cancel": "취소",
       "confirmTooltip": "아직 실행 중인 작업이 있습니다 — 재시작하면 중단됩니다",
       "cancelTooltip": "취소",
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
index fe3f94c097c..75b5f83d98d 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -4147,7 +4147,7 @@
       "preparingAria": "正在准备新版本，请稍候",
       "confirmTitle": "仍有任务在运行中",
       "confirmBusyHint": "重启会中断运行中的任务",
-      "confirmButton": "仍要重启",
+      "confirmButton": "仍要重启应用",
       "cancel": "取消",
       "confirmTooltip": "仍有任务在运行中，重启会中断它",
       "cancelTooltip": "取消",

From b13938639d80b70d24111f69af21d316b7257231 Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 17:59:14 +0800
Subject: [PATCH 04/11] =?UTF-8?q?fix(desktop):=20busy=20=E5=88=A4=E5=AE=9A?=
 =?UTF-8?q?=E8=A1=A5=E4=B8=8A=E3=80=8Cturn=20=E5=B7=B2=E7=BB=93=E6=9D=9F?=
 =?UTF-8?q?=E4=BD=86=E4=BB=8D=E5=9C=A8=E8=B0=83=E6=A8=A1=E5=9E=8B=E3=80=8D?=
 =?UTF-8?q?=E7=9A=84=E5=90=8E=E5=8F=B0=E6=B4=BB=E5=8A=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

review 指出 anySessionInTurn() 查不到后台活动，这是改成单击直达后**新增**的
无保护场景 —— 旧流程无论如何都有第二次确认，用户至少能看到一屏并中止。

channels.ts 把「turn 已结束但 CC 子进程仍在调模型」(后台子 agent、
run_in_background 的 Bash) 维护成与逻辑 turn 完全独立的状态
(SESSION_BACKGROUND_ACTIVITY)，anySessionInTurn 只看 SessionTurnActivityTracker
与 live session 的 isTurnRunning，两者互不覆盖。所以父 turn 刚结束、后台子 agent
还在跑时，点一下就会经 forceQuit() 直接 process.exit(0) 把它打断或留成失联进程。

改为并行查两个来源，任一为真就进中断警告态：
- anySessionInTurn()
- maker.listSessionBackgroundActivity()（preload 已有，renderer 侧现成 API）

Promise.all 任一 reject 仍落到 catch → fail closed，与上一版一致。

刻意未覆盖并已在注释与 PR 描述写明：scheduler「run 已启动但 turn 尚未开始」的
窄窗口。它没有 renderer 侧查询入口（main 的无人值守探针另走 SQLite
hasRunningRuns），且 run 真跑起来后会产生 turn，落回第一个来源。没有把它当成
已覆盖。

未采用「复用 main 侧无人值守重启探针」的建议：那套判定含远程 controller 与
remote invoke，对无人值守是对的，但手动重启是用户主动发起 —— 有远程设备在看
会话列表并不构成「会被打断的任务」，套过来会产生误报警告。

测试补两条并验证过能区分错误修法（临时移除后台活动查询后两条全红）：
- 只有后台活动、无 turn → 进警告态且不重启，点确认才重启
- 后台活动查询 reject → fail closed

验证：pnpm test:unit 56 PASS / 0 FAIL、desktop typecheck 通过。首跑时
apps/mobile 的 startupSplashOverlay 用例 5s 超时，单独跑 733ms 通过、重跑全量
亦通过，是负载下的 flake，与本改动（desktop renderer）无关。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../updateBannerRelaunchEntry.test.tsx        | 45 +++++++++++++++++--
 .../updateBannerReleaseNotesLink.test.tsx     |  6 ++-
 .../components/sidebar/UpdateBanner.tsx       | 27 ++++++++---
 3 files changed, 68 insertions(+), 10 deletions(-)

diff --git a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
index 7f5c981e966..5589ff6d7bb 100644
--- a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
@@ -1,9 +1,12 @@
 // @vitest-environment jsdom
 
 /**
- * UpdateBanner 的重启入口判定:点入口先查 anySessionInTurn(),确认没有任务在跑才直接重启,
- * 有任务(或探针拿不到可信答案)就拦一次并说明「会打断进行中的任务」。探针失败刻意 fail
- * closed —— 重启会不可撤销地杀掉 in-flight turn,「无法确认」不能当成「确认没有」。
+ * UpdateBanner 的重启入口判定:点入口先查「有没有任务在跑」,确认没有才直接重启,有任务
+ * (或探针拿不到可信答案)就拦一次并说明「会打断进行中的任务」。探针失败刻意 fail closed
+ * —— 重启会不可撤销地杀掉 in-flight turn,「无法确认」不能当成「确认没有」。
+ *
+ * 「有任务在跑」有**两个独立来源**,各有一条用例:逻辑 turn(anySessionInTurn)与 turn 已
+ * 结束但仍在调模型的后台活动(listSessionBackgroundActivity)。漏任一个都是无保护入口。
  *
  * 另一半是**不变量:一次点击的探针结论,只有在这次点击仍然有效时才能驱动副作用**。
  * 探针在飞期间 dismiss、组件卸载、status 离开 ready 都必须让它作废 —— 三条对称路径
@@ -13,8 +16,11 @@
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-const { anySessionInTurn, relaunchToUpdate, updateStatus, dismissState } = vi.hoisted(() => ({
+const {
+  anySessionInTurn, listSessionBackgroundActivity, relaunchToUpdate, updateStatus, dismissState,
+} = vi.hoisted(() => ({
   anySessionInTurn: vi.fn<() => Promise<boolean>>(),
+  listSessionBackgroundActivity: vi.fn<() => Promise<{ sessionIds: string[] }>>(),
   relaunchToUpdate: vi.fn(),
   updateStatus: {
     current: { status: 'ready', version: '1.2.3', errorCode: null } as {
@@ -65,6 +71,9 @@ function deferredProbe(): (busy: boolean) => void {
 
 beforeEach(() => {
   anySessionInTurn.mockReset();
+  listSessionBackgroundActivity.mockReset();
+  // 默认没有后台活动 —— 每条用例只需声明它关心的那个来源。
+  listSessionBackgroundActivity.mockResolvedValue({ sessionIds: [] });
   relaunchToUpdate.mockReset();
   updateStatus.current = { status: 'ready', version: '1.2.3', errorCode: null };
   dismissState.dismissed = false;
@@ -73,6 +82,7 @@ beforeEach(() => {
     value: {
       anySessionInTurn,
       relaunchToUpdate,
+      maker: { listSessionBackgroundActivity },
       clientEndpoints: { websiteUrl: 'https://cindy.ai' },
     } as unknown as Window['electronAPI'],
   });
@@ -110,6 +120,33 @@ describe('UpdateBanner relaunch entry', () => {
     expect(screen.queryByText('update.banner.confirmBusyHint')).toBeNull();
   });
 
+  // 第二个来源:turn 已结束但 CC 子进程仍在调模型(后台子 agent / run_in_background 的
+  // Bash)。anySessionInTurn 查不到它 —— 改成单击直达前,这个缺口被无条件二次确认盖着。
+  it('warns when only post-turn background activity is running', async () => {
+    anySessionInTurn.mockResolvedValue(false);
+    listSessionBackgroundActivity.mockResolvedValue({ sessionIds: ['sess-bg-1'] });
+    render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+
+    await screen.findByText('update.banner.confirmBusyHint');
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.confirmAria' }));
+    expect(relaunchToUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it('falls back to the warning state when the background-activity query rejects', async () => {
+    anySessionInTurn.mockResolvedValue(false);
+    listSessionBackgroundActivity.mockRejectedValue(new Error('ipc channel closed'));
+    render(<UpdateBanner isCollapsed={false} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
+
+    await screen.findByText('update.banner.confirmBusyHint');
+    expect(relaunchToUpdate).not.toHaveBeenCalled();
+  });
+
   // 探针拿不到可信答案时 fail closed:「无法确认」不能当成「确认没有」,重启会不可撤销地
   // 杀掉 in-flight turn。口径同 main 侧托盘退出路径的 hasActiveTurn(catch → true)。
   it('falls back to the warning state when the busy probe throws synchronously', async () => {
diff --git a/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
index 742ac9fc3c4..13085eec090 100644
--- a/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
@@ -40,8 +40,9 @@ const LINK = 'update.banner.viewNotes';
 
 // 入口按钮现在先查 busy 探针再决定「直接重启 vs 进中断警告态」,所以这个文件也需要
 // 一个 electronAPI 桩;默认没有任务在跑(本文件只关心文字链,不关心重启)。
-const { anySessionInTurn, relaunchToUpdate } = vi.hoisted(() => ({
+const { anySessionInTurn, listSessionBackgroundActivity, relaunchToUpdate } = vi.hoisted(() => ({
   anySessionInTurn: vi.fn<() => Promise<boolean>>(),
+  listSessionBackgroundActivity: vi.fn<() => Promise<{ sessionIds: string[] }>>(),
   relaunchToUpdate: vi.fn(),
 }));
 
@@ -51,12 +52,15 @@ beforeEach(() => {
   fetchReleaseNotes.mockResolvedValue(NOTES);
   anySessionInTurn.mockReset();
   anySessionInTurn.mockResolvedValue(false);
+  listSessionBackgroundActivity.mockReset();
+  listSessionBackgroundActivity.mockResolvedValue({ sessionIds: [] });
   relaunchToUpdate.mockReset();
   Object.defineProperty(window, 'electronAPI', {
     configurable: true,
     value: {
       anySessionInTurn,
       relaunchToUpdate,
+      maker: { listSessionBackgroundActivity },
       clientEndpoints: { websiteUrl: 'https://cindy.ai' },
     } as unknown as Window['electronAPI'],
   });
diff --git a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
index 5deee41d03f..60f353e9922 100644
--- a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
+++ b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
@@ -6,9 +6,9 @@
  * of the already-ready patch (status === 'superseding'). Sits between the upper
  * content slot and UserInfoSection in the Sidebar shell.
  *
- * 点「立即重启」不再无条件多要一次确认:先查 anySessionInTurn(),**只有真的有任务在跑
- * 时**才就地切换成确认态,确认没有任务就直接重启。原先那句「应用会自动重启」的中性二次
- * 确认纯属多一次点击、不带信息,已退役。
+ * 点「立即重启」不再无条件多要一次确认:先查「有没有任务在跑」(逻辑 turn + turn 已结束但
+ * 仍在调模型的后台活动,两个来源都要看),**只有真的有任务时**才就地切换成确认态,确认没有
+ * 就直接重启。原先那句「应用会自动重启」的中性二次确认纯属多一次点击、不带信息,已退役。
  *
  * 探针拿不到可信答案时 fail closed(当作有任务),因为重启会杀掉 in-flight turn:「无法确认」
  * 不能当成「确认没有」。这条口径跟的是 main 侧托盘退出路径,而不是 WindowControls 关窗那半。
@@ -213,6 +213,18 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   // 入口「立即重启」/ 收起态火焰按钮的点击。展开态与收起态共用一份判定:
   //   - 有任务在跑 → 进 confirming 态,把「会打断进行中的任务」这件事说清楚,由用户拍板;
   //   - 没有        → 直接重启,不再多要一次无信息量的确认。
+  //
+  // 「有任务在跑」必须同时看两个来源,漏一个就是一个无保护的中断入口:
+  //   1. anySessionInTurn() —— 逻辑 turn(SessionTurnActivityTracker + live session)。
+  //   2. listSessionBackgroundActivity() —— **turn 已结束但 CC 子进程仍在调模型**的后台
+  //      活动(后台子 agent、run_in_background 的 Bash)。channels.ts 把它维护成与 turn
+  //      完全独立的状态,anySessionInTurn 查不到它。
+  // 改成单击直达之前,这个缺口被那道无条件二次确认盖住了(用户至少能看到一屏并中止);
+  // 现在没有那道兜底,必须自己覆盖到。
+  //
+  // 已知未覆盖(刻意,不假装全覆盖):scheduler 里「run 已启动但 turn 尚未开始」的窄窗口。
+  // 它没有 renderer 侧的查询入口(main 的无人值守探针另有 hasRunningRuns 走 SQLite),
+  // 而 run 真跑起来后会产生 turn,落回第 1 条。
   // 探针失败 = **无法确认**,不等于「没有任务」。重启会杀掉 in-flight turn,属于不可撤销的
   // 破坏性动作,所以这里 fail closed:退化成中断警告让用户自己拍板,而不是静默重启。口径对齐
   // main 侧托盘退出路径(bootstrap-electron.ts 的 hasActiveTurn:「A failed busy probe must
@@ -228,10 +240,15 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
     if (relaunchProbeRef.current) return;
     relaunchProbeRef.current = true;
     const epoch = relaunchEpochRef.current;
-    // 初值取 true:探针没给出可信答案的任何路径(reject、桥同步 throw)都落在保守的那一侧。
+    // 初值取 true:探针没给出可信答案的任何路径(任一 reject、桥同步 throw)都落在保守的
+    // 那一侧。两个查询并行 —— 它们互不依赖,没理由把两次 IPC 串起来等。
     let hasInFlight = true;
     try {
-      hasInFlight = await window.electronAPI.anySessionInTurn();
+      const [inTurn, background] = await Promise.all([
+        window.electronAPI.anySessionInTurn(),
+        window.electronAPI.maker.listSessionBackgroundActivity(),
+      ]);
+      hasInFlight = inTurn || background.sessionIds.length > 0;
     } catch {
       hasInFlight = true;
     } finally {

From f27cdfadc15055eb3cd159d88df498895c7f3cd2 Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 21:03:53 +0800
Subject: [PATCH 05/11] =?UTF-8?q?fix(desktop):=20=E9=87=8D=E5=90=AF?=
 =?UTF-8?q?=E9=98=BB=E6=96=AD=E5=88=A4=E5=AE=9A=E6=94=B6=E5=88=B0=20main?=
 =?UTF-8?q?=20=E4=BE=A7=E4=B8=80=E5=A4=84=EF=BC=8C=E8=A1=A5=E4=B8=8A=20Gho?=
 =?UTF-8?q?st=20=E5=90=8E=E5=8F=B0=E6=B4=BB=E5=8A=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

review 连续三轮指出同一形状的问题：又一个活动来源没被 busy 判定覆盖（逻辑 turn
→ Claude 后台活动 → Ghost card-action）。根因不是漏了某个来源，而是判定放在
renderer 侧逐个枚举，而「有哪些活动来源」在本仓没有单一事实源——每加一个来源就
漏一次，漏掉的后果是静默打断用户任务且不可撤销。

改成 main 侧一处判定，renderer 只问一次结论：

- 新增 relaunchBusyActivity.ts：纯函数聚合三个来源，依赖全注入。三源等价无主次，
  任一报忙即忙；**任一来源读取抛错也算忙**（「无法确认」不等于「确认没有」），
  标签带 -probe-failed 后缀以便在日志里区分「真有活动」与「探针坏了」。不短路，
  reasons 完整反映现场。
- GhostSessionActivityTracker 加 anySessionBusy()：它此前只有 per-session 的
  isSessionBusy，而 renderer 侧 ghostSessionActivityStore 只靠 0↔1 推送累积、
  没有全量快照通道，首次订阅拿不到已在跑的活动，不能当权威来源。
- bootstrap-electron 注册 update-relaunch:blocking-activity：那是本进程唯一能同时
  看到 maker 与 cindy-brain 两侧跟踪器的位置。与既有的无人值守探针
  (setUpdateAutoRelaunchBusyProbe) 刻意分开——后者连「有远程设备在看会话」都让路，
  手动重启只该关心「这一下会打断哪些正在跑的活」，把远程 controller 纳进来只会
  产生误报警告。
- UpdateBanner 改为单次查询，renderer 不再枚举来源；新增来源以后只改 main 那一处。

device-link allowlist：不登记。allowlist 顶部注释把 updater 类列为「永不放行」，
且远程控制端不会代替用户点被控端的更新重启。

刻意未覆盖并已写进注释：scheduler「run 已启动但 turn 尚未开始」的窄窗口——纳入它
要引入 SQLite 异步查询，而 run 真跑起来会产生 turn、落回第一个来源。

未触及 updateService.ts 与 cindy-updater/：本 PR 只提供判定查询，不改重启执行路径，
因此不在 docs/dev-rules/cindy-updater.md 的门禁范围内。

测试：relaunchBusyActivity 9 条（三源各一条 + 多源并发 + 三源各自 fail-closed +
一源抛错不影响其它源）、ghostSessionActivity 补 anySessionBusy 4 条（含多会话引用
计数与 TTL 兜底）。renderer 侧删掉两条已搬走职责的用例，改为只测「拿到 true 就拦、
false 才走、拿不到就保守」这一契约。

验证：pnpm test:unit 56 PASS / 0 FAIL（desktop 60.3s、mobile 11.0s）、desktop
typecheck 通过。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../__tests__/relaunchBusyActivity.test.ts    | 83 +++++++++++++++++++
 apps/desktop/src/main/bootstrap-electron.ts   | 23 +++++
 .../__tests__/ghostSessionActivity.test.ts    | 37 +++++++++
 .../main/cindy-brain/ghostSessionActivity.ts  | 14 ++++
 apps/desktop/src/main/relaunchBusyActivity.ts | 74 +++++++++++++++++
 apps/desktop/src/preload/preload.ts           |  9 ++
 .../updateBannerRelaunchEntry.test.tsx        | 77 +++++------------
 .../updateBannerReleaseNotesLink.test.tsx     | 18 ++--
 .../components/sidebar/UpdateBanner.tsx       | 36 +++-----
 apps/desktop/src/renderer/vite-env.d.ts       |  5 ++
 10 files changed, 287 insertions(+), 89 deletions(-)
 create mode 100644 apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
 create mode 100644 apps/desktop/src/main/relaunchBusyActivity.ts

diff --git a/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts b/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
new file mode 100644
index 00000000000..e94fd144732
--- /dev/null
+++ b/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
@@ -0,0 +1,83 @@
+/**
+ * 手动更新重启的阻断判定 —— 三个活动来源的聚合与 fail-closed。
+ *
+ * 这个判定服务的是不可撤销的破坏性动作(forceQuit → process.exit(0)),所以两条不变量:
+ *  1. **任一来源报忙就是忙**（三源等价，没有主次）;
+ *  2. **任一来源读不出来也算忙**（「无法确认」不等于「确认没有」）。
+ * 每个来源各有一条独立用例 —— 少一条就意味着少覆盖一个真实的静默中断入口。
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { evaluateRelaunchBusyActivity } from '../relaunchBusyActivity.js';
+
+const idle = {
+  anySessionInTurn: () => false,
+  listClaudeBackgroundSessions: () => [] as readonly string[],
+  anyGhostSessionBusy: () => false,
+};
+
+describe('evaluateRelaunchBusyActivity', () => {
+  it('全部空闲时不阻断', () => {
+    expect(evaluateRelaunchBusyActivity(idle)).toEqual({ busy: false, reasons: [] });
+  });
+
+  it('逻辑 turn 在跑时阻断', () => {
+    const r = evaluateRelaunchBusyActivity({ ...idle, anySessionInTurn: () => true });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['session-in-turn']);
+  });
+
+  it('Claude 后台活动(turn 已结束但仍在调模型)时阻断', () => {
+    const r = evaluateRelaunchBusyActivity({
+      ...idle,
+      listClaudeBackgroundSessions: () => ['sess-a'],
+    });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['claude-background-activity']);
+  });
+
+  it('Ghost card-action 后台活动时阻断(它完全不经 LLM turn)', () => {
+    const r = evaluateRelaunchBusyActivity({ ...idle, anyGhostSessionBusy: () => true });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['ghost-background-activity']);
+  });
+
+  it('多个来源同时命中时全部记进 reasons(不短路,便于诊断)', () => {
+    const r = evaluateRelaunchBusyActivity({
+      anySessionInTurn: () => true,
+      listClaudeBackgroundSessions: () => ['sess-a'],
+      anyGhostSessionBusy: () => true,
+    });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual([
+      'session-in-turn',
+      'claude-background-activity',
+      'ghost-background-activity',
+    ]);
+  });
+
+  it.each([
+    ['anySessionInTurn', 'session-in-turn'],
+    ['listClaudeBackgroundSessions', 'claude-background-activity'],
+    ['anyGhostSessionBusy', 'ghost-background-activity'],
+  ] as const)('%s 抛错时 fail closed 并标记探针失败', (key, label) => {
+    const r = evaluateRelaunchBusyActivity({
+      ...idle,
+      [key]: () => { throw new Error('probe exploded'); },
+    });
+    expect(r.busy).toBe(true);
+    // 标签区分「真的有活动」与「探针坏了」—— 两者都拦，但排查方向完全不同。
+    expect(r.reasons).toEqual([`${label}-probe-failed`]);
+  });
+
+  it('一个来源抛错不影响其它来源继续被读到', () => {
+    const r = evaluateRelaunchBusyActivity({
+      anySessionInTurn: () => { throw new Error('probe exploded'); },
+      listClaudeBackgroundSessions: () => [] as readonly string[],
+      anyGhostSessionBusy: () => true,
+    });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['session-in-turn-probe-failed', 'ghost-background-activity']);
+  });
+});
diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index 4a4f1f4e0c4..e60a1f9bca5 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -611,6 +611,7 @@ import { installNewMakerWindowShortcut } from './app-shortcuts/new-maker-window-
 import { registerLayoutIpc } from './layout/index.js';
 import {
   getGhostManager,
+  getGhostSessionActivityTracker,
   isGhostAvailableForActiveSession,
   refreshGhostLocalization,
   registerGhostIpc,
@@ -618,6 +619,8 @@ import {
   suspendAllGhosts,
   waitForGhostMutations,
 } from './cindy-brain/index.js';
+import { listActiveClaudeBackgroundActivitySessions } from './maker-host/claude-session-background-activity.js';
+import { evaluateRelaunchBusyActivity } from './relaunchBusyActivity.js';
 import { getGhostSetupChangeBus } from './cindy-brain/ghostSetupChangeBus.js';
 import { getGhostSetupInteractionBridge } from './cindy-brain/ghostSetupInteractionBridge.js';
 import { registerPluginMarketIpc } from './plugin-market/registerIpc.js';
@@ -849,6 +852,7 @@ const authBoundaryLog = createLogger('auth-boundary');
 // 主窗 renderer 加载失败可观测性 + dev 启动看门狗(见 renderer-boot-guard.ts 顶部注释)。
 const rendererGuardLog = createLogger('renderer-guard');
 const updatePresentationLog = createLogger('update-presentation');
+const relaunchActivityLog = createLogger('relaunch-activity');
 const voicePowerBroadcastLog = createLogger('voice-input-power');
 let rendererBootGuard: RendererBootGuard | null = null;
 
@@ -3811,6 +3815,25 @@ const registerIpcHandlers = () => {
           readScheduleBusy: () => readUpdateRelaunchScheduleBusy(getScheduleStorageIfInitialized()),
         });
       });
+      // 手动更新重启(侧栏 UpdateBanner)的阻断判定。与上面那个**无人值守**探针刻意分开:
+      // 无人值守要连「有远程设备在看会话」都让路,手动重启是用户主动发起的,只该关心
+      // 「这一下会打断哪些正在跑的活」。三个活动来源的聚合与 fail-closed 口径见
+      // relaunchBusyActivity.ts;这里只做装配 —— 它是本进程唯一能同时看到 maker 与
+      // cindy-brain 两侧跟踪器的位置。
+      //
+      // 不进 device-link allowlist:updater 类 channel 按 allowlist 顶部注释属「永不放行」,
+      // 且远程控制端不会代替用户点被控端的更新重启。
+      ipcMain.handle('update-relaunch:blocking-activity', () => {
+        const result = evaluateRelaunchBusyActivity({
+          anySessionInTurn: () => anySessionInTurn(getMakerCore()),
+          listClaudeBackgroundSessions: () => listActiveClaudeBackgroundActivitySessions(),
+          anyGhostSessionBusy: () => getGhostSessionActivityTracker().anySessionBusy(),
+        });
+        if (result.busy) {
+          relaunchActivityLog.info('manual relaunch has live activity', { reasons: result.reasons });
+        }
+        return result.busy;
+      });
       // getMakerCore() 首次调用触发 Maker 构造，同时发起自定义 MCP 初始加载。
       // await 确保第一个会话的 mcpProviders 数组已填入已保存的自定义 MCP（P2 冷启动竞态修复）。
       getMakerCore();
diff --git a/apps/desktop/src/main/cindy-brain/__tests__/ghostSessionActivity.test.ts b/apps/desktop/src/main/cindy-brain/__tests__/ghostSessionActivity.test.ts
index ec1b431808e..9a3640032db 100644
--- a/apps/desktop/src/main/cindy-brain/__tests__/ghostSessionActivity.test.ts
+++ b/apps/desktop/src/main/cindy-brain/__tests__/ghostSessionActivity.test.ts
@@ -118,4 +118,41 @@ describe('GhostSessionActivityTracker', () => {
   it('TTL 常量覆盖 mivo 单窗轮询(105s)', () => {
     expect(GHOST_SESSION_ACTIVITY_TTL_MS).toBeGreaterThan(105_000);
   });
+
+  // anySessionBusy 给「这个破坏性动作会不会打断正在干的活」这类全局判定用(更新重启前的
+  // 阻断探针)。那些调用方没有 sessionId 可传,而 renderer 侧的 store 只靠 0↔1 推送累积、
+  // 没有全量快照通道,不能当权威来源。
+  describe('anySessionBusy', () => {
+    it('没有任何在途活动时为 false', () => {
+      const { tracker } = makeTracker();
+      expect(tracker.anySessionBusy()).toBe(false);
+    });
+
+    it('任意会话有在途活动即为 true', () => {
+      const { tracker } = makeTracker();
+      tracker.begin('k1', 's1');
+      expect(tracker.anySessionBusy()).toBe(true);
+    });
+
+    it('多会话时要等最后一个结束才回到 false', () => {
+      const { tracker } = makeTracker();
+      tracker.begin('k1', 's1');
+      tracker.begin('k2', 's2');
+      tracker.end('k1');
+      expect(tracker.isSessionBusy('s1')).toBe(false);
+      // s2 还在干活 —— 此时重启仍会打断它。
+      expect(tracker.anySessionBusy()).toBe(true);
+      tracker.end('k2');
+      expect(tracker.anySessionBusy()).toBe(false);
+    });
+
+    it('TTL 兜底熄灭后也回到 false(意识崩了不会永久拦住重启)', () => {
+      const { tracker, pendingTimerIds, fire } = makeTracker();
+      tracker.begin('k1', 's1');
+      expect(tracker.anySessionBusy()).toBe(true);
+      const [ttl] = pendingTimerIds();
+      fire(ttl);
+      expect(tracker.anySessionBusy()).toBe(false);
+    });
+  });
 });
diff --git a/apps/desktop/src/main/cindy-brain/ghostSessionActivity.ts b/apps/desktop/src/main/cindy-brain/ghostSessionActivity.ts
index b3773565935..bfb503f86c1 100644
--- a/apps/desktop/src/main/cindy-brain/ghostSessionActivity.ts
+++ b/apps/desktop/src/main/cindy-brain/ghostSessionActivity.ts
@@ -62,6 +62,20 @@ export class GhostSessionActivityTracker {
     return (this.sessionKeys.get(sessionId)?.size ?? 0) > 0;
   }
 
+  /**
+   * 是否有**任意**会话存在在途的意识后台活动。
+   *
+   * 给「这个破坏性动作会不会打断正在干的活」这类全局判定用(如更新重启前的阻断探针)——
+   * 那些调用方没有 sessionId 可传,而 renderer 侧的 ghostSessionActivityStore 只靠 0↔1
+   * 推送累积集合、没有全量快照通道,首次订阅时拿不到已在跑的活动,不能作为权威来源。
+   */
+  anySessionBusy(): boolean {
+    for (const keys of this.sessionKeys.values()) {
+      if (keys.size > 0) return true;
+    }
+    return false;
+  }
+
   /**
    * 活动开始(card-action 派发成功时调;key = 衍生卡位 spawnCallId,兜底原
    * callId)。同 key 重复 begin 只续 TTL,不重复计数。
diff --git a/apps/desktop/src/main/relaunchBusyActivity.ts b/apps/desktop/src/main/relaunchBusyActivity.ts
new file mode 100644
index 00000000000..0aad7d342e1
--- /dev/null
+++ b/apps/desktop/src/main/relaunchBusyActivity.ts
@@ -0,0 +1,74 @@
+/**
+ * relaunchBusyActivity.ts — 「现在重启会不会打断正在干的活」的单一判定。
+ * ---------------------------------------------------------------------------
+ * 背景:手动更新重启(侧栏 UpdateBanner 的「立即重启」)一旦执行就走 forceQuit() ——
+ * 绕过 before-quit 链、destroyAll() 掉 Ghost Node runtime、process.exit(0)。所以点下去
+ * 之前必须回答一个问题:**当前有没有正在跑的活会被这一下打断?**
+ *
+ * 这个问题的难点不在判断,而在**来源分散**:仓里「活动」由三个互不相干的跟踪器各自维护,
+ * 谁都不知道另外两个的存在。此前 renderer 侧逐个枚举来源,结果是每加一个新来源就漏一次
+ * (PR #1197 的 review 里连续被指出三轮),而漏掉的后果是静默打断用户任务、不可撤销。
+ * 所以判定收在这里一处,renderer 只问一次结论:
+ *
+ *   1. 逻辑 turn        —— SessionTurnActivityTracker + live session 的 isTurnRunning()
+ *   2. Claude 后台活动  —— turn 已结束但 CC 子进程仍在调模型(后台子 agent、后台 Bash)
+ *   3. Ghost 后台活动   —— card-action 干活,**完全不经 LLM turn**(生成媒体等)
+ *
+ * 新增第 4 个来源时改这一个函数,不必再去翻每个调用点。
+ *
+ * **fail closed**:任一来源读取抛错都按「有活动」处理。理由是这里服务的是不可撤销的破坏性
+ * 动作,「无法确认」不能当成「确认没有」;同样口径见 bootstrap-electron 托盘退出的
+ * hasActiveTurn(「A failed busy probe must not turn the tray into an unguarded exit path.」)。
+ * 代价只是多一次确认。
+ *
+ * 刻意**不**包含的两项:
+ *  - scheduler 正在跑的 run(hasRunningRuns,SQLite 异步):这里保持同步、零 IO,好让 IPC
+ *    handler 是一次同步读。run 真跑起来会产生 turn,落回来源 1。
+ *  - 远程 controller / in-flight remote invoke:那是**无人值守**自动重启该管的
+ *    (setUpdateAutoRelaunchBusyProbe),不该管手动重启 —— 用户主动点重启时,「有远程设备
+ *    在看会话列表」不构成「会被打断的任务」,纳进来只会产生误报警告。
+ *
+ * 依赖全注入,便于单测(规则 14)。
+ */
+
+export interface RelaunchBusyActivitySources {
+  /** 是否有任意 session 正在跑逻辑 turn。 */
+  anySessionInTurn: () => boolean;
+  /** 处于「turn 已结束但仍在调模型」后台活动态的会话 id 列表。 */
+  listClaudeBackgroundSessions: () => readonly string[];
+  /** 是否有任意会话存在在途的 Ghost card-action 后台活动。 */
+  anyGhostSessionBusy: () => boolean;
+}
+
+/** 判定出的忙闲,附带命中的来源(只用于日志/诊断,不进 UI 文案)。 */
+export interface RelaunchBusyActivity {
+  busy: boolean;
+  /** 命中的来源标签;fail-closed 时是抛错的那个来源。 */
+  reasons: string[];
+}
+
+/**
+ * 三个来源全查一遍(不短路),让 reasons 能完整反映现场 —— 诊断「为什么拦了我」时,
+ * 只知道第一个命中的来源不够用。单次调用的成本是三次内存读,可忽略。
+ */
+export function evaluateRelaunchBusyActivity(
+  sources: RelaunchBusyActivitySources,
+): RelaunchBusyActivity {
+  const reasons: string[] = [];
+
+  const probe = (label: string, read: () => boolean): void => {
+    try {
+      if (read()) reasons.push(label);
+    } catch {
+      // fail closed:读不出来就当它忙(见文件头)。标签带 -probe-failed 后缀,便于在日志里
+      // 区分「真的有活动」与「探针坏了」——两者都拦,但排查方向完全不同。
+      reasons.push(`${label}-probe-failed`);
+    }
+  };
+
+  probe('session-in-turn', () => sources.anySessionInTurn());
+  probe('claude-background-activity', () => sources.listClaudeBackgroundSessions().length > 0);
+  probe('ghost-background-activity', () => sources.anyGhostSessionBusy());
+
+  return { busy: reasons.length > 0, reasons };
+}
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index 35e9fdc4f5f..42da1f4bbe5 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -2934,6 +2934,15 @@ contextBridge.exposeInMainWorld('electronAPI', {
     result: 'ready' | 'idle' | 'downloading' | 'manifest_failed' | 'download_failed' | 'manual_download';
   }> => ipcRenderer.invoke('update-check-now'),
 
+  /**
+   * 现在重启会不会打断正在跑的活。聚合三个互不相干的活动来源(逻辑 turn / Claude 后台活动 /
+   * Ghost card-action 后台活动),判定与 fail-closed 口径都在 main 侧一处
+   * (relaunchBusyActivity.ts)—— renderer 逐个枚举来源会漏,漏了就是静默打断用户任务。
+   * 供 UpdateBanner 决定「直接重启」还是「先弹中断警告」。
+   */
+  anyActivityBlockingRelaunch: (): Promise<boolean> =>
+    ipcRenderer.invoke('update-relaunch:blocking-activity'),
+
   /**
    * Tell the main process to apply the downloaded update and relaunch.
    */
diff --git a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
index 5589ff6d7bb..11f5a251eac 100644
--- a/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/updateBannerRelaunchEntry.test.tsx
@@ -5,8 +5,9 @@
  * (或探针拿不到可信答案)就拦一次并说明「会打断进行中的任务」。探针失败刻意 fail closed
  * —— 重启会不可撤销地杀掉 in-flight turn,「无法确认」不能当成「确认没有」。
  *
- * 「有任务在跑」有**两个独立来源**,各有一条用例:逻辑 turn(anySessionInTurn)与 turn 已
- * 结束但仍在调模型的后台活动(listSessionBackgroundActivity)。漏任一个都是无保护入口。
+ * 「有任务在跑」由哪些活动来源构成(逻辑 turn / Claude 后台活动 / Ghost card-action)是 main
+ * 侧一处判定的职责,覆盖面由 main/__tests__/relaunchBusyActivity.test.ts 负责。本文件只管
+ * renderer 这一侧的契约:**拿到 true 就拦、false 才走、拿不到答案就保守**。
  *
  * 另一半是**不变量:一次点击的探针结论,只有在这次点击仍然有效时才能驱动副作用**。
  * 探针在飞期间 dismiss、组件卸载、status 离开 ready 都必须让它作废 —— 三条对称路径
@@ -17,10 +18,9 @@ import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/re
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const {
-  anySessionInTurn, listSessionBackgroundActivity, relaunchToUpdate, updateStatus, dismissState,
+  anyActivityBlockingRelaunch, relaunchToUpdate, updateStatus, dismissState,
 } = vi.hoisted(() => ({
-  anySessionInTurn: vi.fn<() => Promise<boolean>>(),
-  listSessionBackgroundActivity: vi.fn<() => Promise<{ sessionIds: string[] }>>(),
+  anyActivityBlockingRelaunch: vi.fn<() => Promise<boolean>>(),
   relaunchToUpdate: vi.fn(),
   updateStatus: {
     current: { status: 'ready', version: '1.2.3', errorCode: null } as {
@@ -63,26 +63,22 @@ import { UpdateBanner } from '@/components/sidebar/UpdateBanner';
 /** 返回一个手动 settle 的探针,用于把「点击后、resolve 前」这段窗口撑开。 */
 function deferredProbe(): (busy: boolean) => void {
   let settle!: (busy: boolean) => void;
-  anySessionInTurn.mockImplementation(
+  anyActivityBlockingRelaunch.mockImplementation(
     () => new Promise<boolean>((resolve) => { settle = resolve; }),
   );
   return (busy: boolean) => settle(busy);
 }
 
 beforeEach(() => {
-  anySessionInTurn.mockReset();
-  listSessionBackgroundActivity.mockReset();
-  // 默认没有后台活动 —— 每条用例只需声明它关心的那个来源。
-  listSessionBackgroundActivity.mockResolvedValue({ sessionIds: [] });
+  anyActivityBlockingRelaunch.mockReset();
   relaunchToUpdate.mockReset();
   updateStatus.current = { status: 'ready', version: '1.2.3', errorCode: null };
   dismissState.dismissed = false;
   Object.defineProperty(window, 'electronAPI', {
     configurable: true,
     value: {
-      anySessionInTurn,
+      anyActivityBlockingRelaunch,
       relaunchToUpdate,
-      maker: { listSessionBackgroundActivity },
       clientEndpoints: { websiteUrl: 'https://cindy.ai' },
     } as unknown as Window['electronAPI'],
   });
@@ -91,14 +87,14 @@ beforeEach(() => {
 afterEach(cleanup);
 
 describe('UpdateBanner relaunch entry', () => {
-  it('warns about the interruption instead of relaunching while a turn is running', async () => {
-    anySessionInTurn.mockResolvedValue(true);
+  it('warns about the interruption instead of relaunching when main reports live activity', async () => {
+    anyActivityBlockingRelaunch.mockResolvedValue(true);
     render(<UpdateBanner isCollapsed={false} />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
 
     const hint = await screen.findByText('update.banner.confirmBusyHint');
-    expect(anySessionInTurn).toHaveBeenCalledTimes(1);
+    expect(anyActivityBlockingRelaunch).toHaveBeenCalledTimes(1);
     expect(hint.className).toContain('text-[var(--warning-fg)]');
     // 拦住的这一步不能顺手把 app 重启了 —— 是否打断任务由用户拍板。
     expect(relaunchToUpdate).not.toHaveBeenCalled();
@@ -107,50 +103,23 @@ describe('UpdateBanner relaunch entry', () => {
     expect(relaunchToUpdate).toHaveBeenCalledTimes(1);
   });
 
-  it('relaunches on the first click when no turn is running', async () => {
-    anySessionInTurn.mockResolvedValue(false);
+  it('relaunches on the first click when main reports nothing running', async () => {
+    anyActivityBlockingRelaunch.mockResolvedValue(false);
     render(<UpdateBanner isCollapsed={false} />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
 
     await waitFor(() => expect(relaunchToUpdate).toHaveBeenCalledTimes(1));
-    expect(anySessionInTurn).toHaveBeenCalledTimes(1);
+    expect(anyActivityBlockingRelaunch).toHaveBeenCalledTimes(1);
     // 没有任务在跑时不该再出现第二步 —— 那句「应用会自动重启」不带任何信息量。
     expect(screen.queryByRole('button', { name: 'update.banner.confirmAria' })).toBeNull();
     expect(screen.queryByText('update.banner.confirmBusyHint')).toBeNull();
   });
 
-  // 第二个来源:turn 已结束但 CC 子进程仍在调模型(后台子 agent / run_in_background 的
-  // Bash)。anySessionInTurn 查不到它 —— 改成单击直达前,这个缺口被无条件二次确认盖着。
-  it('warns when only post-turn background activity is running', async () => {
-    anySessionInTurn.mockResolvedValue(false);
-    listSessionBackgroundActivity.mockResolvedValue({ sessionIds: ['sess-bg-1'] });
-    render(<UpdateBanner isCollapsed={false} />);
-
-    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-
-    await screen.findByText('update.banner.confirmBusyHint');
-    expect(relaunchToUpdate).not.toHaveBeenCalled();
-
-    fireEvent.click(screen.getByRole('button', { name: 'update.banner.confirmAria' }));
-    expect(relaunchToUpdate).toHaveBeenCalledTimes(1);
-  });
-
-  it('falls back to the warning state when the background-activity query rejects', async () => {
-    anySessionInTurn.mockResolvedValue(false);
-    listSessionBackgroundActivity.mockRejectedValue(new Error('ipc channel closed'));
-    render(<UpdateBanner isCollapsed={false} />);
-
-    fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-
-    await screen.findByText('update.banner.confirmBusyHint');
-    expect(relaunchToUpdate).not.toHaveBeenCalled();
-  });
-
   // 探针拿不到可信答案时 fail closed:「无法确认」不能当成「确认没有」,重启会不可撤销地
   // 杀掉 in-flight turn。口径同 main 侧托盘退出路径的 hasActiveTurn(catch → true)。
   it('falls back to the warning state when the busy probe throws synchronously', async () => {
-    anySessionInTurn.mockImplementation(() => {
+    anyActivityBlockingRelaunch.mockImplementation(() => {
       throw new Error('electron bridge is not registered');
     });
     render(<UpdateBanner isCollapsed={false} />);
@@ -162,7 +131,7 @@ describe('UpdateBanner relaunch entry', () => {
   });
 
   it('falls back to the warning state when the busy probe rejects', async () => {
-    anySessionInTurn.mockRejectedValue(new Error('ipc channel closed'));
+    anyActivityBlockingRelaunch.mockRejectedValue(new Error('ipc channel closed'));
     render(<UpdateBanner isCollapsed={false} />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
@@ -180,7 +149,7 @@ describe('UpdateBanner relaunch entry', () => {
     fireEvent.click(entry);
     fireEvent.click(entry);
 
-    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(anyActivityBlockingRelaunch).toHaveBeenCalledTimes(1));
     expect(relaunchToUpdate).not.toHaveBeenCalled();
 
     settle(false);
@@ -188,7 +157,7 @@ describe('UpdateBanner relaunch entry', () => {
   });
 
   it('applies the same judgement to the collapsed / rail entry', async () => {
-    anySessionInTurn.mockResolvedValue(false);
+    anyActivityBlockingRelaunch.mockResolvedValue(false);
     const { unmount } = render(<UpdateBanner isCollapsed />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaCollapsed' }));
@@ -197,7 +166,7 @@ describe('UpdateBanner relaunch entry', () => {
 
     unmount();
     relaunchToUpdate.mockClear();
-    anySessionInTurn.mockResolvedValue(true);
+    anyActivityBlockingRelaunch.mockResolvedValue(true);
     render(<UpdateBanner isCollapsed />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaCollapsed' }));
@@ -215,7 +184,7 @@ describe('UpdateBanner relaunch entry', () => {
     const { rerender } = render(<UpdateBanner isCollapsed={false} />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(anyActivityBlockingRelaunch).toHaveBeenCalledTimes(1));
 
     // 用户点「稍后再说」= 明确表达现在不要重启。
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.dismissAria' }));
@@ -233,7 +202,7 @@ describe('UpdateBanner relaunch entry', () => {
     const { rerender } = render(<UpdateBanner isCollapsed={false} />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(anyActivityBlockingRelaunch).toHaveBeenCalledTimes(1));
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.dismissAria' }));
     rerender(<UpdateBanner isCollapsed={false} />);
@@ -258,7 +227,7 @@ describe('UpdateBanner relaunch entry', () => {
     const { rerender } = render(<UpdateBanner isCollapsed={false} />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(anyActivityBlockingRelaunch).toHaveBeenCalledTimes(1));
 
     // 新版本下载完成,已就绪补丁被顶掉:此时重启会装回旧补丁。
     updateStatus.current = { status: 'superseding', version: '1.2.3', errorCode: null };
@@ -277,7 +246,7 @@ describe('UpdateBanner relaunch entry', () => {
     const { unmount } = render(<UpdateBanner isCollapsed={false} />);
 
     fireEvent.click(screen.getByRole('button', { name: 'update.banner.ariaExpanded' }));
-    await waitFor(() => expect(anySessionInTurn).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(anyActivityBlockingRelaunch).toHaveBeenCalledTimes(1));
 
     unmount();
     settle(false);
diff --git a/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx b/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
index 13085eec090..129cb091f30 100644
--- a/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/updateBannerReleaseNotesLink.test.tsx
@@ -38,11 +38,10 @@ const NOTES = { version: '1.4.2', date: '2026-07-28', contributors: [], sections
 
 const LINK = 'update.banner.viewNotes';
 
-// 入口按钮现在先查 busy 探针再决定「直接重启 vs 进中断警告态」,所以这个文件也需要
+// 入口按钮现在先查阻断探针再决定「直接重启 vs 进中断警告态」,所以这个文件也需要
 // 一个 electronAPI 桩;默认没有任务在跑(本文件只关心文字链,不关心重启)。
-const { anySessionInTurn, listSessionBackgroundActivity, relaunchToUpdate } = vi.hoisted(() => ({
-  anySessionInTurn: vi.fn<() => Promise<boolean>>(),
-  listSessionBackgroundActivity: vi.fn<() => Promise<{ sessionIds: string[] }>>(),
+const { anyActivityBlockingRelaunch, relaunchToUpdate } = vi.hoisted(() => ({
+  anyActivityBlockingRelaunch: vi.fn<() => Promise<boolean>>(),
   relaunchToUpdate: vi.fn(),
 }));
 
@@ -50,17 +49,14 @@ beforeEach(() => {
   updateStatus.current = { status: 'ready', version: '1.4.2' };
   fetchReleaseNotes.mockReset();
   fetchReleaseNotes.mockResolvedValue(NOTES);
-  anySessionInTurn.mockReset();
-  anySessionInTurn.mockResolvedValue(false);
-  listSessionBackgroundActivity.mockReset();
-  listSessionBackgroundActivity.mockResolvedValue({ sessionIds: [] });
+  anyActivityBlockingRelaunch.mockReset();
+  anyActivityBlockingRelaunch.mockResolvedValue(false);
   relaunchToUpdate.mockReset();
   Object.defineProperty(window, 'electronAPI', {
     configurable: true,
     value: {
-      anySessionInTurn,
+      anyActivityBlockingRelaunch,
       relaunchToUpdate,
-      maker: { listSessionBackgroundActivity },
       clientEndpoints: { websiteUrl: 'https://cindy.ai' },
     } as unknown as Window['electronAPI'],
   });
@@ -91,7 +87,7 @@ describe('UpdateBanner release-notes link', () => {
   });
 
   it('hides the link while the busy-turn interruption warning is showing', async () => {
-    anySessionInTurn.mockResolvedValue(true);
+    anyActivityBlockingRelaunch.mockResolvedValue(true);
     render(<UpdateBanner isCollapsed={false} onOpenVersionNotice={vi.fn()} />);
     await screen.findByText(LINK);
 
diff --git a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
index 60f353e9922..8b92cf493ba 100644
--- a/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
+++ b/apps/desktop/src/renderer/components/sidebar/UpdateBanner.tsx
@@ -214,24 +214,17 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
   //   - 有任务在跑 → 进 confirming 态,把「会打断进行中的任务」这件事说清楚,由用户拍板;
   //   - 没有        → 直接重启,不再多要一次无信息量的确认。
   //
-  // 「有任务在跑」必须同时看两个来源,漏一个就是一个无保护的中断入口:
-  //   1. anySessionInTurn() —— 逻辑 turn(SessionTurnActivityTracker + live session)。
-  //   2. listSessionBackgroundActivity() —— **turn 已结束但 CC 子进程仍在调模型**的后台
-  //      活动(后台子 agent、run_in_background 的 Bash)。channels.ts 把它维护成与 turn
-  //      完全独立的状态,anySessionInTurn 查不到它。
-  // 改成单击直达之前,这个缺口被那道无条件二次确认盖住了(用户至少能看到一屏并中止);
-  // 现在没有那道兜底,必须自己覆盖到。
-  //
-  // 已知未覆盖(刻意,不假装全覆盖):scheduler 里「run 已启动但 turn 尚未开始」的窄窗口。
-  // 它没有 renderer 侧的查询入口(main 的无人值守探针另有 hasRunningRuns 走 SQLite),
-  // 而 run 真跑起来后会产生 turn,落回第 1 条。
+  // 「有任务在跑」有三个互不相干的来源(逻辑 turn / Claude 后台活动 / Ghost card-action),
+  // 判定收在 main 侧一处(relaunchBusyActivity.ts),这里只问一次结论。**刻意不在 renderer
+  // 逐个枚举来源** —— 那样每加一个新来源就会漏一次(本 PR review 里连续被指出三轮),
+  // 而漏掉的后果是静默打断用户任务。新增来源改 main 侧那一个函数即可,这里不用动。
   // 探针失败 = **无法确认**,不等于「没有任务」。重启会杀掉 in-flight turn,属于不可撤销的
-  // 破坏性动作,所以这里 fail closed:退化成中断警告让用户自己拍板,而不是静默重启。口径对齐
-  // main 侧托盘退出路径(bootstrap-electron.ts 的 hasActiveTurn:「A failed busy probe must
-  // not turn the tray into an unguarded exit path.」)—— 同样是「破坏性入口 + 探针不可确认」。
-  // 代价只有探针真失败时多出来的一次确认;正常路径(handler 已注册,main 侧是纯同步 snapshot)
-  // 不受影响。注意 WindowControls.handleCloseClick 的 catch 走的是 false,那条是既有行为,
-  // 本 PR 不改它,但新入口不跟随更宽松的那一半。
+  // 破坏性动作,所以 fail closed:退化成中断警告让用户自己拍板,而不是静默重启。main 侧对每个
+  // 来源也各自 fail closed(见 relaunchBusyActivity.ts),这里再兜住整条 IPC 失败的情况。
+  // 口径对齐 main 侧托盘退出路径(bootstrap-electron.ts 的 hasActiveTurn:「A failed busy
+  // probe must not turn the tray into an unguarded exit path.」)。注意
+  // WindowControls.handleCloseClick 的 catch 走的是 false,那条是既有行为,本 PR 不改它,
+  // 但新入口不跟随更宽松的那一半。
   //
   // await 之后的两道复核是必需的,不是防御性冗余:探针在飞期间用户可能 dismiss、组件可能
   // 卸载、已就绪补丁可能被 superseding 顶掉。少了它们,「点了稍后却重启」「装回旧补丁」
@@ -240,15 +233,10 @@ export function UpdateBanner({ isCollapsed, onOpenVersionNotice }: UpdateBannerP
     if (relaunchProbeRef.current) return;
     relaunchProbeRef.current = true;
     const epoch = relaunchEpochRef.current;
-    // 初值取 true:探针没给出可信答案的任何路径(任一 reject、桥同步 throw)都落在保守的
-    // 那一侧。两个查询并行 —— 它们互不依赖,没理由把两次 IPC 串起来等。
+    // 初值取 true:探针没给出可信答案的任何路径(reject、桥同步 throw)都落在保守的那一侧。
     let hasInFlight = true;
     try {
-      const [inTurn, background] = await Promise.all([
-        window.electronAPI.anySessionInTurn(),
-        window.electronAPI.maker.listSessionBackgroundActivity(),
-      ]);
-      hasInFlight = inTurn || background.sessionIds.length > 0;
+      hasInFlight = await window.electronAPI.anyActivityBlockingRelaunch();
     } catch {
       hasInFlight = true;
     } finally {
diff --git a/apps/desktop/src/renderer/vite-env.d.ts b/apps/desktop/src/renderer/vite-env.d.ts
index d1c150e453f..2786e3cc227 100644
--- a/apps/desktop/src/renderer/vite-env.d.ts
+++ b/apps/desktop/src/renderer/vite-env.d.ts
@@ -2808,6 +2808,11 @@ interface ElectronAPI {
   checkForUpdate: () => Promise<{
     result: 'ready' | 'idle' | 'downloading' | 'manifest_failed' | 'download_failed' | 'manual_download';
   }>;
+  /**
+   * 现在重启会不会打断正在跑的活(逻辑 turn / Claude 后台活动 / Ghost card-action 后台活动
+   * 三源聚合,判定在 main 侧一处)。UpdateBanner 用它决定「直接重启」还是「先弹中断警告」。
+   */
+  anyActivityBlockingRelaunch: () => Promise<boolean>;
   /** Tell main process to apply the update and relaunch the app.
    *  `theme` is the renderer's *resolved* light/dark (after collapsing 'system'),
    *  forwarded to cindy-updater so its splash matches the app the user is seeing. */

From 5e284d53511c729023f0dcd94daa3d8fbbbe4aec Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 21:24:26 +0800
Subject: [PATCH 06/11] =?UTF-8?q?fix(desktop):=20=E9=87=8D=E5=90=AF?=
 =?UTF-8?q?=E6=8E=A2=E9=92=88=E8=A1=A5=20scheduler=20run=20=E4=B8=8E=20sen?=
 =?UTF-8?q?der=20=E6=96=AD=E8=A8=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

两条 review 都成立，都修了。

1. **scheduler 在跑的 run 必须单独查。** 上一版文件头写「run 真跑起来会产生 turn，落回
   来源 1」——这个假设对 script 模式是错的：script-runner.ts 明确
   'script execution does not support worktrees or bound sessions'、sessionId 落空串，
   pre-run hook 阶段同理不创建 session。于是 run 已持久化为 running 而三个内存探针全空闲，
   首次点击直接 forceQuit()，run 来不及落终态、脚本子进程变成失联进程。
   判定改为 async，第四个来源复用既有 readUpdateRelaunchScheduleBusy(...)。
   顺序上：先读三个内存源，**都空闲**才查 SQLite（省掉绝大多数情况的一次往返）；拿到
   结果后复采一次内存源，关掉「查库期间新 turn 起来」的窗口——二次采样理由同
   updateRelaunchSafety.hasUpdateRelaunchBusyActivity。

2. **IPC handler 缺 sender 断言。** 这是我漏读
   electron-security-and-process-boundaries.md 的直接后果——它 §5 明写「新增 handler 不得
   以旧代码没校验为理由省略 sender 与 payload 验证」。该 handler 读全局会话 / Claude /
   Ghost / scheduler 活动态，不校验等于把「本机现在在跑什么」暴露给被导航到不可信内容的
   窗口、WebView 与子 frame。已加 assertTrustedAppRendererEvent。

为了能按仓库既有 *IpcBoundary 模式真正测到这个 guard，把 handler 注册从
bootstrap-electron.ts 抽到 relaunchBusyActivityIpc.ts（那个模块 import 一次就拉起整个
启动链，没法单测）。纯判定逻辑留在 relaunchBusyActivity.ts，零 Electron 依赖。
sources 改为工厂形态传入：maker 会在 app session owner 边界被整体换掉，提前捕获会读到
过期实例。

测试：
- relaunchBusyActivity 13 条（四源各一条 + 多源并发 + 四源各自 fail-closed + 一源抛错不
  影响其它源 + 内存源命中时不查库 + 查库期间新起 turn 被二次采样抓到）
- relaunchBusyActivityIpcBoundary 3 条：注册 channel、可信 sender 正常返回、不可信 sender
  拒绝**且一个来源都不读**（断言必须发生在读取任何跟踪器之前）

验证：pnpm test:unit 56 PASS / 0 FAIL、desktop typecheck 通过。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../__tests__/relaunchBusyActivity.test.ts    | 80 ++++++++++++++----
 .../relaunchBusyActivityIpcBoundary.test.ts   | 81 +++++++++++++++++++
 apps/desktop/src/main/bootstrap-electron.ts   | 28 +++----
 apps/desktop/src/main/relaunchBusyActivity.ts | 75 +++++++++++------
 .../src/main/relaunchBusyActivityIpc.ts       | 41 ++++++++++
 5 files changed, 249 insertions(+), 56 deletions(-)
 create mode 100644 apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
 create mode 100644 apps/desktop/src/main/relaunchBusyActivityIpc.ts

diff --git a/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts b/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
index e94fd144732..29c0e5ab936 100644
--- a/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
+++ b/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
@@ -2,9 +2,12 @@
  * 手动更新重启的阻断判定 —— 三个活动来源的聚合与 fail-closed。
  *
  * 这个判定服务的是不可撤销的破坏性动作(forceQuit → process.exit(0)),所以两条不变量:
- *  1. **任一来源报忙就是忙**（三源等价，没有主次）;
+ *  1. **任一来源报忙就是忙**（四源等价，没有主次）;
  *  2. **任一来源读不出来也算忙**（「无法确认」不等于「确认没有」）。
  * 每个来源各有一条独立用例 —— 少一条就意味着少覆盖一个真实的静默中断入口。
+ *
+ * scheduler 源尤其不能省:script 模式与 pre-run hook 阶段的 run 都不创建 session,三个内存
+ * 探针全看不到它们。
  */
 
 import { describe, expect, it } from 'vitest';
@@ -15,21 +18,22 @@ const idle = {
   anySessionInTurn: () => false,
   listClaudeBackgroundSessions: () => [] as readonly string[],
   anyGhostSessionBusy: () => false,
+  anySchedulerRunRunning: async () => false,
 };
 
 describe('evaluateRelaunchBusyActivity', () => {
-  it('全部空闲时不阻断', () => {
-    expect(evaluateRelaunchBusyActivity(idle)).toEqual({ busy: false, reasons: [] });
+  it('全部空闲时不阻断', async () => {
+    await expect(evaluateRelaunchBusyActivity(idle)).resolves.toEqual({ busy: false, reasons: [] });
   });
 
-  it('逻辑 turn 在跑时阻断', () => {
-    const r = evaluateRelaunchBusyActivity({ ...idle, anySessionInTurn: () => true });
+  it('逻辑 turn 在跑时阻断', async () => {
+    const r = await evaluateRelaunchBusyActivity({ ...idle, anySessionInTurn: () => true });
     expect(r.busy).toBe(true);
     expect(r.reasons).toEqual(['session-in-turn']);
   });
 
-  it('Claude 后台活动(turn 已结束但仍在调模型)时阻断', () => {
-    const r = evaluateRelaunchBusyActivity({
+  it('Claude 后台活动(turn 已结束但仍在调模型)时阻断', async () => {
+    const r = await evaluateRelaunchBusyActivity({
       ...idle,
       listClaudeBackgroundSessions: () => ['sess-a'],
     });
@@ -37,14 +41,15 @@ describe('evaluateRelaunchBusyActivity', () => {
     expect(r.reasons).toEqual(['claude-background-activity']);
   });
 
-  it('Ghost card-action 后台活动时阻断(它完全不经 LLM turn)', () => {
-    const r = evaluateRelaunchBusyActivity({ ...idle, anyGhostSessionBusy: () => true });
+  it('Ghost card-action 后台活动时阻断(它完全不经 LLM turn)', async () => {
+    const r = await evaluateRelaunchBusyActivity({ ...idle, anyGhostSessionBusy: () => true });
     expect(r.busy).toBe(true);
     expect(r.reasons).toEqual(['ghost-background-activity']);
   });
 
-  it('多个来源同时命中时全部记进 reasons(不短路,便于诊断)', () => {
-    const r = evaluateRelaunchBusyActivity({
+  it('多个来源同时命中时全部记进 reasons(不短路,便于诊断)', async () => {
+    const r = await evaluateRelaunchBusyActivity({
+      ...idle,
       anySessionInTurn: () => true,
       listClaudeBackgroundSessions: () => ['sess-a'],
       anyGhostSessionBusy: () => true,
@@ -61,8 +66,8 @@ describe('evaluateRelaunchBusyActivity', () => {
     ['anySessionInTurn', 'session-in-turn'],
     ['listClaudeBackgroundSessions', 'claude-background-activity'],
     ['anyGhostSessionBusy', 'ghost-background-activity'],
-  ] as const)('%s 抛错时 fail closed 并标记探针失败', (key, label) => {
-    const r = evaluateRelaunchBusyActivity({
+  ] as const)('%s 抛错时 fail closed 并标记探针失败', async (key, label) => {
+    const r = await evaluateRelaunchBusyActivity({
       ...idle,
       [key]: () => { throw new Error('probe exploded'); },
     });
@@ -71,13 +76,56 @@ describe('evaluateRelaunchBusyActivity', () => {
     expect(r.reasons).toEqual([`${label}-probe-failed`]);
   });
 
-  it('一个来源抛错不影响其它来源继续被读到', () => {
-    const r = evaluateRelaunchBusyActivity({
+  it('一个来源抛错不影响其它来源继续被读到', async () => {
+    const r = await evaluateRelaunchBusyActivity({
+      ...idle,
       anySessionInTurn: () => { throw new Error('probe exploded'); },
-      listClaudeBackgroundSessions: () => [] as readonly string[],
       anyGhostSessionBusy: () => true,
     });
     expect(r.busy).toBe(true);
     expect(r.reasons).toEqual(['session-in-turn-probe-failed', 'ghost-background-activity']);
   });
+
+  // scheduler:script 模式与 pre-run hook 阶段的 run 都不创建 session,内存探针看不到 ——
+  // 漏掉它意味着重启会让 run 来不及落终态、脚本子进程变成失联进程。
+  it('scheduler 有 run 在跑时阻断(内存源全空闲也要拦)', async () => {
+    const r = await evaluateRelaunchBusyActivity({
+      ...idle,
+      anySchedulerRunRunning: async () => true,
+    });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['scheduler-run-running']);
+  });
+
+  it('scheduler 查询 reject 时 fail closed', async () => {
+    const r = await evaluateRelaunchBusyActivity({
+      ...idle,
+      anySchedulerRunRunning: async () => { throw new Error('sqlite is gone'); },
+    });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['scheduler-run-probe-failed']);
+  });
+
+  it('内存源已命中时不再查 scheduler(省一次 SQLite 往返)', async () => {
+    let called = 0;
+    const r = await evaluateRelaunchBusyActivity({
+      ...idle,
+      anySessionInTurn: () => true,
+      anySchedulerRunRunning: async () => { called += 1; return false; },
+    });
+    expect(r.busy).toBe(true);
+    expect(called).toBe(0);
+  });
+
+  it('查库期间新起的 turn 会被二次采样抓到', async () => {
+    let turnRunning = false;
+    const r = await evaluateRelaunchBusyActivity({
+      ...idle,
+      // 第一次读为空闲;scheduler 查询期间 turn 起来,复采时才为 true。
+      anySessionInTurn: () => turnRunning,
+      anySchedulerRunRunning: async () => { turnRunning = true; return false; },
+    });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['session-in-turn']);
+  });
 });
diff --git a/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts b/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
new file mode 100644
index 00000000000..e3cedf70a64
--- /dev/null
+++ b/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
@@ -0,0 +1,81 @@
+/**
+ * 手动重启阻断查询的授权边界。
+ *
+ * 这个 handler 读的是**全局**会话 / Claude / Ghost / scheduler 活动态。带 preload 的窗口被
+ * 导航到不可信内容、WebView、子 frame 都能发 Electron IPC,不校验 sender 就等于把「本机现在
+ * 在跑什么」暴露给它们。按 docs/dev-rules/electron-security-and-process-boundaries.md §5,
+ * 新增 handler 不得以「旧代码没校验」为由省略 sender 验证 —— 这里把它钉住。
+ *
+ * 另一条要钉的:**断言必须发生在读取任何跟踪器之前**。先读后拦仍然会碰全局状态(也可能被
+ * 时序侧信道观察到),所以拒绝路径下的来源读取次数必须是 0。
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const h = vi.hoisted(() => ({
+  handlers: new Map<string, (...args: unknown[]) => unknown>(),
+  trusted: true,
+  reads: 0,
+}));
+
+vi.mock('electron', () => ({
+  ipcMain: {
+    handle: vi.fn((channel: string, handler: (...args: unknown[]) => unknown) => {
+      h.handlers.set(channel, handler);
+    }),
+  },
+}));
+vi.mock('../logger', () => ({
+  createLogger: () => ({ warn: vi.fn(), error: vi.fn(), info: vi.fn(), debug: vi.fn() }),
+}));
+vi.mock('../security/trustedAppRenderer', () => ({
+  assertTrustedAppRendererEvent: () => {
+    if (!h.trusted) throw new Error('[PERMISSION_DENIED] 此操作只能从 Cindy 主页面发起');
+  },
+}));
+
+import {
+  RELAUNCH_BLOCKING_ACTIVITY_CHANNEL,
+  registerRelaunchBusyActivityIpc,
+} from '../relaunchBusyActivityIpc.js';
+
+/** 每个来源都记一次读取,用来证明拒绝路径下一个都没被碰。 */
+function countingSources(busy: boolean) {
+  return () => ({
+    anySessionInTurn: (): boolean => { h.reads += 1; return busy; },
+    listClaudeBackgroundSessions: (): readonly string[] => { h.reads += 1; return []; },
+    anyGhostSessionBusy: (): boolean => { h.reads += 1; return false; },
+    anySchedulerRunRunning: async (): Promise<boolean> => { h.reads += 1; return false; },
+  });
+}
+
+/** handler 只把 event 交给 sender 断言(已被 mock),不读它的字段。 */
+const fakeEvent = {} as never;
+
+beforeEach(() => {
+  h.handlers.clear();
+  h.trusted = true;
+  h.reads = 0;
+});
+
+describe('registerRelaunchBusyActivityIpc', () => {
+  it('注册在约定的 channel 上', () => {
+    registerRelaunchBusyActivityIpc(countingSources(false));
+    expect(h.handlers.has(RELAUNCH_BLOCKING_ACTIVITY_CHANNEL)).toBe(true);
+  });
+
+  it('可信 sender:正常返回判定结果', async () => {
+    registerRelaunchBusyActivityIpc(countingSources(true));
+    const handler = h.handlers.get(RELAUNCH_BLOCKING_ACTIVITY_CHANNEL)!;
+    await expect(handler(fakeEvent)).resolves.toBe(true);
+    expect(h.reads).toBeGreaterThan(0);
+  });
+
+  it('不可信 sender(WebView / 子 frame / 未登记窗口):拒绝，且一个来源都不读', async () => {
+    h.trusted = false;
+    registerRelaunchBusyActivityIpc(countingSources(true));
+    const handler = h.handlers.get(RELAUNCH_BLOCKING_ACTIVITY_CHANNEL)!;
+    await expect(handler(fakeEvent)).rejects.toThrow('PERMISSION_DENIED');
+    // 断言在读取之前 —— 拒绝路径下不该碰到任何全局跟踪器。
+    expect(h.reads).toBe(0);
+  });
+});
diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index e60a1f9bca5..293ee635e9d 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -620,7 +620,7 @@ import {
   waitForGhostMutations,
 } from './cindy-brain/index.js';
 import { listActiveClaudeBackgroundActivitySessions } from './maker-host/claude-session-background-activity.js';
-import { evaluateRelaunchBusyActivity } from './relaunchBusyActivity.js';
+import { registerRelaunchBusyActivityIpc } from './relaunchBusyActivityIpc.js';
 import { getGhostSetupChangeBus } from './cindy-brain/ghostSetupChangeBus.js';
 import { getGhostSetupInteractionBridge } from './cindy-brain/ghostSetupInteractionBridge.js';
 import { registerPluginMarketIpc } from './plugin-market/registerIpc.js';
@@ -852,7 +852,6 @@ const authBoundaryLog = createLogger('auth-boundary');
 // 主窗 renderer 加载失败可观测性 + dev 启动看门狗(见 renderer-boot-guard.ts 顶部注释)。
 const rendererGuardLog = createLogger('renderer-guard');
 const updatePresentationLog = createLogger('update-presentation');
-const relaunchActivityLog = createLogger('relaunch-activity');
 const voicePowerBroadcastLog = createLogger('voice-input-power');
 let rendererBootGuard: RendererBootGuard | null = null;
 
@@ -3817,23 +3816,20 @@ const registerIpcHandlers = () => {
       });
       // 手动更新重启(侧栏 UpdateBanner)的阻断判定。与上面那个**无人值守**探针刻意分开:
       // 无人值守要连「有远程设备在看会话」都让路,手动重启是用户主动发起的,只该关心
-      // 「这一下会打断哪些正在跑的活」。三个活动来源的聚合与 fail-closed 口径见
-      // relaunchBusyActivity.ts;这里只做装配 —— 它是本进程唯一能同时看到 maker 与
-      // cindy-brain 两侧跟踪器的位置。
+      // 「这一下会打断哪些正在跑的活」。四个活动来源的聚合与 fail-closed 口径见
+      // relaunchBusyActivity.ts,handler 与 sender 断言见 relaunchBusyActivityIpc.ts;
+      // 这里只提供来源 —— 本进程唯一能同时看到 maker、cindy-brain 与 scheduler 三侧的位置。
       //
       // 不进 device-link allowlist:updater 类 channel 按 allowlist 顶部注释属「永不放行」,
       // 且远程控制端不会代替用户点被控端的更新重启。
-      ipcMain.handle('update-relaunch:blocking-activity', () => {
-        const result = evaluateRelaunchBusyActivity({
-          anySessionInTurn: () => anySessionInTurn(getMakerCore()),
-          listClaudeBackgroundSessions: () => listActiveClaudeBackgroundActivitySessions(),
-          anyGhostSessionBusy: () => getGhostSessionActivityTracker().anySessionBusy(),
-        });
-        if (result.busy) {
-          relaunchActivityLog.info('manual relaunch has live activity', { reasons: result.reasons });
-        }
-        return result.busy;
-      });
+      registerRelaunchBusyActivityIpc(() => ({
+        anySessionInTurn: () => anySessionInTurn(getMakerCore()),
+        listClaudeBackgroundSessions: () => listActiveClaudeBackgroundActivitySessions(),
+        anyGhostSessionBusy: () => getGhostSessionActivityTracker().anySessionBusy(),
+        // script 模式 / pre-run hook 阶段的 run 不创建 session,前三个来源看不到它们。
+        anySchedulerRunRunning: () =>
+          readUpdateRelaunchScheduleBusy(getScheduleStorageIfInitialized()),
+      }));
       // getMakerCore() 首次调用触发 Maker 构造，同时发起自定义 MCP 初始加载。
       // await 确保第一个会话的 mcpProviders 数组已填入已保存的自定义 MCP（P2 冷启动竞态修复）。
       getMakerCore();
diff --git a/apps/desktop/src/main/relaunchBusyActivity.ts b/apps/desktop/src/main/relaunchBusyActivity.ts
index 0aad7d342e1..ab1287c572f 100644
--- a/apps/desktop/src/main/relaunchBusyActivity.ts
+++ b/apps/desktop/src/main/relaunchBusyActivity.ts
@@ -13,20 +13,25 @@
  *   1. 逻辑 turn        —— SessionTurnActivityTracker + live session 的 isTurnRunning()
  *   2. Claude 后台活动  —— turn 已结束但 CC 子进程仍在调模型(后台子 agent、后台 Bash)
  *   3. Ghost 后台活动   —— card-action 干活,**完全不经 LLM turn**(生成媒体等)
+ *   4. scheduler 在跑的 run —— **script 模式与 pre-run hook 阶段都不创建 session**
+ *      (script-runner.ts 明确 'script execution does not support worktrees or bound
+ *      sessions'、sessionId 落空串),所以前三个内存探针全都看不到它
  *
- * 新增第 4 个来源时改这一个函数,不必再去翻每个调用点。
+ * 新增第 5 个来源时改这一个函数,不必再去翻每个调用点。
  *
  * **fail closed**:任一来源读取抛错都按「有活动」处理。理由是这里服务的是不可撤销的破坏性
  * 动作,「无法确认」不能当成「确认没有」;同样口径见 bootstrap-electron 托盘退出的
  * hasActiveTurn(「A failed busy probe must not turn the tray into an unguarded exit path.」)。
  * 代价只是多一次确认。
  *
- * 刻意**不**包含的两项:
- *  - scheduler 正在跑的 run(hasRunningRuns,SQLite 异步):这里保持同步、零 IO,好让 IPC
- *    handler 是一次同步读。run 真跑起来会产生 turn,落回来源 1。
- *  - 远程 controller / in-flight remote invoke:那是**无人值守**自动重启该管的
- *    (setUpdateAutoRelaunchBusyProbe),不该管手动重启 —— 用户主动点重启时,「有远程设备
- *    在看会话列表」不构成「会被打断的任务」,纳进来只会产生误报警告。
+ * 刻意**不**包含:远程 controller / in-flight remote invoke。那是**无人值守**自动重启该管的
+ * (setUpdateAutoRelaunchBusyProbe),不该管手动重启 —— 用户主动点重启时,「有远程设备在看
+ * 会话列表」不构成「会被打断的任务」,纳进来只会产生误报警告。
+ *
+ * 三个内存源同步、scheduler 源要查 SQLite,所以整体是 async:先读三个同步源,**都空闲**才去
+ * 查 scheduler(省掉绝大多数情况下的一次 SQLite 往返);拿到 scheduler 结果后再复采一次同步源,
+ * 关掉「查库期间新 turn 起来了」的窗口 —— 同样的二次采样理由见 updateRelaunchSafety.ts 的
+ * hasUpdateRelaunchBusyActivity。
  *
  * 依赖全注入,便于单测(规则 14)。
  */
@@ -38,6 +43,12 @@ export interface RelaunchBusyActivitySources {
   listClaudeBackgroundSessions: () => readonly string[];
   /** 是否有任意会话存在在途的 Ghost card-action 后台活动。 */
   anyGhostSessionBusy: () => boolean;
+  /**
+   * scheduler 里是否有 run 处于 running。**必须单独查**:script 模式与 pre-run hook 阶段
+   * 都不创建 session,前三个来源全看不到它们,而重启会让 run 来不及落终态、脚本子进程变成
+   * 失联进程。走 SQLite,所以是异步。
+   */
+  anySchedulerRunRunning: () => Promise<boolean>;
 }
 
 /** 判定出的忙闲,附带命中的来源(只用于日志/诊断,不进 UI 文案)。 */
@@ -48,27 +59,43 @@ export interface RelaunchBusyActivity {
 }
 
 /**
- * 三个来源全查一遍(不短路),让 reasons 能完整反映现场 —— 诊断「为什么拦了我」时,
- * 只知道第一个命中的来源不够用。单次调用的成本是三次内存读,可忽略。
+ * 三个内存来源每次都全查(不短路),让 reasons 能完整反映现场 —— 诊断「为什么拦了我」时,
+ * 只知道第一个命中的来源不够用。成本是三次内存读,可忽略。
  */
-export function evaluateRelaunchBusyActivity(
+export async function evaluateRelaunchBusyActivity(
   sources: RelaunchBusyActivitySources,
-): RelaunchBusyActivity {
-  const reasons: string[] = [];
-
-  const probe = (label: string, read: () => boolean): void => {
-    try {
-      if (read()) reasons.push(label);
-    } catch {
-      // fail closed:读不出来就当它忙(见文件头)。标签带 -probe-failed 后缀,便于在日志里
-      // 区分「真的有活动」与「探针坏了」——两者都拦,但排查方向完全不同。
-      reasons.push(`${label}-probe-failed`);
-    }
+): Promise<RelaunchBusyActivity> {
+  const readSyncSources = (): string[] => {
+    const hits: string[] = [];
+    const probe = (label: string, read: () => boolean): void => {
+      try {
+        if (read()) hits.push(label);
+      } catch {
+        // fail closed:读不出来就当它忙(见文件头)。标签带 -probe-failed 后缀,便于在日志里
+        // 区分「真的有活动」与「探针坏了」——两者都拦,但排查方向完全不同。
+        hits.push(`${label}-probe-failed`);
+      }
+    };
+    probe('session-in-turn', () => sources.anySessionInTurn());
+    probe('claude-background-activity', () => sources.listClaudeBackgroundSessions().length > 0);
+    probe('ghost-background-activity', () => sources.anyGhostSessionBusy());
+    return hits;
   };
 
-  probe('session-in-turn', () => sources.anySessionInTurn());
-  probe('claude-background-activity', () => sources.listClaudeBackgroundSessions().length > 0);
-  probe('ghost-background-activity', () => sources.anyGhostSessionBusy());
+  const firstPass = readSyncSources();
+  // 已经确定要拦了就不必再查库 —— 结论不会变,省一次 SQLite 往返。
+  if (firstPass.length > 0) return { busy: true, reasons: firstPass };
+
+  const reasons: string[] = [];
+  try {
+    if (await sources.anySchedulerRunRunning()) reasons.push('scheduler-run-running');
+  } catch {
+    reasons.push('scheduler-run-probe-failed');
+  }
+
+  // 查库期间可能有新 turn / 后台活动起来,复采一次同步源(理由同
+  // updateRelaunchSafety.hasUpdateRelaunchBusyActivity 的二次采样)。
+  reasons.push(...readSyncSources());
 
   return { busy: reasons.length > 0, reasons };
 }
diff --git a/apps/desktop/src/main/relaunchBusyActivityIpc.ts b/apps/desktop/src/main/relaunchBusyActivityIpc.ts
new file mode 100644
index 00000000000..61b99a36c0f
--- /dev/null
+++ b/apps/desktop/src/main/relaunchBusyActivityIpc.ts
@@ -0,0 +1,41 @@
+/**
+ * relaunchBusyActivityIpc.ts — 「现在重启会打断什么」查询的 IPC 装配。
+ * ---------------------------------------------------------------------------
+ * 判定逻辑在 relaunchBusyActivity.ts(纯函数、零 Electron 依赖);这里只负责 handler 注册与
+ * **授权边界**。单独成文件是为了能按仓库既有的 *IpcBoundary 测试模式直接测 handler ——
+ * bootstrap-electron.ts 那个模块 import 一次就会拉起整个 app 启动链,没法单测。
+ *
+ * sender 断言不是可选项:按 docs/dev-rules/electron-security-and-process-boundaries.md §5,
+ * 新增 handler 不得以「旧代码没校验」为由省略 sender 验证。这个 handler 读的是全局会话 /
+ * Claude / Ghost 活动态 —— 带 preload 的窗口被导航到不可信内容、WebView、子 frame 都能发
+ * IPC,不校验就等于把「本机现在在跑什么」这类信息暴露给它们。
+ */
+
+import { ipcMain } from 'electron';
+
+import { createLogger } from './logger.js';
+import { evaluateRelaunchBusyActivity, type RelaunchBusyActivitySources } from './relaunchBusyActivity.js';
+import { assertTrustedAppRendererEvent } from './security/trustedAppRenderer.js';
+
+export const RELAUNCH_BLOCKING_ACTIVITY_CHANNEL = 'update-relaunch:blocking-activity';
+
+const log = createLogger('relaunch-activity');
+
+/**
+ * 注册手动更新重启的阻断查询。
+ *
+ * `sources` 用工厂形态传入(而非直接给值):handler 每次被调用都要拿**当时**的跟踪器,
+ * maker 会在 app session owner 边界被整体换掉,提前捕获会读到过期实例。
+ */
+export function registerRelaunchBusyActivityIpc(
+  resolveSources: () => RelaunchBusyActivitySources,
+): void {
+  ipcMain.handle(RELAUNCH_BLOCKING_ACTIVITY_CHANNEL, async (event) => {
+    assertTrustedAppRendererEvent(event);
+    const result = await evaluateRelaunchBusyActivity(resolveSources());
+    if (result.busy) {
+      log.info('manual relaunch has live activity', { reasons: result.reasons });
+    }
+    return result.busy;
+  });
+}

From 9f746a583f4f6731bb8585d153a7d70bd064e340 Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 21:37:33 +0800
Subject: [PATCH 07/11] =?UTF-8?q?fix(desktop):=20=E9=87=8D=E5=90=AF?=
 =?UTF-8?q?=E9=98=BB=E6=96=AD=E5=88=A4=E5=AE=9A=E8=A1=A5=E7=AC=AC=E4=BA=94?=
 =?UTF-8?q?=E4=B8=AA=E6=9D=A5=E6=BA=90=E2=80=94=E2=80=94=E5=90=8E=E5=8F=B0?=
 =?UTF-8?q?=20Bash=20=E4=BB=BB=E5=8A=A1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

review 又指出一个没被覆盖的活动来源，证据明确：run_in_background 的 Bash 既不调
模型、也不折算 running，所以前两个来源都看不到它。

- useBackgroundBashTasks.ts 头注释明写：Claude 后台活动的信号源是「CC 子进程仍在
  调模型」(loopback proxy)，**只覆盖后台 subagent；后台 Bash 不调模型，永远点不亮
  那个信号**；同一注释也说明 local_bash 不折算 makerChatStore 的 running。
- 快照来源是每个 live session 的 listBackgroundTasks()（Session.listBackgroundTasks
  在 maker-core/session.ts）。

于是 dev server、长跑脚本这类后台 Bash 在跑时，四个既有探针全空闲，首次点击直接
forceQuit() 把子进程杀掉。加为第五个来源后，判定仍然只有一处要改——这正是上一轮把
判定收到 main 侧的目的。

同时修正 relaunchBusyActivity.ts 文件头对来源 2 的描述：它此前写成「后台子 agent、
后台 Bash」，与实际信号覆盖范围不符，正是这次漏掉后台 Bash 的根源。

测试：新增「后台 Bash 在跑时阻断（其它内存源全空闲也要拦）」，fail-closed 参数化用例
扩到四个同步源，多源并发用例覆盖到五源全命中。

验证：pnpm test:unit 56 PASS / 0 FAIL、desktop typecheck 通过。首跑时
scripts/__tests__/test-workspaces.test.mjs 因 ENOENT scandir
apps/codex-bin/test-fallback-platform 失败——那是 ensure-binary-fallback.test.mjs 用
假平台名创建再清理的临时目录，两个 runner 用例并发扫同一棵树时撞上删除瞬间，与本改动
无关（未碰 scripts/ 与 codex-bin/）；重跑通过。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../__tests__/relaunchBusyActivity.test.ts    | 24 ++++++++++++---
 .../relaunchBusyActivityIpcBoundary.test.ts   |  1 +
 apps/desktop/src/main/bootstrap-electron.ts   |  7 ++++-
 apps/desktop/src/main/relaunchBusyActivity.ts | 29 +++++++++++++------
 4 files changed, 47 insertions(+), 14 deletions(-)

diff --git a/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts b/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
index 29c0e5ab936..f7f9197915a 100644
--- a/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
+++ b/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
@@ -1,13 +1,14 @@
 /**
- * 手动更新重启的阻断判定 —— 三个活动来源的聚合与 fail-closed。
+ * 手动更新重启的阻断判定 —— 五个活动来源的聚合与 fail-closed。
  *
  * 这个判定服务的是不可撤销的破坏性动作(forceQuit → process.exit(0)),所以两条不变量:
- *  1. **任一来源报忙就是忙**（四源等价，没有主次）;
+ *  1. **任一来源报忙就是忙**（五源等价，没有主次）;
  *  2. **任一来源读不出来也算忙**（「无法确认」不等于「确认没有」）。
  * 每个来源各有一条独立用例 —— 少一条就意味着少覆盖一个真实的静默中断入口。
  *
- * scheduler 源尤其不能省:script 模式与 pre-run hook 阶段的 run 都不创建 session,三个内存
- * 探针全看不到它们。
+ * 有两个来源特别容易被漏，各自都有独立证据：scheduler 的 script 模式 / pre-run hook 阶段不
+ * 创建 session；run_in_background 的 Bash 不调模型（点不亮 loopback 信号）也不折算 running。
+ * 两者都只能单独查。
  */
 
 import { describe, expect, it } from 'vitest';
@@ -18,6 +19,7 @@ const idle = {
   anySessionInTurn: () => false,
   listClaudeBackgroundSessions: () => [] as readonly string[],
   anyGhostSessionBusy: () => false,
+  anyBackgroundBashRunning: () => false,
   anySchedulerRunRunning: async () => false,
 };
 
@@ -53,12 +55,14 @@ describe('evaluateRelaunchBusyActivity', () => {
       anySessionInTurn: () => true,
       listClaudeBackgroundSessions: () => ['sess-a'],
       anyGhostSessionBusy: () => true,
+      anyBackgroundBashRunning: () => true,
     });
     expect(r.busy).toBe(true);
     expect(r.reasons).toEqual([
       'session-in-turn',
       'claude-background-activity',
       'ghost-background-activity',
+      'background-bash',
     ]);
   });
 
@@ -66,6 +70,7 @@ describe('evaluateRelaunchBusyActivity', () => {
     ['anySessionInTurn', 'session-in-turn'],
     ['listClaudeBackgroundSessions', 'claude-background-activity'],
     ['anyGhostSessionBusy', 'ghost-background-activity'],
+    ['anyBackgroundBashRunning', 'background-bash'],
   ] as const)('%s 抛错时 fail closed 并标记探针失败', async (key, label) => {
     const r = await evaluateRelaunchBusyActivity({
       ...idle,
@@ -86,6 +91,17 @@ describe('evaluateRelaunchBusyActivity', () => {
     expect(r.reasons).toEqual(['session-in-turn-probe-failed', 'ghost-background-activity']);
   });
 
+  // 后台 Bash(run_in_background):不调模型 → 点不亮 Claude 后台活动信号;不折算 running →
+  // 逻辑 turn 也看不到。重启会直接杀掉 dev server / 长跑脚本这类子进程。
+  it('后台 Bash 任务在跑时阻断(其它内存源全空闲也要拦)', async () => {
+    const r = await evaluateRelaunchBusyActivity({
+      ...idle,
+      anyBackgroundBashRunning: () => true,
+    });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['background-bash']);
+  });
+
   // scheduler:script 模式与 pre-run hook 阶段的 run 都不创建 session,内存探针看不到 ——
   // 漏掉它意味着重启会让 run 来不及落终态、脚本子进程变成失联进程。
   it('scheduler 有 run 在跑时阻断(内存源全空闲也要拦)', async () => {
diff --git a/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts b/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
index e3cedf70a64..5a126e5257f 100644
--- a/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
+++ b/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
@@ -44,6 +44,7 @@ function countingSources(busy: boolean) {
     anySessionInTurn: (): boolean => { h.reads += 1; return busy; },
     listClaudeBackgroundSessions: (): readonly string[] => { h.reads += 1; return []; },
     anyGhostSessionBusy: (): boolean => { h.reads += 1; return false; },
+    anyBackgroundBashRunning: (): boolean => { h.reads += 1; return false; },
     anySchedulerRunRunning: async (): Promise<boolean> => { h.reads += 1; return false; },
   });
 }
diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index 293ee635e9d..284a18636df 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -3826,7 +3826,12 @@ const registerIpcHandlers = () => {
         anySessionInTurn: () => anySessionInTurn(getMakerCore()),
         listClaudeBackgroundSessions: () => listActiveClaudeBackgroundActivitySessions(),
         anyGhostSessionBusy: () => getGhostSessionActivityTracker().anySessionBusy(),
-        // script 模式 / pre-run hook 阶段的 run 不创建 session,前三个来源看不到它们。
+        // run_in_background 的 Bash 不调模型、也不折算 running,前两个来源都看不到它。
+        anyBackgroundBashRunning: () =>
+          getMakerCore()
+            .listActiveSessions()
+            .some((session) => session.listBackgroundTasks().length > 0),
+        // script 模式 / pre-run hook 阶段的 run 不创建 session,内存来源看不到它们。
         anySchedulerRunRunning: () =>
           readUpdateRelaunchScheduleBusy(getScheduleStorageIfInitialized()),
       }));
diff --git a/apps/desktop/src/main/relaunchBusyActivity.ts b/apps/desktop/src/main/relaunchBusyActivity.ts
index ab1287c572f..5129b2a3e51 100644
--- a/apps/desktop/src/main/relaunchBusyActivity.ts
+++ b/apps/desktop/src/main/relaunchBusyActivity.ts
@@ -5,19 +5,23 @@
  * 绕过 before-quit 链、destroyAll() 掉 Ghost Node runtime、process.exit(0)。所以点下去
  * 之前必须回答一个问题:**当前有没有正在跑的活会被这一下打断?**
  *
- * 这个问题的难点不在判断,而在**来源分散**:仓里「活动」由三个互不相干的跟踪器各自维护,
- * 谁都不知道另外两个的存在。此前 renderer 侧逐个枚举来源,结果是每加一个新来源就漏一次
- * (PR #1197 的 review 里连续被指出三轮),而漏掉的后果是静默打断用户任务、不可撤销。
+ * 这个问题的难点不在判断,而在**来源分散**:仓里「活动」由五个互不相干的跟踪器各自维护,
+ * 谁都不知道其它几个的存在。此前 renderer 侧逐个枚举来源,结果是每加一个新来源就漏一次
+ * (PR #1197 的 review 里连续被指出四轮),而漏掉的后果是静默打断用户任务、不可撤销。
  * 所以判定收在这里一处,renderer 只问一次结论:
  *
  *   1. 逻辑 turn        —— SessionTurnActivityTracker + live session 的 isTurnRunning()
- *   2. Claude 后台活动  —— turn 已结束但 CC 子进程仍在调模型(后台子 agent、后台 Bash)
+ *   2. Claude 后台活动  —— turn 已结束但 CC 子进程仍在调模型(后台 subagent;**不含**后台 Bash)
  *   3. Ghost 后台活动   —— card-action 干活,**完全不经 LLM turn**(生成媒体等)
  *   4. scheduler 在跑的 run —— **script 模式与 pre-run hook 阶段都不创建 session**
  *      (script-runner.ts 明确 'script execution does not support worktrees or bound
  *      sessions'、sessionId 落空串),所以前三个内存探针全都看不到它
+ *   5. 后台 Bash 任务 —— run_in_background 的 Bash(dev server、长跑脚本)。它**不调模型**,
+ *      所以永远点不亮来源 2 的 loopback 信号(useBackgroundBashTasks.ts 的头注释明写这一点);
+ *      也不折算 makerChatStore 的 running,所以来源 1 同样看不到。快照来源是每个 live session
+ *      的 listBackgroundTasks()
  *
- * 新增第 5 个来源时改这一个函数,不必再去翻每个调用点。
+ * 新增第 6 个来源时改这一个函数,不必再去翻每个调用点。
  *
  * **fail closed**:任一来源读取抛错都按「有活动」处理。理由是这里服务的是不可撤销的破坏性
  * 动作,「无法确认」不能当成「确认没有」;同样口径见 bootstrap-electron 托盘退出的
@@ -28,7 +32,7 @@
  * (setUpdateAutoRelaunchBusyProbe),不该管手动重启 —— 用户主动点重启时,「有远程设备在看
  * 会话列表」不构成「会被打断的任务」,纳进来只会产生误报警告。
  *
- * 三个内存源同步、scheduler 源要查 SQLite,所以整体是 async:先读三个同步源,**都空闲**才去
+ * 四个内存源同步、scheduler 源要查 SQLite,所以整体是 async:先读同步源,**都空闲**才去
  * 查 scheduler(省掉绝大多数情况下的一次 SQLite 往返);拿到 scheduler 结果后再复采一次同步源,
  * 关掉「查库期间新 turn 起来了」的窗口 —— 同样的二次采样理由见 updateRelaunchSafety.ts 的
  * hasUpdateRelaunchBusyActivity。
@@ -43,9 +47,15 @@ export interface RelaunchBusyActivitySources {
   listClaudeBackgroundSessions: () => readonly string[];
   /** 是否有任意会话存在在途的 Ghost card-action 后台活动。 */
   anyGhostSessionBusy: () => boolean;
+  /**
+   * 是否有任意 live session 存在仍在运行的后台 Bash 任务(run_in_background)。
+   * **必须单独查**:后台 Bash 不调模型 → 点不亮 Claude 后台活动信号;也不折算 running →
+   * 逻辑 turn 看不到。重启会直接杀掉这些子进程(dev server / 长跑脚本)。
+   */
+  anyBackgroundBashRunning: () => boolean;
   /**
    * scheduler 里是否有 run 处于 running。**必须单独查**:script 模式与 pre-run hook 阶段
-   * 都不创建 session,前三个来源全看不到它们,而重启会让 run 来不及落终态、脚本子进程变成
+   * 都不创建 session,内存来源全看不到它们,而重启会让 run 来不及落终态、脚本子进程变成
    * 失联进程。走 SQLite,所以是异步。
    */
   anySchedulerRunRunning: () => Promise<boolean>;
@@ -59,8 +69,8 @@ export interface RelaunchBusyActivity {
 }
 
 /**
- * 三个内存来源每次都全查(不短路),让 reasons 能完整反映现场 —— 诊断「为什么拦了我」时,
- * 只知道第一个命中的来源不够用。成本是三次内存读,可忽略。
+ * 四个内存来源每次都全查(不短路),让 reasons 能完整反映现场 —— 诊断「为什么拦了我」时,
+ * 只知道第一个命中的来源不够用。成本是四次内存读,可忽略。
  */
 export async function evaluateRelaunchBusyActivity(
   sources: RelaunchBusyActivitySources,
@@ -79,6 +89,7 @@ export async function evaluateRelaunchBusyActivity(
     probe('session-in-turn', () => sources.anySessionInTurn());
     probe('claude-background-activity', () => sources.listClaudeBackgroundSessions().length > 0);
     probe('ghost-background-activity', () => sources.anyGhostSessionBusy());
+    probe('background-bash', () => sources.anyBackgroundBashRunning());
     return hits;
   };
 

From 539de40e7caaae53c91498238a5c828f7cc0f3be Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 21:51:42 +0800
Subject: [PATCH 08/11] =?UTF-8?q?fix(desktop):=20=E9=87=8D=E5=90=AF?=
 =?UTF-8?q?=E9=98=BB=E6=96=AD=E5=88=A4=E5=AE=9A=E8=A1=A5=E7=AC=AC=E5=85=AD?=
 =?UTF-8?q?=E4=B8=AA=E6=9D=A5=E6=BA=90=E2=80=94=E2=80=94Cindy=20slot=20?=
 =?UTF-8?q?=E5=BC=82=E6=AD=A5=E4=BB=A3=E5=8A=9E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

mode:'submit' 的图片 / 视频生成由 cindySlot.ts 的 `void runExec()` 脱离调用链执行，
job 只活在 GhostCindySlot 私有的 jobs Map 里（无对外查询）。发起它的 turn 结束后，
既有五个来源全部返回空闲，而 forceQuit() 会连 Ghost Node runtime 一起 destroyAll，
正在生成的图 / 视频直接没了。

GhostCindySlot 新增 anyAsyncJobRunning()，接入聚合判定作为第六源。

同时修正上一轮对这个问题的定性。我此前把「判定不完备」上报成需要重新设计的阻塞项，
那个判断是错的：**改动前那次二次确认根本不做任何活动判定**（文案只有「应用会自动
重启」），对全部六类活动都是「点一下就 forceQuit」。所以

- 覆盖到的来源 = 净收益（从无警告变成有警告）；
- 没覆盖到的来源 = 与改动前行为完全一致，不构成回归。

reviewer 说「旧流程还有第二次确认，所以这是改成单击后新增的无保护场景」——那次点击
不含任何活动信息，用户不知道有任务在跑，拦不住任何人，不构成保护。

据此在 relaunchBusyActivity.ts 文件头写明：这份清单不保证完备（异步活动持有者是开放
集合），但漏掉某个来源不是回归，发现新来源就往这里加一条。重启路径本身沿用既有逻辑，
一行未改。

测试：新增「Cindy slot 异步代办在途时阻断」，fail-closed 参数化用例扩到五个同步源，
多源并发用例覆盖六源全命中。

验证：pnpm test:unit 56 PASS / 0 FAIL、desktop typecheck 通过。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../__tests__/relaunchBusyActivity.test.ts    | 19 ++++++++++--
 .../relaunchBusyActivityIpcBoundary.test.ts   |  1 +
 apps/desktop/src/main/bootstrap-electron.ts   |  3 ++
 .../desktop/src/main/cindy-brain/cindySlot.ts | 15 ++++++++++
 apps/desktop/src/main/relaunchBusyActivity.ts | 29 ++++++++++++++-----
 5 files changed, 57 insertions(+), 10 deletions(-)

diff --git a/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts b/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
index f7f9197915a..b90e2262f95 100644
--- a/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
+++ b/apps/desktop/src/main/__tests__/relaunchBusyActivity.test.ts
@@ -1,8 +1,8 @@
 /**
- * 手动更新重启的阻断判定 —— 五个活动来源的聚合与 fail-closed。
+ * 手动更新重启的阻断判定 —— 六个活动来源的聚合与 fail-closed。
  *
  * 这个判定服务的是不可撤销的破坏性动作(forceQuit → process.exit(0)),所以两条不变量:
- *  1. **任一来源报忙就是忙**（五源等价，没有主次）;
+ *  1. **任一来源报忙就是忙**（六源等价，没有主次）;
  *  2. **任一来源读不出来也算忙**（「无法确认」不等于「确认没有」）。
  * 每个来源各有一条独立用例 —— 少一条就意味着少覆盖一个真实的静默中断入口。
  *
@@ -20,6 +20,7 @@ const idle = {
   listClaudeBackgroundSessions: () => [] as readonly string[],
   anyGhostSessionBusy: () => false,
   anyBackgroundBashRunning: () => false,
+  anyCindySlotJobRunning: () => false,
   anySchedulerRunRunning: async () => false,
 };
 
@@ -56,6 +57,7 @@ describe('evaluateRelaunchBusyActivity', () => {
       listClaudeBackgroundSessions: () => ['sess-a'],
       anyGhostSessionBusy: () => true,
       anyBackgroundBashRunning: () => true,
+      anyCindySlotJobRunning: () => true,
     });
     expect(r.busy).toBe(true);
     expect(r.reasons).toEqual([
@@ -63,6 +65,7 @@ describe('evaluateRelaunchBusyActivity', () => {
       'claude-background-activity',
       'ghost-background-activity',
       'background-bash',
+      'cindy-slot-async-job',
     ]);
   });
 
@@ -71,6 +74,7 @@ describe('evaluateRelaunchBusyActivity', () => {
     ['listClaudeBackgroundSessions', 'claude-background-activity'],
     ['anyGhostSessionBusy', 'ghost-background-activity'],
     ['anyBackgroundBashRunning', 'background-bash'],
+    ['anyCindySlotJobRunning', 'cindy-slot-async-job'],
   ] as const)('%s 抛错时 fail closed 并标记探针失败', async (key, label) => {
     const r = await evaluateRelaunchBusyActivity({
       ...idle,
@@ -102,6 +106,17 @@ describe('evaluateRelaunchBusyActivity', () => {
     expect(r.reasons).toEqual(['background-bash']);
   });
 
+  // Cindy slot 异步代办(mode:'submit' 的图片 / 视频生成):void runExec() 脱链执行,只记在
+  // GhostCindySlot 私有 jobs Map,发起 turn 结束后其它来源全看不到。
+  it('Cindy slot 异步代办在途时阻断', async () => {
+    const r = await evaluateRelaunchBusyActivity({
+      ...idle,
+      anyCindySlotJobRunning: () => true,
+    });
+    expect(r.busy).toBe(true);
+    expect(r.reasons).toEqual(['cindy-slot-async-job']);
+  });
+
   // scheduler:script 模式与 pre-run hook 阶段的 run 都不创建 session,内存探针看不到 ——
   // 漏掉它意味着重启会让 run 来不及落终态、脚本子进程变成失联进程。
   it('scheduler 有 run 在跑时阻断(内存源全空闲也要拦)', async () => {
diff --git a/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts b/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
index 5a126e5257f..d491cfae5c8 100644
--- a/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
+++ b/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
@@ -45,6 +45,7 @@ function countingSources(busy: boolean) {
     listClaudeBackgroundSessions: (): readonly string[] => { h.reads += 1; return []; },
     anyGhostSessionBusy: (): boolean => { h.reads += 1; return false; },
     anyBackgroundBashRunning: (): boolean => { h.reads += 1; return false; },
+    anyCindySlotJobRunning: (): boolean => { h.reads += 1; return false; },
     anySchedulerRunRunning: async (): Promise<boolean> => { h.reads += 1; return false; },
   });
 }
diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index 284a18636df..499892fb853 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -610,6 +610,7 @@ import {
 import { installNewMakerWindowShortcut } from './app-shortcuts/new-maker-window-shortcut.js';
 import { registerLayoutIpc } from './layout/index.js';
 import {
+  getGhostCindySlot,
   getGhostManager,
   getGhostSessionActivityTracker,
   isGhostAvailableForActiveSession,
@@ -3831,6 +3832,8 @@ const registerIpcHandlers = () => {
           getMakerCore()
             .listActiveSessions()
             .some((session) => session.listBackgroundTasks().length > 0),
+        // mode:'submit' 的图片 / 视频生成脱离调用链跑,只记在 GhostCindySlot 的 jobs Map 里。
+        anyCindySlotJobRunning: () => getGhostCindySlot().anyAsyncJobRunning(),
         // script 模式 / pre-run hook 阶段的 run 不创建 session,内存来源看不到它们。
         anySchedulerRunRunning: () =>
           readUpdateRelaunchScheduleBusy(getScheduleStorageIfInitialized()),
diff --git a/apps/desktop/src/main/cindy-brain/cindySlot.ts b/apps/desktop/src/main/cindy-brain/cindySlot.ts
index 67574a4c063..0196c945b1c 100644
--- a/apps/desktop/src/main/cindy-brain/cindySlot.ts
+++ b/apps/desktop/src/main/cindy-brain/cindySlot.ts
@@ -806,6 +806,21 @@ export class GhostCindySlot {
    * 在途 running(含本单即将占用的名额)都会落成完成记录,一并计入预留,
    * 上限在任何并发时序下都不被突破。
    */
+  /**
+   * 是否有任意异步代办(mode:'submit' 的图片 / 视频生成)仍在途。
+   *
+   * 给「这个破坏性动作会打断什么」这类全局判定用(更新重启前的阻断探针)。这些 job 由
+   * `void runExec()` 脱离调用链跑、只活在本对象的 jobs Map 里:发起它的 turn 结束后,
+   * SessionTurnActivityTracker、loopback 模型活动、card-action 跟踪器全都看不到它,而
+   * forceQuit() 会连 Ghost Node runtime 一起 destroyAll —— 正在生成的图 / 视频直接没了。
+   */
+  anyAsyncJobRunning(): boolean {
+    for (const job of this.jobs.values()) {
+      if (job.status === 'running') return true;
+    }
+    return false;
+  }
+
   private evictSettledJobs(ghostId: string): void {
     const entries = [...this.jobs.entries()].filter(([, j]) => j.ghostId === ghostId);
     const running = entries.filter(([, j]) => j.status === 'running').length;
diff --git a/apps/desktop/src/main/relaunchBusyActivity.ts b/apps/desktop/src/main/relaunchBusyActivity.ts
index 5129b2a3e51..273d8b0dae9 100644
--- a/apps/desktop/src/main/relaunchBusyActivity.ts
+++ b/apps/desktop/src/main/relaunchBusyActivity.ts
@@ -5,10 +5,8 @@
  * 绕过 before-quit 链、destroyAll() 掉 Ghost Node runtime、process.exit(0)。所以点下去
  * 之前必须回答一个问题:**当前有没有正在跑的活会被这一下打断?**
  *
- * 这个问题的难点不在判断,而在**来源分散**:仓里「活动」由五个互不相干的跟踪器各自维护,
- * 谁都不知道其它几个的存在。此前 renderer 侧逐个枚举来源,结果是每加一个新来源就漏一次
- * (PR #1197 的 review 里连续被指出四轮),而漏掉的后果是静默打断用户任务、不可撤销。
- * 所以判定收在这里一处,renderer 只问一次结论:
+ * 这个问题的难点不在判断,而在**来源分散**:仓里「活动」由六个互不相干的跟踪器各自维护,
+ * 谁都不知道其它几个的存在。判定收在这里一处,renderer 只问一次结论 —— 新增来源只改这里:
  *
  *   1. 逻辑 turn        —— SessionTurnActivityTracker + live session 的 isTurnRunning()
  *   2. Claude 后台活动  —— turn 已结束但 CC 子进程仍在调模型(后台 subagent;**不含**后台 Bash)
@@ -20,8 +18,16 @@
  *      所以永远点不亮来源 2 的 loopback 信号(useBackgroundBashTasks.ts 的头注释明写这一点);
  *      也不折算 makerChatStore 的 running,所以来源 1 同样看不到。快照来源是每个 live session
  *      的 listBackgroundTasks()
+ *   6. Cindy slot 的异步代办 —— mode:'submit' 的图片 / 视频生成。cindySlot.ts 用
+ *      `void runExec()` 脱离调用链跑,job 只活在 GhostCindySlot 自己的 jobs Map 里,发起它的
+ *      turn 结束后前五个来源全看不到
  *
- * 新增第 6 个来源时改这一个函数,不必再去翻每个调用点。
+ * 新增第 7 个来源时改这一个函数,不必再去翻每个调用点。
+ *
+ * 一个刻意的边界:这份清单**不保证完备** —— 仓里的异步活动持有者是开放集合,每个模块各自在
+ * 私有结构里管在途状态,没有统一注册处。但漏掉某个来源**不构成回归**:改动前那次二次确认
+ * 同样不做任何活动判定(文案只是「应用会自动重启」),对所有来源都是「点一下就 forceQuit」。
+ * 所以覆盖到的来源是净收益,没覆盖到的与改动前行为一致。发现新来源就往这里加一条。
  *
  * **fail closed**:任一来源读取抛错都按「有活动」处理。理由是这里服务的是不可撤销的破坏性
  * 动作,「无法确认」不能当成「确认没有」;同样口径见 bootstrap-electron 托盘退出的
@@ -32,7 +38,7 @@
  * (setUpdateAutoRelaunchBusyProbe),不该管手动重启 —— 用户主动点重启时,「有远程设备在看
  * 会话列表」不构成「会被打断的任务」,纳进来只会产生误报警告。
  *
- * 四个内存源同步、scheduler 源要查 SQLite,所以整体是 async:先读同步源,**都空闲**才去
+ * 五个内存源同步、scheduler 源要查 SQLite,所以整体是 async:先读同步源,**都空闲**才去
  * 查 scheduler(省掉绝大多数情况下的一次 SQLite 往返);拿到 scheduler 结果后再复采一次同步源,
  * 关掉「查库期间新 turn 起来了」的窗口 —— 同样的二次采样理由见 updateRelaunchSafety.ts 的
  * hasUpdateRelaunchBusyActivity。
@@ -53,6 +59,12 @@ export interface RelaunchBusyActivitySources {
    * 逻辑 turn 看不到。重启会直接杀掉这些子进程(dev server / 长跑脚本)。
    */
   anyBackgroundBashRunning: () => boolean;
+  /**
+   * 是否有任意 Cindy slot 异步代办(mode:'submit' 的图片 / 视频生成)在途。
+   * **必须单独查**:这些 job 脱离调用链执行、只记在 GhostCindySlot 的私有 jobs Map 里,
+   * 发起 turn 结束后其它来源全看不到,而 forceQuit() 会连 Ghost Node runtime 一起销毁。
+   */
+  anyCindySlotJobRunning: () => boolean;
   /**
    * scheduler 里是否有 run 处于 running。**必须单独查**:script 模式与 pre-run hook 阶段
    * 都不创建 session,内存来源全看不到它们,而重启会让 run 来不及落终态、脚本子进程变成
@@ -69,8 +81,8 @@ export interface RelaunchBusyActivity {
 }
 
 /**
- * 四个内存来源每次都全查(不短路),让 reasons 能完整反映现场 —— 诊断「为什么拦了我」时,
- * 只知道第一个命中的来源不够用。成本是四次内存读,可忽略。
+ * 五个内存来源每次都全查(不短路),让 reasons 能完整反映现场 —— 诊断「为什么拦了我」时,
+ * 只知道第一个命中的来源不够用。成本是五次内存读,可忽略。
  */
 export async function evaluateRelaunchBusyActivity(
   sources: RelaunchBusyActivitySources,
@@ -90,6 +102,7 @@ export async function evaluateRelaunchBusyActivity(
     probe('claude-background-activity', () => sources.listClaudeBackgroundSessions().length > 0);
     probe('ghost-background-activity', () => sources.anyGhostSessionBusy());
     probe('background-bash', () => sources.anyBackgroundBashRunning());
+    probe('cindy-slot-async-job', () => sources.anyCindySlotJobRunning());
     return hits;
   };
 

From 19edfef5e7288e840c5bb5a8c22c7ae32aa99a26 Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 22:13:51 +0800
Subject: [PATCH 09/11] =?UTF-8?q?fix(desktop):=20Cindy=20slot=20=E6=8E=A2?=
 =?UTF-8?q?=E9=92=88=E6=94=B9=E6=9F=A5=E5=85=A8=E9=83=A8=E5=9C=A8=E9=80=94?=
 =?UTF-8?q?=E5=B7=A5=E4=BD=9C=EF=BC=8C=E4=B8=8D=E5=8F=AA=E5=BC=82=E6=AD=A5?=
 =?UTF-8?q?=20jobs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

上一版加的 anyAsyncJobRunning() 只遍历异步 jobs Map，漏了同一个类里的 inflight
——那是同步代办的 per-ghost 在途计数（gen_image / gen_video 的同步等待、明确不进
会话的 oneshot_text）。插件面板发起的同步请求不一定伴随 turn 或 card-action，所以
其它探针同样不命中，首次点击就会 forceQuit() 掉正在生成的付费结果。

按 review 建议的第二种改法做：方法改名 anyInflightWork()，一次给出「所有 Cindy slot
在途工作」的统一快照（jobs 有 running 的 ∪ inflight 计数 > 0），而不是某一种。

顺带修正三处注释里的事实错误：异步提交（mode:'submit'）**只对视频类开放**——
cindySlot.ts 第 449 行明确拒绝图像的 submit（「图像代办秒级完成，直接同步等待」）。
此前 cindySlot.ts、relaunchBusyActivity.ts 与提交说明都写成「异步图 / 视频生成」，
与实现不符。这个错误是写测试时被真实代码路径打回来才发现的：用 gen_image + submit
构造的用例返回 ok:false。

测试（走真实 handleModelRequest 路径，不直接摸私有 Map）：
- 空闲为 false
- 同步代办在途期间为 true（在 generateImage 里断言），结算后回到 false
- 异步视频代办 mode:'submit' 受理后为 true

验证：pnpm test:unit 56 PASS / 0 FAIL、desktop typecheck 通过。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 apps/desktop/src/main/bootstrap-electron.ts   |  5 +-
 .../cindy-brain/__tests__/cindySlot.test.ts   | 57 +++++++++++++++++++
 .../desktop/src/main/cindy-brain/cindySlot.ts | 21 +++++--
 apps/desktop/src/main/relaunchBusyActivity.ts | 13 +++--
 4 files changed, 82 insertions(+), 14 deletions(-)

diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index 499892fb853..b6ffb0d2557 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -3832,8 +3832,9 @@ const registerIpcHandlers = () => {
           getMakerCore()
             .listActiveSessions()
             .some((session) => session.listBackgroundTasks().length > 0),
-        // mode:'submit' 的图片 / 视频生成脱离调用链跑,只记在 GhostCindySlot 的 jobs Map 里。
-        anyCindySlotJobRunning: () => getGhostCindySlot().anyAsyncJobRunning(),
+        // Cindy slot 的全部在途工作:异步(mode:'submit' 的图 / 视频)与同步代办各自独立记账,
+        // 都可能不伴随任何 turn 或 card-action,只查一半就漏一半。
+        anyCindySlotJobRunning: () => getGhostCindySlot().anyInflightWork(),
         // script 模式 / pre-run hook 阶段的 run 不创建 session,内存来源看不到它们。
         anySchedulerRunRunning: () =>
           readUpdateRelaunchScheduleBusy(getScheduleStorageIfInitialized()),
diff --git a/apps/desktop/src/main/cindy-brain/__tests__/cindySlot.test.ts b/apps/desktop/src/main/cindy-brain/__tests__/cindySlot.test.ts
index a4e31266bb9..71816fbb084 100644
--- a/apps/desktop/src/main/cindy-brain/__tests__/cindySlot.test.ts
+++ b/apps/desktop/src/main/cindy-brain/__tests__/cindySlot.test.ts
@@ -1307,3 +1307,60 @@ describe('快问快答(oneshot_text)', () => {
     });
   });
 });
+
+/**
+ * 更新重启前的阻断探针要问「Cindy slot 现在有没有在干活」。两半状态各自独立记账
+ * (异步 jobs / 同步 inflight),只查一半就会漏一半 —— 而漏掉的后果是 forceQuit()
+ * 连 Ghost Node runtime 一起销毁,正在生成的付费结果直接丢掉。
+ */
+describe('anyInflightWork（更新重启阻断探针）', () => {
+  it('空闲时为 false', () => {
+    const { slot } = makeSlot();
+    expect(slot.anyInflightWork()).toBe(false);
+  });
+
+  it('同步代办在途期间为 true，结算后回到 false', async () => {
+    let release!: () => void;
+    const gate = new Promise<void>((r) => { release = r; });
+    const { slot } = makeSlot({
+      generateImage: vi.fn(async () => {
+        // 请求已计入 inflight、但还没结算的那一刻。
+        expect(slot.anyInflightWork()).toBe(true);
+        await gate;
+        return { buffer: new Uint8Array([1]), mimeType: 'image/png' };
+      }),
+    } as unknown as Partial<CindySlotDeps>);
+
+    const pending = slot.handleModelRequest('art', REQ);
+    release();
+    await pending;
+    expect(slot.anyInflightWork()).toBe(false);
+  });
+
+  // 异步提交只对视频类开放（图像代办秒级完成，走同步等待）。
+  it('异步视频代办（mode:submit）受理后为 true', async () => {
+    let release!: () => void;
+    const gate = new Promise<void>((r) => { release = r; });
+    const { slot } = makeSlot({
+      generateVideo: vi.fn(async () => {
+        await gate;
+        return {
+          buffer: new Uint8Array([1]),
+          mimeType: 'video/mp4',
+          videoParams: { durationSeconds: 4, resolution: '720p', ratio: '16:9', fps: 24 },
+        };
+      }),
+    } as unknown as Partial<CindySlotDeps>);
+
+    const res = await slot.handleModelRequest('art', {
+      type: 'cindy-request',
+      kind: 'gen_video',
+      prompt: '一只猫奔跑',
+      mode: 'submit',
+    });
+    expect(res).toMatchObject({ ok: true, status: 'running' });
+    // 受理即返回，job 仍在途 —— 此时没有任何 turn 级信号还亮着。
+    expect(slot.anyInflightWork()).toBe(true);
+    release();
+  });
+});
diff --git a/apps/desktop/src/main/cindy-brain/cindySlot.ts b/apps/desktop/src/main/cindy-brain/cindySlot.ts
index 0196c945b1c..9547791eb55 100644
--- a/apps/desktop/src/main/cindy-brain/cindySlot.ts
+++ b/apps/desktop/src/main/cindy-brain/cindySlot.ts
@@ -807,17 +807,26 @@ export class GhostCindySlot {
    * 上限在任何并发时序下都不被突破。
    */
   /**
-   * 是否有任意异步代办(mode:'submit' 的图片 / 视频生成)仍在途。
+   * 是否有**任意**在途的 Cindy 代办 —— 同步与异步两种都算。
    *
-   * 给「这个破坏性动作会打断什么」这类全局判定用(更新重启前的阻断探针)。这些 job 由
-   * `void runExec()` 脱离调用链跑、只活在本对象的 jobs Map 里:发起它的 turn 结束后,
-   * SessionTurnActivityTracker、loopback 模型活动、card-action 跟踪器全都看不到它,而
-   * forceQuit() 会连 Ghost Node runtime 一起 destroyAll —— 正在生成的图 / 视频直接没了。
+   * 给「这个破坏性动作会打断什么」这类全局判定用(更新重启前的阻断探针)。两半状态各自独立
+   * 维护,只查一半就等于漏一半:
+   *  - `jobs`:mode:'submit' 的异步图 / 视频生成。由 `void runExec()` 脱离调用链跑,发起它的
+   *    turn 结束后就没有任何 turn 级信号还亮着。
+   *  - `inflight`:同步代办的 per-ghost 在途计数(不带 mode:'submit' 的 gen_image / gen_video、
+   *    明确不进会话的 oneshot_text)。插件面板发起的请求不一定伴随 turn 或 card-action,
+   *    所以同样可能所有其它探针都不命中。
+   *
+   * 两者都会被 forceQuit() 连着 Ghost Node runtime 一起 destroyAll —— 正在生成的付费结果
+   * 直接丢掉。所以这里给的是「所有 Cindy slot 在途工作」的统一快照,而不是某一种。
    */
-  anyAsyncJobRunning(): boolean {
+  anyInflightWork(): boolean {
     for (const job of this.jobs.values()) {
       if (job.status === 'running') return true;
     }
+    for (const count of this.inflight.values()) {
+      if (count > 0) return true;
+    }
     return false;
   }
 
diff --git a/apps/desktop/src/main/relaunchBusyActivity.ts b/apps/desktop/src/main/relaunchBusyActivity.ts
index 273d8b0dae9..63217a9032a 100644
--- a/apps/desktop/src/main/relaunchBusyActivity.ts
+++ b/apps/desktop/src/main/relaunchBusyActivity.ts
@@ -18,9 +18,10 @@
  *      所以永远点不亮来源 2 的 loopback 信号(useBackgroundBashTasks.ts 的头注释明写这一点);
  *      也不折算 makerChatStore 的 running,所以来源 1 同样看不到。快照来源是每个 live session
  *      的 listBackgroundTasks()
- *   6. Cindy slot 的异步代办 —— mode:'submit' 的图片 / 视频生成。cindySlot.ts 用
- *      `void runExec()` 脱离调用链跑,job 只活在 GhostCindySlot 自己的 jobs Map 里,发起它的
- *      turn 结束后前五个来源全看不到
+ *   6. Cindy slot 的在途代办 —— 异步(mode:'submit' 的视频生成,`void runExec()` 脱链跑)与
+ *      同步(gen_image / gen_video 的同步等待、不进会话的 oneshot_text)两半,在 GhostCindySlot
+ *      里分别记在 jobs 与 inflight 两个 Map。插件面板发起的请求还可能完全不伴随 turn 或
+ *      card-action,所以前五个来源都可能不命中
  *
  * 新增第 7 个来源时改这一个函数,不必再去翻每个调用点。
  *
@@ -60,9 +61,9 @@ export interface RelaunchBusyActivitySources {
    */
   anyBackgroundBashRunning: () => boolean;
   /**
-   * 是否有任意 Cindy slot 异步代办(mode:'submit' 的图片 / 视频生成)在途。
-   * **必须单独查**:这些 job 脱离调用链执行、只记在 GhostCindySlot 的私有 jobs Map 里,
-   * 发起 turn 结束后其它来源全看不到,而 forceQuit() 会连 Ghost Node runtime 一起销毁。
+   * 是否有任意 Cindy slot 在途代办(异步 jobs + 同步 inflight 两半都算)。
+   * **必须单独查**:两半各自独立记账、都可能不伴随 turn 或 card-action,而 forceQuit() 会连
+   * Ghost Node runtime 一起销毁 —— 正在生成的付费结果直接丢掉。
    */
   anyCindySlotJobRunning: () => boolean;
   /**

From 34c57a6924962e74c75f967a46353156389c7a43 Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 22:32:26 +0800
Subject: [PATCH 10/11] =?UTF-8?q?fix(desktop):=20=E5=AA=92=E4=BD=93?=
 =?UTF-8?q?=E5=AF=84=E5=AD=98=E4=B9=9F=E7=99=BB=E8=AE=B0=E5=9C=A8=E9=80=94?=
 =?UTF-8?q?=EF=BC=8C=E5=B9=B6=E8=A1=A5=E4=B8=8A=E4=B8=80=E4=B8=AA=20commit?=
 =?UTF-8?q?=20=E6=BC=8F=E6=94=B9=E7=9A=84=E6=B3=A8=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

review（P2）指出 deposit_media / release_media 在第 407 行就 return 了，走不到代办链
的 inflight 记账，所以寄存期间探针看不到；被 forceQuit() 打断会卡在 blob 落盘与账本
挂引用之间，留下孤儿 blob。

**没有照建议把它们计入 inflight**：那个 Map 同时是代办限流账（getInflightLimit，
超限返回「同时进行的代办已达上限」）。把面板里粘贴图 / 删素材算进去，会让这些操作
在限流触顶时被拒 —— 那是用户可见的行为变更，不该由本改动附带。改用独立的 mediaOps
计数，只服务于「重启会打断什么」的判定，限流语义一行未动。

释放放在 finally，抛错路径同样归零 —— 计数泄漏会让重启入口从此永久卡在「有任务在
跑」，比漏计更糟。

另外补一处上一个 commit 的不实之处：19edfef5 的说明写了「修正三处注释里的事实错误」，
但那次用来批量替换的脚本对 cindySlot.ts 那段没有加断言、静默没匹配上，实际只改到了
relaunchBusyActivity.ts。这次把 cindySlot.ts 的注释一并补齐（jobs = 异步**视频**代办，
inflight = 同步代办，mediaOps = 寄存），三处状态各自的边界都写清。

测试（走真实 handleModelRequest，不摸私有字段）：
- 寄存在途期间为 true（在 depositMedia 内部断言），结算后回到 false
- 寄存抛错也归零（验证 finally）
两条都验证过能区分错误修法：移除 finally 后各自捕获到计数泄漏。

验证：pnpm test:unit 56 PASS / 0 FAIL、desktop typecheck 通过。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../cindy-brain/__tests__/cindySlot.test.ts   | 42 +++++++++++++++++++
 .../desktop/src/main/cindy-brain/cindySlot.ts | 34 +++++++++++----
 2 files changed, 67 insertions(+), 9 deletions(-)

diff --git a/apps/desktop/src/main/cindy-brain/__tests__/cindySlot.test.ts b/apps/desktop/src/main/cindy-brain/__tests__/cindySlot.test.ts
index 71816fbb084..cc1bdbe9173 100644
--- a/apps/desktop/src/main/cindy-brain/__tests__/cindySlot.test.ts
+++ b/apps/desktop/src/main/cindy-brain/__tests__/cindySlot.test.ts
@@ -1337,6 +1337,48 @@ describe('anyInflightWork（更新重启阻断探针）', () => {
     expect(slot.anyInflightWork()).toBe(false);
   });
 
+  // 寄存 / 撤回寄存在进入代办链之前就 return 了，走不到 inflight 记账；被打断会卡在
+  // blob 落盘与账本挂引用之间，所以单独记 mediaOps。
+  it('寄存在途期间为 true，结算后回到 false', async () => {
+    const PNG_BYTES = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2]);
+    let release!: () => void;
+    const gate = new Promise<void>((r) => { release = r; });
+    let seenDuring: boolean | null = null;
+    const { slot } = makeSlot({
+      depositMedia: vi.fn(async () => {
+        seenDuring = slot.anyInflightWork();
+        await gate;
+        return { hash: 'a'.repeat(64), bytes: PNG_BYTES.length, usedBytes: 10, quotaBytes: 100 };
+      }),
+    } as unknown as Partial<CindySlotDeps>);
+
+    const pending = slot.handleModelRequest('art', {
+      type: 'cindy-request',
+      kind: 'deposit_media',
+      data: Buffer.from(PNG_BYTES).toString('base64'),
+    });
+    release();
+    await pending;
+    expect(seenDuring).toBe(true);
+    expect(slot.anyInflightWork()).toBe(false);
+  });
+
+  it('寄存抛错也会释放在途计数（finally）', async () => {
+    const PNG_BYTES = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2]);
+    const { slot } = makeSlot({
+      depositMedia: vi.fn(async () => { throw new Error('disk is full'); }),
+    } as unknown as Partial<CindySlotDeps>);
+
+    const r = await slot.handleModelRequest('art', {
+      type: 'cindy-request',
+      kind: 'deposit_media',
+      data: Buffer.from(PNG_BYTES).toString('base64'),
+    });
+    expect(r).toMatchObject({ ok: false });
+    // 计数泄漏会让重启入口从此永久卡在「有任务在跑」。
+    expect(slot.anyInflightWork()).toBe(false);
+  });
+
   // 异步提交只对视频类开放（图像代办秒级完成，走同步等待）。
   it('异步视频代办（mode:submit）受理后为 true', async () => {
     let release!: () => void;
diff --git a/apps/desktop/src/main/cindy-brain/cindySlot.ts b/apps/desktop/src/main/cindy-brain/cindySlot.ts
index 9547791eb55..a4d9b891047 100644
--- a/apps/desktop/src/main/cindy-brain/cindySlot.ts
+++ b/apps/desktop/src/main/cindy-brain/cindySlot.ts
@@ -362,6 +362,12 @@ export function stripJsonFences(text: string): string {
 
 export class GhostCindySlot {
   private readonly inflight = new Map<string, number>();
+  /**
+   * 寄存 / 撤回寄存(deposit_media / release_media)的在途条数。与 inflight 分开记:那个是
+   * 代办限流账(getInflightLimit),这个只回答「重启会打断什么」—— 理由见 handleModelRequest
+   * 里那两个分支的注释。
+   */
+  private mediaOps = 0;
   /** 异步代办任务表(jobId → 记录;惰性 sweep,过期即清)。 */
   private readonly jobs = new Map<string, CindyAsyncJob>();
   /**
@@ -406,6 +412,12 @@ export class GhostCindySlot {
     // 而"永不 reject"是本类对沙箱的硬承诺(注入的嗅探/账本抛错也不许穿透)。
     if (p?.kind === 'deposit_media' || p?.kind === 'release_media') {
       const verb = p.kind === 'deposit_media' ? '寄存' : '撤回寄存';
+      // 寄存 / 撤回也要登记在途 —— 它们在这一行就 return 了,走不到下面代办链的 inflight
+      // 记账,而 ingestMedia 落盘与账本挂引用之间被 forceQuit() 打断会留下孤儿 blob。
+      // 刻意用独立计数而不并入 inflight:那个是**代办限流账**(getInflightLimit),
+      // 把面板里删素材 / 粘贴图算进去会让它们撞上「同时进行的代办已达上限」——
+      // 那是行为变更,不是本改动该做的事。这里只服务于「重启会打断什么」的判定。
+      this.mediaOps += 1;
       try {
         return p.kind === 'deposit_media'
           ? await this.handleDepositMedia(ghostId, p)
@@ -417,6 +429,8 @@ export class GhostCindySlot {
           error: message,
         });
         return { ok: false, message: `${verb}失败:${message}` };
+      } finally {
+        this.mediaOps -= 1;
       }
     }
     // 快问快答(text.oneshot):不经媒体生成链、不选型、秒级同步——单独
@@ -807,17 +821,19 @@ export class GhostCindySlot {
    * 上限在任何并发时序下都不被突破。
    */
   /**
-   * 是否有**任意**在途的 Cindy 代办 —— 同步与异步两种都算。
+   * 是否有**任意**在途的 Cindy 工作。
    *
-   * 给「这个破坏性动作会打断什么」这类全局判定用(更新重启前的阻断探针)。两半状态各自独立
-   * 维护,只查一半就等于漏一半:
-   *  - `jobs`:mode:'submit' 的异步图 / 视频生成。由 `void runExec()` 脱离调用链跑,发起它的
-   *    turn 结束后就没有任何 turn 级信号还亮着。
-   *  - `inflight`:同步代办的 per-ghost 在途计数(不带 mode:'submit' 的 gen_image / gen_video、
-   *    明确不进会话的 oneshot_text)。插件面板发起的请求不一定伴随 turn 或 card-action,
+   * 给「这个破坏性动作会打断什么」这类全局判定用(更新重启前的阻断探针)。三处状态各自独立
+   * 维护,只查一部分就等于漏一部分:
+   *  - `jobs`:mode:'submit' 的**异步视频**代办(异步提交只对视频开放,图像秒级完成走同步)。
+   *    由 `void runExec()` 脱离调用链跑,发起它的 turn 结束后就没有任何 turn 级信号还亮着。
+   *  - `inflight`:**同步**代办的 per-ghost 在途计数(gen_image / gen_video / edit_* 的同步
+   *    等待、明确不进会话的 oneshot_text)。插件面板发起的请求不一定伴随 turn 或 card-action,
    *    所以同样可能所有其它探针都不命中。
+   *  - `mediaOps`:寄存 / 撤回寄存(deposit_media / release_media)。这两个分支在进入代办链
+   *    之前就 return 了、走不到 inflight 记账;被打断会卡在 blob 落盘与账本挂引用之间。
    *
-   * 两者都会被 forceQuit() 连着 Ghost Node runtime 一起 destroyAll —— 正在生成的付费结果
+   * 三者都会被 forceQuit() 连着 Ghost Node runtime 一起 destroyAll —— 正在生成的付费结果
    * 直接丢掉。所以这里给的是「所有 Cindy slot 在途工作」的统一快照,而不是某一种。
    */
   anyInflightWork(): boolean {
@@ -827,7 +843,7 @@ export class GhostCindySlot {
     for (const count of this.inflight.values()) {
       if (count > 0) return true;
     }
-    return false;
+    return this.mediaOps > 0;
   }
 
   private evictSettledJobs(ghostId: string): void {

From 471c6e1f95a3a192a6202952a022d5838cc724b6 Mon Sep 17 00:00:00 2001
From: Dash <dashhuang@gmail.com>
Date: Fri, 31 Jul 2026 22:49:01 +0800
Subject: [PATCH 11/11] =?UTF-8?q?fix(desktop):=20=E9=87=8D=E5=90=AF?=
 =?UTF-8?q?=E6=8E=A2=E9=92=88=20IPC=20=E6=94=B9=E4=B8=BA=E5=B9=82=E7=AD=89?=
 =?UTF-8?q?=E6=B3=A8=E5=86=8C=EF=BC=8C=E9=98=B2=20splash=20=E9=87=8D?=
 =?UTF-8?q?=E8=AF=95=E8=BF=9E=E5=B8=A6=E6=8E=80=E6=8E=89=20maker=20IPC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

review 指出的问题成立，而且后果比 P2 的定级更重。

调用点 registerMakerIpcsAfterSplash 里，本 handler 注册在第 3826 行，而
makerIpcsRegistered = true 在第 3957 行；中间的 getMakerCore() 与
waitForInitialCustomMcpRefresh() 都可能抛，那个 try 的 catch 明写「不阻塞启动
—— 下次 splash retry 再尝试」。重试时 flag 仍是 false，早退不生效，于是这行被执行
第二次，ipcMain.handle 对同 channel 抛「Attempted to register a second handler」。

关键在于异常会从这里穿出去：不只是本 handler 注册失败，**排在它后面的全部 maker IPC
注册都被一起掀掉**，而且每次重试都卡在同一行 —— 结果是 maker 链路永久不可用。

修法用注册函数内幂等（先 removeHandler 再 handle），而不是把调用挪到成功之后：它对
调用位置不敏感，以后调用点顺序再变也不会重新踩坑。

测试：边界测试的 electron mock 改成仿真真实行为（同 channel 第二次 handle 直接抛）
—— 原来那个只 set 的假 Map 根本测不出重复注册。新增用例「重复注册不抛错且 handler
仍可用」，验证过能区分错误修法：移除 removeHandler 后该用例精确失败。

验证：pnpm test:unit 56 PASS / 0 FAIL、desktop typecheck 通过。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Dash <dashhuang@gmail.com>
---
 .../relaunchBusyActivityIpcBoundary.test.ts   | 23 +++++++++++++++++++
 .../src/main/relaunchBusyActivityIpc.ts       |  8 +++++++
 2 files changed, 31 insertions(+)

diff --git a/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts b/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
index d491cfae5c8..a07d5939519 100644
--- a/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
+++ b/apps/desktop/src/main/__tests__/relaunchBusyActivityIpcBoundary.test.ts
@@ -15,13 +15,23 @@ const h = vi.hoisted(() => ({
   handlers: new Map<string, (...args: unknown[]) => unknown>(),
   trusted: true,
   reads: 0,
+  removed: [] as string[],
 }));
 
+// 仿 Electron 的真实行为:同一 channel 第二次 handle 直接抛。幂等注册要靠 removeHandler,
+// 用一个只会 set 的假 Map 是测不出来的。
 vi.mock('electron', () => ({
   ipcMain: {
     handle: vi.fn((channel: string, handler: (...args: unknown[]) => unknown) => {
+      if (h.handlers.has(channel)) {
+        throw new Error(`Attempted to register a second handler for '${channel}'`);
+      }
       h.handlers.set(channel, handler);
     }),
+    removeHandler: vi.fn((channel: string) => {
+      h.removed.push(channel);
+      h.handlers.delete(channel);
+    }),
   },
 }));
 vi.mock('../logger', () => ({
@@ -57,6 +67,7 @@ beforeEach(() => {
   h.handlers.clear();
   h.trusted = true;
   h.reads = 0;
+  h.removed = [];
 });
 
 describe('registerRelaunchBusyActivityIpc', () => {
@@ -72,6 +83,18 @@ describe('registerRelaunchBusyActivityIpc', () => {
     expect(h.reads).toBeGreaterThan(0);
   });
 
+  // splash 首次失败会整段重试注册(bootstrap-electron 那个 catch 明写「下次 splash retry
+  // 再尝试」),此时 makerIpcsRegistered 仍是 false。若不幂等,第二次 handle 抛出的异常会
+  // 把排在后面的全部 maker IPC 注册一起掀掉,且每次重试都卡在同一行。
+  it('重复注册不抛错（splash 重试路径），且 handler 仍然可用', async () => {
+    registerRelaunchBusyActivityIpc(countingSources(true));
+    expect(() => registerRelaunchBusyActivityIpc(countingSources(true))).not.toThrow();
+    expect(h.removed).toContain(RELAUNCH_BLOCKING_ACTIVITY_CHANNEL);
+
+    const handler = h.handlers.get(RELAUNCH_BLOCKING_ACTIVITY_CHANNEL)!;
+    await expect(handler(fakeEvent)).resolves.toBe(true);
+  });
+
   it('不可信 sender(WebView / 子 frame / 未登记窗口):拒绝，且一个来源都不读', async () => {
     h.trusted = false;
     registerRelaunchBusyActivityIpc(countingSources(true));
diff --git a/apps/desktop/src/main/relaunchBusyActivityIpc.ts b/apps/desktop/src/main/relaunchBusyActivityIpc.ts
index 61b99a36c0f..cd66f359e35 100644
--- a/apps/desktop/src/main/relaunchBusyActivityIpc.ts
+++ b/apps/desktop/src/main/relaunchBusyActivityIpc.ts
@@ -30,6 +30,14 @@ const log = createLogger('relaunch-activity');
 export function registerRelaunchBusyActivityIpc(
   resolveSources: () => RelaunchBusyActivitySources,
 ): void {
+  // **幂等注册**,不是防御性冗余:调用点(bootstrap-electron 的 registerMakerIpcsAfterSplash)
+  // 在它之后还有会抛的初始化,而那个 try 的 catch 明写「下次 splash retry 再尝试」,重试时
+  // makerIpcsRegistered 仍是 false —— 于是这行会被执行第二次。ipcMain.handle 对同一 channel
+  // 第二次注册会抛「Attempted to register a second handler」,那不只是本 handler 注册失败:
+  // 异常会从这里穿出去,把**排在它后面的全部 maker IPC 注册**一起掀掉,而且每次重试都卡在
+  // 同一行 —— 结果是 maker 链路永久不可用。先 remove 再 handle,让重复调用总是收敛到
+  // 「一个当前有效的 handler」。
+  ipcMain.removeHandler(RELAUNCH_BLOCKING_ACTIVITY_CHANNEL);
   ipcMain.handle(RELAUNCH_BLOCKING_ACTIVITY_CHANNEL, async (event) => {
     assertTrustedAppRendererEvent(event);
     const result = await evaluateRelaunchBusyActivity(resolveSources());