Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

perf(remote): 远程归档乐观更新,不等远程电脑往返 (#5520)

Dash1ae5c38fb130
diff --git a/apps/desktop/src/main/__tests__/disableOrcaStrandedLead.test.ts b/apps/desktop/src/main/__tests__/disableOrcaStrandedLead.test.ts
index 2e6a2ccc54..59eaaa8558 100644
--- a/apps/desktop/src/main/__tests__/disableOrcaStrandedLead.test.ts
+++ b/apps/desktop/src/main/__tests__/disableOrcaStrandedLead.test.ts
@@ -62,12 +62,10 @@ describe('disableOrcaInternal stranded-lead recovery', () => {
expect(recycleIndex).toBeGreaterThan(archiveIndex);
});
- it('runs full removed-session cleanup after archiving one worker', () => {
+ it('schedules full removed-session cleanup after archiving one worker without awaiting it', () => {
const archiveIndex = registerSource.indexOf('await archiveSingleWorkerSession(sessionId, beforeMutation);');
- const recycleIndex = registerSource.indexOf(
- "await recycleSessionWorktreeForStatusChange(sessionId, 'archived', workerRecycleScope);",
- archiveIndex,
- );
+ const blockEnd = registerSource.indexOf('getManualInterrupt,', archiveIndex);
+ const block = registerSource.slice(archiveIndex, blockEnd);
const scopeIndex = registerSource.lastIndexOf(
'const workerRecycleScope = captureSessionRecycleScope();',
archiveIndex,
@@ -75,7 +73,16 @@ describe('disableOrcaInternal stranded-lead recovery', () => {
expect(scopeIndex).toBeGreaterThanOrEqual(0);
expect(scopeIndex).toBeLessThan(archiveIndex);
expect(archiveIndex).toBeGreaterThanOrEqual(0);
- expect(recycleIndex).toBeGreaterThan(archiveIndex);
+ expect(blockEnd).toBeGreaterThan(archiveIndex);
+ // Like ordinary archive, the reply must not wait for quiesce + git worktree removal.
+ // Awaiting here would also self-wait on the send lock held by plugin releaseWorker.
+ expect(block).toContain(
+ "scheduleWorktreeRecycleForStatusChange(sessionId, 'archived', workerRecycleScope);",
+ );
+ expect(block).not.toContain('await recycleSessionWorktreeForStatusChange');
+ expect(block.indexOf('await beforeMutation?.();')).toBeLessThan(
+ block.indexOf('scheduleWorktreeRecycleForStatusChange('),
+ );
});
it('reuses clearLeadOrcaRoleState on BOTH the normal-close and stranded-recovery paths', () => {
diff --git a/apps/desktop/src/main/__tests__/setSessionsStatusInDb.test.ts b/apps/desktop/src/main/__tests__/setSessionsStatusInDb.test.ts
index 9e3ade5c5d..4ef2467892 100644
--- a/apps/desktop/src/main/__tests__/setSessionsStatusInDb.test.ts
+++ b/apps/desktop/src/main/__tests__/setSessionsStatusInDb.test.ts
@@ -94,6 +94,7 @@ vi.mock('../worktree/sessionRemovalRecycle.js', () => ({
}));
import {
recycleSessionWorktreeForStatusChange,
+ scheduleWorktreeRecycleForStatusChange,
setSessionWorktreeRecycle,
setSessionRuntimeCleanup,
setSessionsStatusInDb,
@@ -614,6 +615,24 @@ describe('setSessionsStatusInDb', () => {
});
describe('recycleSessionWorktreeForStatusChange', () => {
+ it('schedules the cleanup chain without making the status reply wait for it', async () => {
+ let finish!: () => void;
+ h.recycleWorktreeForRemovedSession.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ finish = resolve;
+ }),
+ );
+ expect(scheduleWorktreeRecycleForStatusChange('s1', 'archived')).toBeUndefined();
+ try {
+ await vi.waitFor(() => expect(h.recycleWorktreeForRemovedSession).toHaveBeenCalledOnce());
+ expect(h.closeSession).toHaveBeenCalledWith('s1');
+ } finally {
+ finish?.();
+ }
+ await queueSessionWorktreeRecycle(async () => {});
+ });
+
it('runs the full runtime cleanup chain for archived sessions', async () => {
await recycleSessionWorktreeForStatusChange('s1', 'archived');
diff --git a/apps/desktop/src/main/localDb/ipc/sessions.ts b/apps/desktop/src/main/localDb/ipc/sessions.ts
index 39ccfc69aa..c176151090 100644
--- a/apps/desktop/src/main/localDb/ipc/sessions.ts
+++ b/apps/desktop/src/main/localDb/ipc/sessions.ts
@@ -557,7 +557,7 @@ async function recycleSessionWorktreeInQueue(
}
}
-function scheduleWorktreeRecycleForStatusChange(
+export function scheduleWorktreeRecycleForStatusChange(
sessionId: string,
status: unknown,
capturedScope?: SessionRecycleScope,
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 70ffa9c4fc..6d7eae0bfc 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -388,6 +388,7 @@ import {
getSessionRowSnapshotStrict,
persistSessionFields,
recycleSessionWorktreeForStatusChange,
+ scheduleWorktreeRecycleForStatusChange,
setSessionRuntimeCleanup,
} from '../localDb/ipc/sessions.js';
// sidebar-card-mode: turn-done 后刷新列表预览,并按需生成置顶卡片摘要
@@ -12192,7 +12193,12 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
const workerRecycleScope = captureSessionRecycleScope();
await archiveSingleWorkerSession(sessionId, beforeMutation);
await beforeMutation?.();
- await recycleSessionWorktreeForStatusChange(sessionId, 'archived', workerRecycleScope);
+ // 与普通归档(patchSessionMetaInDb)一致:status 落库即回执,回收(quiesce + git worktree
+ // remove + 文件清理)放后台,不让手机/桌面的归档回执等它。调用方(IPC / MCP archive_worker /
+ // 插件 releaseWorker)都不依赖回收已完成;回收在队列里按 captured scope 自行复核仍可删。
+ // 插件 releaseWorker 在持有该 session send 锁时调到这里,而回收要拿同一把 route 锁——
+ // 若在此 await 会自等到锁 watchdog bail,后台调度同时消除了这处自锁。
+ scheduleWorktreeRecycleForStatusChange(sessionId, 'archived', workerRecycleScope);
},
getManualInterrupt,
clearManualInterrupt,
diff --git a/apps/desktop/src/renderer/__tests__/makerChatStoreTextDeltaBatching.test.ts b/apps/desktop/src/renderer/__tests__/makerChatStoreTextDeltaBatching.test.ts
index b0da05d159..f55249ded7 100644
--- a/apps/desktop/src/renderer/__tests__/makerChatStoreTextDeltaBatching.test.ts
+++ b/apps/desktop/src/renderer/__tests__/makerChatStoreTextDeltaBatching.test.ts
@@ -5729,6 +5729,54 @@ describe('makerChatStore text delta batching', () => {
},
);
+ it('keeps the archived tombstone through an optimistic unarchive until the write confirms', () => {
+ remoteProjectsStore.pinSessionOrigin('device-1', SESSION_ID);
+ remoteProjectsStore.setDeviceSessions(
+ 'device-1',
+ 'Test Mac',
+ [{ id: SESSION_ID, status: 'archived', title: 'Archived task' } as Session],
+ 'archived',
+ );
+ onRemotePush?.({
+ deviceId: 'device-1',
+ channel: 'local-db:sessions:patched',
+ payload: { sessionId: SESSION_ID, patch: { status: 'archived' } },
+ });
+ const lateMessage = (id: string) => ({
+ deviceId: 'device-1',
+ channel: 'local-db:messages:created',
+ payload: {
+ sessionId: SESSION_ID,
+ message: serverMessage({
+ id,
+ sessionId: SESSION_ID,
+ clientId: `${id}-client`,
+ role: 'user',
+ content: id,
+ createdAt: '2026-08-02T00:00:00.000Z',
+ }),
+ },
+ });
+
+ // 恢复写库仍在途:投影已是 active,但墓碑只认分片里的权威行,迟到帧照旧丢弃。
+ const token = remoteProjectsStore.beginPendingStatus('device-1', SESSION_ID, 'active');
+ expect(
+ remoteProjectsStore.getMergedRemoteSessions().find((s) => s.id === SESSION_ID)?.status,
+ ).toBe('active');
+ onRemotePush?.(lateMessage('during-write'));
+ expect(makerChatStore.__hasSessionForTest(SESSION_ID)).toBe(false);
+
+ // 写库失败回滚 —— 墓碑仍在。
+ remoteProjectsStore.rollbackPendingStatus(token);
+ onRemotePush?.(lateMessage('after-rollback'));
+ expect(makerChatStore.__hasSessionForTest(SESSION_ID)).toBe(false);
+
+ // 写库成功:显式释放墓碑,后续帧不再被丢弃,不必等 reseed。
+ makerChatStore.releaseRemoteArchivedTombstone(SESSION_ID, 'device-1');
+ onRemotePush?.(lateMessage('after-restore'));
+ expect(makerChatStore.__hasSessionForTest(SESSION_ID)).toBe(true);
+ });
+
it('cancels a remote optimistic send that is still in preflight when the session is cleared', async () => {
remoteProjectsStore.pinSessionOrigin('device-1', SESSION_ID);
let resolvePreflight!: (value: boolean) => void;
diff --git a/apps/desktop/src/renderer/__tests__/remoteProjectsStore.test.ts b/apps/desktop/src/renderer/__tests__/remoteProjectsStore.test.ts
index 9ecdaf331e..f4052c7ed3 100644
--- a/apps/desktop/src/renderer/__tests__/remoteProjectsStore.test.ts
+++ b/apps/desktop/src/renderer/__tests__/remoteProjectsStore.test.ts
@@ -941,3 +941,216 @@ describe('remoteProjectsStore pending first send', () => {
expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.userSendAt).toBeNull();
});
});
+
+/**
+ * 远程归档 / 恢复的状态迁移叠加层:写库往返期间行先换桶,分片保持权威;
+ * 写库成功落被控端返回的行,叠加层留到写库之后的新列表确认为止。
+ */
+describe('remoteProjectsStore pending status (remote archive / unarchive)', () => {
+ const PINNED_AT = '2026-01-02T00:00:00.000Z';
+ const projected = (id: string) =>
+ remoteProjectsStore.getMergedRemoteSessions().find((session) => session.id === id);
+ const stored = (id: string) =>
+ remoteProjectsStore.getDeviceSessions('dev-A').find((session) => session.id === id);
+
+ beforeEach(() => {
+ setRemoteReseedImpl(null);
+ remoteProjectsStore.clear();
+ remoteProjectsStore.__resetPendingTitlePreviewForTest();
+ });
+
+ it('moves an archived row out of the active bucket at once without rewriting the shard', () => {
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { pinnedAt: PINNED_AT }), mk('b')]);
+ const before = remoteProjectsStore.getMergedRemoteSessions();
+
+ remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
+
+ expect(remoteProjectsStore.getMergedRemoteSessions()).not.toBe(before);
+ expect(projected('a')).toMatchObject({ status: 'archived', pinnedAt: null });
+ expect(projected('b')?.status).toBe('active');
+ // 分片仍是权威镜像;origin 判定不受影响。
+ expect(stored('a')).toMatchObject({ status: 'active', pinnedAt: PINNED_AT });
+ expect(getSessionDeviceId('a')).toBe('dev-A');
+ });
+
+ it('restores the row on rollback, and only the latest token can settle a session', () => {
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ const first = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
+ const second = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
+ expect(remoteProjectsStore.isPendingStatusCurrent(first)).toBe(false);
+ expect(remoteProjectsStore.isPendingStatusCurrent(second)).toBe(true);
+
+ expect(remoteProjectsStore.rollbackPendingStatus(first)).toBe(false);
+ expect(remoteProjectsStore.completePendingStatus(first, { status: 'archived' })).toBe(false);
+ expect(projected('a')?.status).toBe('archived');
+ expect(stored('a')?.status).toBe('active');
+
+ expect(remoteProjectsStore.rollbackPendingStatus(second)).toBe(true);
+ expect(projected('a')?.status).toBe('active');
+ });
+
+ it('keeps the row hidden while stale snapshots and patches land during the write', () => {
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
+
+ // 写库前就在途的列表 / 乱序 push 仍报 active —— 叠加层顶着,不回弹。
+ remoteProjectsStore.nextSnapshotEpoch('dev-A');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { title: 'renamed' })]);
+ remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'active' });
+
+ expect(projected('a')).toMatchObject({ status: 'archived', title: 'renamed' });
+ expect(stored('a')?.status).toBe('active');
+ });
+
+ it('applies the persisted row on success and survives a list that started before the write', () => {
+ const reseed = vi.fn();
+ setRemoteReseedImpl(reseed);
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { pinnedAt: PINNED_AT })]);
+ // 10s 周期对账在写库前已发出(拿到了 epoch),响应会在写库成功之后才落地。
+ const staleEpoch = remoteProjectsStore.nextSnapshotEpoch('dev-A');
+ const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
+
+ expect(
+ remoteProjectsStore.completePendingStatus(token, {
+ id: 'a',
+ status: 'archived',
+ pinnedAt: null,
+ updatedAt: '2026-02-01T00:00:00.000Z',
+ }),
+ ).toBe(true);
+ // 不等 sessions:patched 回流,权威行已就地落下。
+ expect(stored('a')).toMatchObject({
+ status: 'archived',
+ pinnedAt: null,
+ updatedAt: '2026-02-01T00:00:00.000Z',
+ });
+ // 完成不让在途列表 superseded(不打断 bootstrap / 按需读取的收尾)。
+ expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', staleEpoch)).toBe(true);
+
+ // 陈旧列表落地,把权威行改回 active —— 叠加层继续顶着,行不复活。
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ expect(stored('a')?.status).toBe('active');
+ expect(projected('a')?.status).toBe('archived');
+
+ // 同状态的 push 回流不撤叠加层(它可能早于那份陈旧列表到达)。
+ remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'archived' });
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ expect(projected('a')?.status).toBe('archived');
+
+ // 写库之后才发出的列表不含该行 → 权威确认,叠加层让位。
+ remoteProjectsStore.nextSnapshotEpoch('dev-A');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
+ expect(projected('a')).toBeUndefined();
+ // 叠加层已回收:之后的权威 active 快照照实显示(例如别处又恢复了它)。
+ remoteProjectsStore.nextSnapshotEpoch('dev-A');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ expect(projected('a')?.status).toBe('active');
+ });
+
+ it('settles on a confirming snapshot even when the shard is already byte-identical', () => {
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
+ remoteProjectsStore.completePendingStatus(token, { status: 'archived', pinnedAt: null });
+
+ // 写库后的 active 新列表不含 a:分片内容与此前逐字节相同(a 已是 archived),走 no-op
+ // 分支 —— 叠加层仍要在这里确认回收。
+ const listener = vi.fn();
+ const unsubscribe = remoteProjectsStore.subscribe(listener);
+ remoteProjectsStore.nextSnapshotEpoch('dev-A');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
+ unsubscribe();
+ expect(listener).toHaveBeenCalled();
+ expect(projected('a')?.status).toBe('archived');
+
+ // 已回收:之后的权威 active 行(例如别处又恢复了它)照实显示。
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ expect(projected('a')?.status).toBe('active');
+ });
+
+ it('brings an unarchived row back into the active bucket immediately', () => {
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
+ remoteProjectsStore.setDeviceSessions(
+ 'dev-A',
+ 'A',
+ [mk('a', { status: 'archived' })],
+ 'archived',
+ );
+ const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'active');
+ expect(projected('a')?.status).toBe('active');
+ expect(stored('a')?.status).toBe('archived');
+
+ remoteProjectsStore.completePendingStatus(token, { id: 'a', status: 'active' });
+ expect(stored('a')?.status).toBe('active');
+ expect(projected('a')?.status).toBe('active');
+ });
+
+ it('ignores late status pushes after the write and a post-write list that still carries old data', () => {
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
+ remoteProjectsStore.completePendingStatus(token, {
+ id: 'a',
+ status: 'archived',
+ updatedAt: '2026-02-01T00:00:00.000Z',
+ });
+
+ // 写库前产生的 active 推送晚于回包到达:不带 updatedAt,分不清新旧 —— 不撤叠加层。
+ remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'active' });
+ expect(projected('a')?.status).toBe('archived');
+
+ // 写库后才发出的列表被被控端并进写库前的查询,仍带旧 active 行 —— 第一份容忍一次。
+ remoteProjectsStore.nextSnapshotEpoch('dev-A');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ expect(projected('a')?.status).toBe('archived');
+
+ // 真正写库后的列表不含它 → 确认让位。
+ remoteProjectsStore.nextSnapshotEpoch('dev-A');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
+ remoteProjectsStore.nextSnapshotEpoch('dev-A');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
+ expect(projected('a')?.status).toBe('active');
+ });
+
+ it('yields to a later change by another controller on the second post-write list', () => {
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
+ remoteProjectsStore.setDeviceSessions(
+ 'dev-A',
+ 'A',
+ [mk('a', { status: 'archived' })],
+ 'archived',
+ );
+ const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'active');
+ remoteProjectsStore.completePendingStatus(token, { id: 'a', status: 'active' });
+
+ // 另一控制端随后又把它归档了。状态写不推进 updatedAt,推送和第一份对不上的写库后列表
+ // 都分不清它与旧结果 —— 叠加层顶住;第二份写库后列表无论内容一律让位,不会永远顶住。
+ remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'archived' });
+ expect(projected('a')?.status).toBe('active');
+ const archivedList = () => {
+ remoteProjectsStore.nextSnapshotEpoch('dev-A', 'archived');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { status: 'archived' })], 'archived');
+ };
+ archivedList();
+ expect(projected('a')?.status).toBe('active');
+ archivedList();
+ expect(projected('a')?.status).toBe('archived');
+ });
+
+ it('drops the overlay on deletion, device removal and clear', () => {
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a'), mk('b'), mk('c')]);
+ const deleted = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
+ remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'deleted' });
+ expect(projected('a')).toBeUndefined();
+ expect(remoteProjectsStore.completePendingStatus(deleted, { status: 'archived' })).toBe(false);
+
+ const removed = remoteProjectsStore.beginPendingStatus('dev-A', 'b', 'archived');
+ remoteProjectsStore.removeDevice('dev-A');
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('b')]);
+ expect(projected('b')?.status).toBe('active');
+ expect(remoteProjectsStore.rollbackPendingStatus(removed)).toBe(false);
+
+ remoteProjectsStore.beginPendingStatus('dev-A', 'b', 'archived');
+ remoteProjectsStore.clear();
+ remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('b')]);
+ expect(projected('b')?.status).toBe('active');
+ });
+});
diff --git a/apps/desktop/src/renderer/features/cc-agent/CCAgentSidebarUpper.tsx b/apps/desktop/src/renderer/features/cc-agent/CCAgentSidebarUpper.tsx
index aac98247f7..bd31c31dd6 100644
--- a/apps/desktop/src/renderer/features/cc-agent/CCAgentSidebarUpper.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/CCAgentSidebarUpper.tsx
@@ -197,6 +197,7 @@ import {
getSessionDeviceId,
remoteProjectsStore,
useRemoteScheduleIndex,
+ type RemotePendingStatusToken,
} from '@/features/device-link/remoteProjectsStore';
import {
getRemoteSessionActivity,
@@ -1113,6 +1114,10 @@ function ExpandedView({
);
const [confirm, setConfirm] = useState<ConfirmState>(CONFIRM_INITIAL);
+ // 远程任务归档确认弹窗期间行已提前隐藏(见 handleActionClick);凭据放 ref 而非 confirm
+ // state:确认按钮的 onClick 要先同步认领它,Radix 随后触发的 onOpenChange(false) →
+ // handleCancelConfirm 才不会把正在写库的那次归档回滚掉。
+ const confirmRemoteArchiveRef = useRef<RemotePendingStatusToken | null>(null);
// 系统级通知触发:sessions 数组每次渲染都新引用,但 callback 读 ref,
// 不会因此重跑 transition effect。通道、失焦与灵动岛去重由共享入口收口。
@@ -2960,9 +2965,21 @@ function ExpandedView({
*/
// includeArchived 跟随当前列表桶(filter.status)—— archived / all 桶里
// 删除后要刷对应桶,否则已删行残留(见 hook 文件头注释)。
- const { runSessionAction, unarchiveSession } = useSessionLifecycleActions({
- includeArchived: filter.status,
- });
+ const { runSessionAction, unarchiveSession, beginRemoteArchive, cancelRemoteArchive } =
+ useSessionLifecycleActions({
+ includeArchived: filter.status,
+ });
+
+ // 新确认框顶替旧确认框时(两次预检交错返回),旧框提前隐藏的远程任务已无处取消,
+ // 先让它回到列表,再登记新框的凭据。
+ const replaceConfirmRemoteArchive = useCallback(
+ (token: RemotePendingStatusToken | null) => {
+ const previous = confirmRemoteArchiveRef.current;
+ confirmRemoteArchiveRef.current = token;
+ if (previous && previous !== token) cancelRemoteArchive(previous);
+ },
+ [cancelRemoteArchive],
+ );
const closeOwnedSharedTask = useCallback(async (sharedTaskId?: string): Promise<boolean> => {
if (!sharedTaskId) return true;
@@ -3041,6 +3058,14 @@ function ExpandedView({
// 之间还有写库和回收链;那一段由 main 在删除前重新检测 + auto-stash 兜住
// (WorktreeManager.removeWorktreeForSession),renderer 这层负责的是「别拿
// 明显过期的结论免掉确认」。
+ //
+ // 远程任务的预检是一次完整隧道往返(被控端跑 git status),不再让用户干等:
+ // 先乐观隐藏行并跳离,再等预检。干净 → 沿用同一叠加层直接写库;需要确认 →
+ // 行保持隐藏弹确认框,取消再让行回来(已跳离的视图不跳回)。本机任务预检
+ // 很快,维持原顺序。
+ const remoteArchiveToken = session?.deviceLinkDeviceId
+ ? beginRemoteArchive(sessionId, session.deviceLinkDeviceId, viewedSessionIdRef.current)
+ : null;
const preflight = await resolveWorktreeRemovalPreflight(
sessionId,
session?.deviceLinkDeviceId,
@@ -3050,6 +3075,7 @@ function ExpandedView({
// (greptile review)。'unknown' 时不摆 dirty 警告文案 —— 那会谎称有改动,
// 走的是普通归档确认。
if (preflight !== 'clean') {
+ replaceConfirmRemoteArchive(remoteArchiveToken);
setConfirm({
open: true,
sessionId,
@@ -3062,9 +3088,13 @@ function ExpandedView({
// 重定向判定用 viewedSessionId:files 路由下归档「正在浏览的会话」也要
// 跳离失效的文件视图(codex review;正常路由下两者恒等)。经 ref 读:它随
// 路由切换而变,留在 deps 里会让本 handler 每次切换都重建、打穿整表 memo。
- if (!(await closeOwnedSharedTask(sharedTaskId))) return;
+ if (!(await closeOwnedSharedTask(sharedTaskId))) {
+ if (remoteArchiveToken) cancelRemoteArchive(remoteArchiveToken);
+ return;
+ }
await runSessionAction(sessionId, 'archive', {
activeSessionId: viewedSessionIdRef.current,
+ remoteArchiveToken,
});
return;
}
@@ -3077,6 +3107,7 @@ function ExpandedView({
'dirty';
// Keep the existing confirm-state shape for the normal delete flow, then attach
// the shared-task scope in a functional update so cancellation still leaves it open.
+ replaceConfirmRemoteArchive(null);
setConfirm({ open: true, sessionId, action, dirtyWorktree });
if (sharedTaskId) {
setConfirm((previous) => ({ ...previous, sharedTaskId }));
@@ -3085,18 +3116,34 @@ function ExpandedView({
}
await unarchiveSession(sessionId);
},
- [closeOwnedSharedTask, runningSessionIds, runSessionAction, unarchiveSession, t],
+ [
+ beginRemoteArchive,
+ cancelRemoteArchive,
+ closeOwnedSharedTask,
+ replaceConfirmRemoteArchive,
+ runningSessionIds,
+ runSessionAction,
+ unarchiveSession,
+ t,
+ ],
);
const handleConfirm = useCallback(async () => {
const { sessionId, action, sharedTaskId } = confirm;
+ // 同步认领提前隐藏的远程归档,见 confirmRemoteArchiveRef。
+ const remoteArchiveToken = confirmRemoteArchiveRef.current;
+ confirmRemoteArchiveRef.current = null;
const session = sessionsById.get(sessionId);
if (isRemoteSessionWriteBlocked(session)) {
+ if (remoteArchiveToken) cancelRemoteArchive(remoteArchiveToken);
toast.warning(t('ccAgent.remoteSession.actionsUnavailable'));
setConfirm(CONFIRM_INITIAL);
return;
}
- if (!(await closeOwnedSharedTask(sharedTaskId))) return;
+ if (!(await closeOwnedSharedTask(sharedTaskId))) {
+ if (remoteArchiveToken) cancelRemoteArchive(remoteArchiveToken);
+ return;
+ }
// 重定向判定统一用 viewedSessionId(files 路由下 = 被浏览文件的会话,
// 正常路由下与 activeSessionId 恒等):从面板删除/归档正在浏览的会话时
// 也要跳离失效的 /cc-agent/files/:id(codex review)。
@@ -3107,13 +3154,18 @@ function ExpandedView({
await runSessionAction(sessionId, action, {
activeSessionId: viewedSessionId,
deleteRedirectRoute,
+ remoteArchiveToken,
});
setConfirm(CONFIRM_INITIAL);
- }, [closeOwnedSharedTask, viewedSessionId, confirm, resolveSessionRemovalRedirect, runSessionAction, sessionsById, t]);
+ }, [cancelRemoteArchive, closeOwnedSharedTask, viewedSessionId, confirm, resolveSessionRemovalRedirect, runSessionAction, sessionsById, t]);
const handleCancelConfirm = useCallback(() => {
+ // 取消 / 点外部关闭:提前隐藏的远程任务回到列表。
+ const remoteArchiveToken = confirmRemoteArchiveRef.current;
+ confirmRemoteArchiveRef.current = null;
+ if (remoteArchiveToken) cancelRemoteArchive(remoteArchiveToken);
setConfirm(CONFIRM_INITIAL);
- }, []);
+ }, [cancelRemoteArchive]);
const handleBulkDelete = useCallback(async () => {
if (bulkActionPending !== null) return;
diff --git a/apps/desktop/src/renderer/features/cc-agent/SessionContentHeader.tsx b/apps/desktop/src/renderer/features/cc-agent/SessionContentHeader.tsx
index a119e44a7a..b3a2c84b9e 100644
--- a/apps/desktop/src/renderer/features/cc-agent/SessionContentHeader.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/SessionContentHeader.tsx
@@ -142,7 +142,8 @@ export function SessionContentHeader({
const sharedGuest = isSharedTaskPeer(session.deviceLinkDeviceId ?? '');
const { runningSessionIds } = useSessionRunningStatus(session.id);
const { confirm: confirmDialog } = useConfirmDialog();
- const { runSessionAction, unarchiveSession } = useSessionLifecycleActions();
+ const { runSessionAction, unarchiveSession, beginRemoteArchive, cancelRemoteArchive } =
+ useSessionLifecycleActions();
const isPinned = session.pinnedAt != null;
const isArchived = session.status === 'archived';
@@ -430,6 +431,11 @@ export function SessionContentHeader({
// 一起等,dirty 先返回 clean、接管查询还在飞的那段时间就是 clean 结论的失效窗口。
// 改成接管结算之后再 resolve —— clean 一律重查(见 worktreeRemovalWarning),
// 拿到的是此刻的结论;菜单打开时的 prefetch 仍然热了 git cache。
+ // 远程任务的预检是一次完整隧道往返:先乐观隐藏行并跳离,预检干净则沿用同一叠加层
+ // 写库,需要确认时取消再让行回来(与 sidebar 同口径,见 handleActionClick)。
+ const remoteArchiveToken = session.deviceLinkDeviceId
+ ? beginRemoteArchive(session.id, session.deviceLinkDeviceId, session.id)
+ : null;
const preflight = await resolveWorktreeRemovalPreflight(session.id, session.deviceLinkDeviceId);
// 归档不弹确认框 —— 可逆操作(菜单里就有「恢复」),与 sidebar 同口径。
// 免确认的判据是「**确认**干净」:worktree 脏、或预检失败拿不到结论('unknown')
@@ -446,10 +452,18 @@ export function SessionContentHeader({
confirmText: t('ccAgent.sidebar.confirmArchive.confirm'),
cancelText: t('ccAgent.sidebar.confirmArchive.cancel'),
});
- if (!ok) return;
+ if (!ok) {
+ if (remoteArchiveToken) cancelRemoteArchive(remoteArchiveToken);
+ return;
+ }
}
- await runSessionAction(session.id, 'archive', { activeSessionId: session.id });
+ await runSessionAction(session.id, 'archive', {
+ activeSessionId: session.id,
+ remoteArchiveToken,
+ });
}, [
+ beginRemoteArchive,
+ cancelRemoteArchive,
confirmDialog,
remoteWritesBlocked,
runSessionAction,
diff --git a/apps/desktop/src/renderer/features/cc-agent/__tests__/sharedTaskArchiveGuard.test.ts b/apps/desktop/src/renderer/features/cc-agent/__tests__/sharedTaskArchiveGuard.test.ts
index 68cf2cf3ce..1bb4aab172 100644
--- a/apps/desktop/src/renderer/features/cc-agent/__tests__/sharedTaskArchiveGuard.test.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/__tests__/sharedTaskArchiveGuard.test.ts
@@ -37,6 +37,8 @@ function harness(result: unknown, reject = false, sharedTaskId: string | undefin
viewedSessionIdRef: { current: 'other' }, viewedSessionId: 'other',
resolveSessionRemovalRedirect: vi.fn(), unarchiveSession: vi.fn(),
runSessionAction, setConfirm, CONFIRM_INITIAL: { open: false },
+ confirmRemoteArchiveRef: { current: null }, beginRemoteArchive: vi.fn(), cancelRemoteArchive: vi.fn(),
+ replaceConfirmRemoteArchive: vi.fn(),
};
const closeOwnedSharedTask = callback('closeOwnedSharedTask', bindings);
return {
@@ -82,3 +84,93 @@ describe('sidebar shared-task archive/delete guard', () => {
expect(h.runSessionAction).toHaveBeenCalledTimes(2);
});
});
+
+describe('sidebar remote archive hides the row before the worktree preflight', () => {
+ function remoteHarness(preflight: 'clean' | 'dirty' | 'unknown') {
+ const token = { deviceId: 'device-1', sessionId: 'task', status: 'archived' };
+ const order: string[] = [];
+ const runSessionAction = vi.fn();
+ const setConfirm = vi.fn();
+ const beginRemoteArchive = vi.fn(() => { order.push('begin'); return token; });
+ const cancelRemoteArchive = vi.fn();
+ const confirmRemoteArchiveRef = { current: null as unknown };
+ const replaceConfirmRemoteArchive = callback('replaceConfirmRemoteArchive', {
+ confirmRemoteArchiveRef, cancelRemoteArchive,
+ });
+ const session = { id: 'task', deviceLinkDeviceId: 'device-1' };
+ const bindings = {
+ window: { electronAPI: { sharedTask: { account: vi.fn() }, binding: { resolveSession: async () => ({ attached: false }) } } },
+ toast: { error: vi.fn(), warning: vi.fn() }, t: (key: string) => key, sharedTaskErrorKey: () => 'sharedTask.retry',
+ sessionsById: new Map([['task', session]]), sessionsByIdRef: { current: new Map([['task', session]]) },
+ runningSessionIds: new Set(), attachedSessionIdsRef: { current: new Set() },
+ isRemoteSessionWriteBlocked: () => false,
+ resolveWorktreeRemovalPreflight: async () => { order.push('preflight'); return preflight; },
+ viewedSessionIdRef: { current: 'task' }, viewedSessionId: 'task',
+ resolveSessionRemovalRedirect: vi.fn(), unarchiveSession: vi.fn(),
+ runSessionAction, setConfirm, CONFIRM_INITIAL: { open: false },
+ confirmRemoteArchiveRef, beginRemoteArchive, cancelRemoteArchive, replaceConfirmRemoteArchive,
+ closeOwnedSharedTask: async () => true,
+ confirm: { sessionId: 'task', action: 'archive' },
+ };
+ return {
+ token, order, runSessionAction, setConfirm, beginRemoteArchive, cancelRemoteArchive, confirmRemoteArchiveRef,
+ archive: () => callback('handleActionClick', bindings)('task', 'archive'),
+ confirm: () => callback('handleConfirm', bindings)(),
+ cancel: () => callback('handleCancelConfirm', bindings)(),
+ };
+ }
+
+ it('reuses the same overlay for a clean preflight', async () => {
+ const h = remoteHarness('clean');
+ await h.archive();
+ expect(h.order).toEqual(['begin', 'preflight']);
+ expect(h.beginRemoteArchive).toHaveBeenCalledWith('task', 'device-1', 'task');
+ expect(h.runSessionAction).toHaveBeenCalledWith('task', 'archive', {
+ activeSessionId: 'task',
+ remoteArchiveToken: h.token,
+ });
+ expect(h.cancelRemoteArchive).not.toHaveBeenCalled();
+ });
+
+ it.each(['dirty', 'unknown'] as const)('restores the row when a %s preflight is cancelled', async (preflight) => {
+ const h = remoteHarness(preflight);
+ await h.archive();
+ expect(h.order).toEqual(['begin', 'preflight']);
+ expect(h.setConfirm).toHaveBeenCalledWith(expect.objectContaining({ open: true, action: 'archive' }));
+ expect(h.confirmRemoteArchiveRef.current).toBe(h.token);
+ expect(h.runSessionAction).not.toHaveBeenCalled();
+
+ h.cancel();
+ expect(h.cancelRemoteArchive).toHaveBeenCalledWith(h.token);
+ expect(h.confirmRemoteArchiveRef.current).toBeNull();
+ });
+
+ it('claims the hidden row on confirm so the dialog closing does not roll it back', async () => {
+ const h = remoteHarness('dirty');
+ await h.archive();
+ const confirmed = h.confirm();
+ // Radix 在确认按钮 onClick 之后同步触发 onOpenChange(false) → handleCancelConfirm。
+ h.cancel();
+ await confirmed;
+ expect(h.cancelRemoteArchive).not.toHaveBeenCalled();
+ expect(h.beginRemoteArchive).toHaveBeenCalledTimes(1);
+ expect(h.runSessionAction).toHaveBeenCalledWith('task', 'archive', expect.objectContaining({
+ remoteArchiveToken: h.token,
+ }));
+ });
+
+ it('restores an earlier hidden row when a later confirm dialog replaces it', async () => {
+ const h = remoteHarness('dirty');
+ await h.archive();
+ const later = { ...h.token, sessionId: 'later' };
+ h.beginRemoteArchive.mockImplementationOnce(() => later);
+ await h.archive();
+ // 第一次的确认框已被顶替,它隐藏的行没有入口可取消 —— 先回到列表。
+ expect(h.cancelRemoteArchive).toHaveBeenCalledTimes(1);
+ expect(h.cancelRemoteArchive).toHaveBeenCalledWith(h.token);
+ expect(h.confirmRemoteArchiveRef.current).toBe(later);
+
+ h.cancel();
+ expect(h.cancelRemoteArchive).toHaveBeenLastCalledWith(later);
+ });
+});
diff --git a/apps/desktop/src/renderer/features/cc-agent/hooks/__tests__/useSessionLifecycleActions.test.tsx b/apps/desktop/src/renderer/features/cc-agent/hooks/__tests__/useSessionLifecycleActions.test.tsx
index e58a05bb59..1a5dc6c988 100644
--- a/apps/desktop/src/renderer/features/cc-agent/hooks/__tests__/useSessionLifecycleActions.test.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/hooks/__tests__/useSessionLifecycleActions.test.tsx
@@ -16,6 +16,11 @@ const mocks = vi.hoisted(() => ({
rollbackStatusTransition: vi.fn(),
closeSessionQuery: vi.fn(),
purgeSession: vi.fn(),
+ releaseRemoteArchivedTombstone: vi.fn(),
+ beginPendingStatus: vi.fn(),
+ completePendingStatus: vi.fn(),
+ rollbackPendingStatus: vi.fn(),
+ isPendingStatusCurrent: vi.fn(),
clearComposerDraft: vi.fn(),
cleanupSessionLayoutPrefs: vi.fn(),
cleanupSessionImages: vi.fn(),
@@ -46,6 +51,16 @@ vi.mock('@/lib/makerChatStore', () => ({
makerChatStore: {
closeSessionQuery: mocks.closeSessionQuery,
purgeSession: mocks.purgeSession,
+ releaseRemoteArchivedTombstone: mocks.releaseRemoteArchivedTombstone,
+ },
+}));
+
+vi.mock('@/features/device-link/remoteProjectsStore', () => ({
+ remoteProjectsStore: {
+ beginPendingStatus: mocks.beginPendingStatus,
+ completePendingStatus: mocks.completePendingStatus,
+ rollbackPendingStatus: mocks.rollbackPendingStatus,
+ isPendingStatusCurrent: mocks.isPendingStatusCurrent,
},
}));
@@ -107,6 +122,12 @@ beforeEach(() => {
},
);
mocks.completeStatusTransition.mockReturnValue(true);
+ mocks.beginPendingStatus.mockImplementation(
+ (deviceId: string, sessionId: string, status: string) => ({ deviceId, sessionId, status }),
+ );
+ mocks.completePendingStatus.mockReturnValue(true);
+ mocks.rollbackPendingStatus.mockReturnValue(true);
+ mocks.isPendingStatusCurrent.mockReturnValue(true);
mocks.rollbackStatusTransition.mockReturnValue(true);
mocks.refreshSessions.mockResolvedValue([]);
mocks.cleanupSessionImages.mockResolvedValue(undefined);
@@ -294,7 +315,7 @@ describe('useSessionLifecycleActions archive optimistic ordering', () => {
);
});
- it('leaves device-link archive convergence to the remote mirror', async () => {
+ it('hides a device-link row through the remote overlay before the write and completes it', async () => {
mocks.resolveStatusWriteTarget.mockResolvedValueOnce({
kind: 'device-link',
deviceId: 'device-1',
@@ -305,17 +326,210 @@ describe('useSessionLifecycleActions archive optimistic ordering', () => {
await act(async () => {
await result.current.runSessionAction('remote-session', 'archive', {
- activeSessionId: null,
+ activeSessionId: 'remote-session',
});
});
+ const token = { deviceId: 'device-1', sessionId: 'remote-session', status: 'archived' };
+ expect(mocks.beginPendingStatus).toHaveBeenCalledWith('device-1', 'remote-session', 'archived');
+ expect(mocks.beginPendingStatus.mock.invocationCallOrder[0]).toBeLessThan(
+ mocks.navigate.mock.invocationCallOrder[0],
+ );
+ expect(mocks.beginPendingStatus.mock.invocationCallOrder[0]).toBeLessThan(
+ mocks.setStatus.mock.invocationCallOrder[0],
+ );
+ expect(mocks.navigate).toHaveBeenCalledWith('/cc-agent/new');
expect(mocks.setStatus).toHaveBeenCalledWith('remote-session', 'archived', {
kind: 'device-link',
deviceId: 'device-1',
});
+ expect(mocks.completePendingStatus).toHaveBeenCalledWith(
+ token,
+ expect.objectContaining({ id: 'remote-session', status: 'archived' }),
+ );
expect(mocks.beginStatusTransition).not.toHaveBeenCalled();
- expect(mocks.completeStatusTransition).not.toHaveBeenCalled();
expect(mocks.patchLocal).not.toHaveBeenCalled();
+ expect(mocks.logInfo).toHaveBeenCalledWith(
+ 'archive timing',
+ expect.objectContaining({ outcome: 'success', deviceLink: true }),
+ );
+ });
+
+ it('drops a pre-begun remote archive that a later restore superseded during the preflight', async () => {
+ mocks.resolveStatusWriteTarget.mockResolvedValue({ kind: 'device-link', deviceId: 'device-1' });
+ // 「全部」筛选里预检期间用户已点了恢复:预先隐藏的归档凭据已被取代。
+ mocks.isPendingStatusCurrent.mockReturnValue(false);
+ const token = { deviceId: 'device-1', sessionId: 'remote-session', status: 'archived' as const };
+ const { result } = renderHook(() => useSessionLifecycleActions({ includeArchived: 'all' }));
+
+ await act(async () => {
+ await result.current.runSessionAction('remote-session', 'archive', {
+ activeSessionId: null,
+ remoteArchiveToken: token,
+ });
+ });
+
+ expect(mocks.isPendingStatusCurrent).toHaveBeenCalledWith(token);
+ expect(mocks.setStatus).not.toHaveBeenCalled();
+ expect(mocks.completePendingStatus).not.toHaveBeenCalled();
+ expect(mocks.rollbackPendingStatus).not.toHaveBeenCalled();
+ expect(mocks.toastError).not.toHaveBeenCalled();
+ });
+
+ it('sends an unarchive only after the in-flight remote archive of the same task settles', async () => {
+ const target = { kind: 'device-link', deviceId: 'device-1' };
+ mocks.resolveStatusWriteTarget.mockResolvedValue(target);
+ let releaseArchive!: () => void;
+ mocks.setStatus.mockImplementationOnce(
+ (id: string, status: string) =>
+ new Promise((resolve) => {
+ releaseArchive = () => resolve({ id, status, title: id });
+ }),
+ );
+ const { result } = renderHook(() => useSessionLifecycleActions({ includeArchived: 'all' }));
+
+ let archiving!: Promise<void>;
+ let unarchiving!: Promise<void>;
+ await act(async () => {
+ archiving = result.current.runSessionAction('remote-session', 'archive', {
+ activeSessionId: null,
+ });
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ await act(async () => {
+ unarchiving = result.current.unarchiveSession('remote-session');
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ // 两次叠加层都已当帧切换,但恢复的写库要等归档那笔结算,被控端按操作顺序落库。
+ expect(mocks.beginPendingStatus).toHaveBeenCalledWith('device-1', 'remote-session', 'active');
+ expect(mocks.setStatus.mock.calls.map((call) => call[1])).toEqual(['archived']);
+
+ await act(async () => {
+ releaseArchive();
+ await archiving;
+ await unarchiving;
+ });
+ expect(mocks.setStatus.mock.calls.map((call) => call[1])).toEqual(['archived', 'active']);
+ });
+
+ it('rolls the device-link overlay back and reports when the remote write fails', async () => {
+ mocks.resolveStatusWriteTarget.mockResolvedValueOnce({
+ kind: 'device-link',
+ deviceId: 'device-1',
+ });
+ mocks.setStatus.mockRejectedValueOnce(new Error('tunnel down'));
+ const { result } = renderHook(() =>
+ useSessionLifecycleActions({ includeArchived: 'active' }),
+ );
+
+ await act(async () => {
+ await result.current.runSessionAction('remote-session', 'archive', {
+ activeSessionId: null,
+ });
+ });
+
+ expect(mocks.rollbackPendingStatus).toHaveBeenCalledWith({
+ deviceId: 'device-1',
+ sessionId: 'remote-session',
+ status: 'archived',
+ });
+ expect(mocks.completePendingStatus).not.toHaveBeenCalled();
+ expect(mocks.purgeSession).not.toHaveBeenCalled();
+ expect(mocks.toastError).toHaveBeenCalledWith('ccAgent.sidebar.archiveFailed');
+ expect(mocks.logWarn).toHaveBeenCalledWith(
+ 'archive timing',
+ expect.objectContaining({ outcome: 'failed', deviceLink: true }),
+ );
+ });
+
+ it('reuses a pre-begun remote archive without hiding or navigating twice', async () => {
+ mocks.resolveStatusWriteTarget.mockResolvedValue({
+ kind: 'device-link',
+ deviceId: 'device-1',
+ });
+ const { result } = renderHook(() =>
+ useSessionLifecycleActions({ includeArchived: 'active' }),
+ );
+
+ let token: unknown;
+ act(() => {
+ token = result.current.beginRemoteArchive('remote-session', 'device-1', 'remote-session');
+ });
+ // 预检之前:行已消失、视图已跳离。
+ expect(mocks.beginPendingStatus).toHaveBeenCalledTimes(1);
+ expect(mocks.beginPendingStatus.mock.invocationCallOrder[0]).toBeLessThan(
+ mocks.navigate.mock.invocationCallOrder[0],
+ );
+ expect(mocks.navigate).toHaveBeenCalledTimes(1);
+
+ await act(async () => {
+ await result.current.runSessionAction('remote-session', 'archive', {
+ activeSessionId: 'remote-session',
+ remoteArchiveToken: token as never,
+ });
+ });
+
+ expect(mocks.beginPendingStatus).toHaveBeenCalledTimes(1);
+ expect(mocks.navigate).toHaveBeenCalledTimes(1);
+ expect(mocks.completePendingStatus).toHaveBeenCalledWith(
+ token,
+ expect.objectContaining({ status: 'archived' }),
+ );
+ });
+
+ it('navigates before hiding a pre-begun remote row that stays in the all bucket', () => {
+ const { result } = renderHook(() => useSessionLifecycleActions({ includeArchived: 'all' }));
+
+ act(() => {
+ result.current.beginRemoteArchive('remote-session', 'device-1', 'remote-session');
+ });
+
+ expect(mocks.navigate.mock.invocationCallOrder[0]).toBeLessThan(
+ mocks.beginPendingStatus.mock.invocationCallOrder[0],
+ );
+ });
+
+ it('restores a pre-begun remote row when the caller cancels', () => {
+ const { result } = renderHook(() =>
+ useSessionLifecycleActions({ includeArchived: 'active' }),
+ );
+
+ act(() => {
+ const token = result.current.beginRemoteArchive('remote-session', 'device-1', null);
+ result.current.cancelRemoteArchive(token);
+ });
+
+ expect(mocks.rollbackPendingStatus).toHaveBeenCalledWith({
+ deviceId: 'device-1',
+ sessionId: 'remote-session',
+ status: 'archived',
+ });
+ expect(mocks.navigate).not.toHaveBeenCalled();
+ expect(mocks.setStatus).not.toHaveBeenCalled();
+ });
+
+ it('drops a pre-begun remote overlay when the write resolves to a local row', async () => {
+ mocks.resolveStatusWriteTarget.mockResolvedValueOnce({ kind: 'local' });
+ const { result } = renderHook(() =>
+ useSessionLifecycleActions({ includeArchived: 'active' }),
+ );
+ const token = { deviceId: 'device-1', sessionId: 'copied', status: 'archived' as const };
+
+ await act(async () => {
+ await result.current.runSessionAction('copied', 'archive', {
+ activeSessionId: null,
+ remoteArchiveToken: token,
+ });
+ });
+
+ expect(mocks.rollbackPendingStatus).toHaveBeenCalledWith(token);
+ expect(mocks.beginStatusTransition).toHaveBeenCalledWith('copied', {
+ status: 'archived',
+ pinnedAt: null,
+ });
+ expect(mocks.completePendingStatus).not.toHaveBeenCalled();
});
});
@@ -427,7 +641,7 @@ describe('useSessionLifecycleActions unarchive convergence', () => {
expect(mocks.toastError).toHaveBeenCalledWith('ccAgent.sidebar.unarchiveFailed');
});
- it('leaves device-link restore convergence to the remote mirror', async () => {
+ it('restores a device-link row optimistically and releases the archived tombstone', async () => {
mocks.resolveStatusWriteTarget.mockResolvedValueOnce({
kind: 'device-link',
deviceId: 'device-1',
@@ -440,13 +654,46 @@ describe('useSessionLifecycleActions unarchive convergence', () => {
await result.current.unarchiveSession('remote-session');
});
- expect(mocks.setStatus).toHaveBeenCalledWith('remote-session', 'active', {
+ const token = { deviceId: 'device-1', sessionId: 'remote-session', status: 'active' };
+ expect(mocks.beginPendingStatus).toHaveBeenCalledWith('device-1', 'remote-session', 'active');
+ expect(mocks.beginPendingStatus.mock.invocationCallOrder[0]).toBeLessThan(
+ mocks.setStatus.mock.invocationCallOrder[0],
+ );
+ expect(mocks.releaseRemoteArchivedTombstone).toHaveBeenCalledWith(
+ 'remote-session',
+ 'device-1',
+ );
+ expect(mocks.completePendingStatus).toHaveBeenCalledWith(
+ token,
+ expect.objectContaining({ id: 'remote-session', status: 'active' }),
+ );
+ expect(mocks.beginStatusTransition).not.toHaveBeenCalled();
+ expect(mocks.patchLocal).not.toHaveBeenCalled();
+ expect(mocks.refreshSessions).not.toHaveBeenCalled();
+ });
+
+ it('rolls a failed device-link restore back without releasing the tombstone', async () => {
+ mocks.resolveStatusWriteTarget.mockResolvedValueOnce({
kind: 'device-link',
deviceId: 'device-1',
});
- expect(mocks.beginStatusTransition).not.toHaveBeenCalled();
- expect(mocks.completeStatusTransition).not.toHaveBeenCalled();
- expect(mocks.patchLocal).not.toHaveBeenCalled();
+ mocks.setStatus.mockRejectedValueOnce(new Error('tunnel down'));
+ const { result } = renderHook(() =>
+ useSessionLifecycleActions({ includeArchived: 'archived' }),
+ );
+
+ await act(async () => {
+ await result.current.unarchiveSession('remote-session');
+ });
+
+ expect(mocks.rollbackPendingStatus).toHaveBeenCalledWith({
+ deviceId: 'device-1',
+ sessionId: 'remote-session',
+ status: 'active',
+ });
+ expect(mocks.releaseRemoteArchivedTombstone).not.toHaveBeenCalled();
+ expect(mocks.completePendingStatus).not.toHaveBeenCalled();
expect(mocks.refreshSessions).not.toHaveBeenCalled();
+ expect(mocks.toastError).toHaveBeenCalledWith('ccAgent.sidebar.unarchiveFailed');
});
});
diff --git a/apps/desktop/src/renderer/features/cc-agent/hooks/useSessionLifecycleActions.ts b/apps/desktop/src/renderer/features/cc-agent/hooks/useSessionLifecycleActions.ts
index 2dbe21ea38..6c050314fa 100644
--- a/apps/desktop/src/renderer/features/cc-agent/hooks/useSessionLifecycleActions.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/hooks/useSessionLifecycleActions.ts
@@ -14,6 +14,12 @@
* activeSessionId 由调用方传入:sidebar 是当前路由解析出的活跃会话(可能
* 操作非活跃行);header 操作的恒为当前打开的会话(传 session.id 即可)。
*
+ * 远程(device-link)任务的归档 / 恢复走 remoteProjectsStore 的状态迁移叠加层,与本机
+ * sessionsStore 状态事务对称:行当帧换桶,写库成功后落被控端返回的行,失败回滚。
+ * 远程归档的 worktree 预检是一次完整隧道往返,调用方可先 `beginRemoteArchive`
+ * (行消失 + 跳离)再等预检,确认后把凭据经 `remoteArchiveToken` 交回 runSessionAction
+ * 复用;取消则 `cancelRemoteArchive` 让行回来(不跳回原任务)。
+ *
* includeArchived 必须与调用方自己的 useCCSessions 桶一致:unarchive 的 refreshSessions
* 只刷当前桶,sidebar 处于 archived / all 桶时删除行后若刷的是默认 active
* 桶,已删行会在当前列表残留(Codex review P2)。header 始终展示 active
@@ -32,12 +38,41 @@ import { discardDraft as discardComposerDraft } from '@/lib/composerDraftStore';
import { cleanupSessionLayoutPrefs } from '@/lib/sessionLayoutPrefs';
import { sessionsStore, type SessionStatusTransitionToken } from '@/lib/sessionsStore';
import { useCCSessions } from '@/hooks/useCCSessions';
+import {
+ remoteProjectsStore,
+ type RemotePendingStatusToken,
+} from '@/features/device-link/remoteProjectsStore';
import { createLogger } from '@/lib/logger';
import type { ListStatusFilter } from '@/lib/sessionService';
import type { Session, SessionStatus } from '@/lib/ccAgent.types';
const log = createLogger('useSessionLifecycleActions');
+/**
+ * 远程任务的状态写按会话串行发出(对齐本机 beginStatusTransitionWhenReady、手机
+ * sessionMetaWriteQueue):叠加层当帧切换,用户可在「全部」筛选里归档后立刻恢复;两次
+ * patch-meta 可能走不同链路(直连 / 中继)逆序到达被控端,较早的意图会最后落库。
+ * 前一笔结算(成功或失败)后才发下一笔,被控端按用户操作顺序落库。
+ */
+const remoteStatusWrites = new Map<string, Promise<Session>>();
+
+function setStatusInOrder(
+ sessionId: string,
+ status: SessionStatus,
+ target: Awaited<ReturnType<typeof sessionService.resolveStatusWriteTarget>>,
+): Promise<Session> {
+ const write = () => sessionService.setStatus(sessionId, status, target);
+ if (target.kind !== 'device-link') return write();
+ const previous = remoteStatusWrites.get(sessionId);
+ const next = previous ? previous.then(write, write) : write();
+ remoteStatusWrites.set(sessionId, next);
+ const release = () => {
+ if (remoteStatusWrites.get(sessionId) === next) remoteStatusWrites.delete(sessionId);
+ };
+ next.then(release, release);
+ return next;
+}
+
export interface RunSessionActionOptions {
/** 当前活跃会话 id —— 决定 archive / delete 后是否需要跳走。 */
activeSessionId: string | null | undefined;
@@ -46,6 +81,11 @@ export interface RunSessionActionOptions {
* "下一条 / 上一条 / 新建";没有列表上下文的入口继续回落到 /cc-agent。
*/
deleteRedirectRoute?: string | null;
+ /**
+ * 调用方已用 beginRemoteArchive 提前隐藏远程任务(并已跳离)时交回的凭据:
+ * 归档沿用同一叠加层直接写库,不再重复 begin / 跳转,避免行闪烁。
+ */
+ remoteArchiveToken?: RemotePendingStatusToken | null;
}
export function useSessionLifecycleActions(options?: { includeArchived?: ListStatusFilter }) {
@@ -60,6 +100,37 @@ export function useSessionLifecycleActions(options?: { includeArchived?: ListSta
// (行渲染隔离不变量,见 SessionItem.tsx)。
const listFilter: ListStatusFilter = options?.includeArchived ?? 'active';
+ /**
+ * 远程任务归档的乐观起点:叠加层把行移出 active 桶,并按 runSessionAction 同一顺序
+ * 跳离(行留在列表时先跳再换桶,否则先换桶再跳,理由见下方 archive 段注释)。
+ * 返回的凭据由调用方交给 runSessionAction(remoteArchiveToken)或 cancelRemoteArchive。
+ */
+ const beginRemoteArchive = useCallback(
+ (
+ sessionId: string,
+ deviceId: string,
+ activeSessionId: string | null | undefined,
+ ): RemotePendingStatusToken => {
+ const archivedRowStaysInList = listFilter === 'all';
+ const leaveArchivedSession = () => {
+ if (sessionId === activeSessionId) navigate('/cc-agent/new');
+ };
+ if (archivedRowStaysInList) flushSync(leaveArchivedSession);
+ let token!: RemotePendingStatusToken;
+ flushSync(() => {
+ token = remoteProjectsStore.beginPendingStatus(deviceId, sessionId, 'archived');
+ });
+ if (!archivedRowStaysInList) leaveArchivedSession();
+ return token;
+ },
+ [navigate, listFilter],
+ );
+
+ /** 用户取消 / 前置条件失败:撤掉提前隐藏,行回到列表。已跳离的视图不跳回。 */
+ const cancelRemoteArchive = useCallback((token: RemotePendingStatusToken) => {
+ remoteProjectsStore.rollbackPendingStatus(token);
+ }, []);
+
/**
* archive / delete 实际执行序列。不关心确认弹窗的开合状态——由调用方负责。
*/
@@ -67,17 +138,37 @@ export function useSessionLifecycleActions(options?: { includeArchived?: ListSta
async (
sessionId: string,
action: 'delete' | 'archive',
- { activeSessionId, deleteRedirectRoute }: RunSessionActionOptions,
+ { activeSessionId, deleteRedirectRoute, remoteArchiveToken }: RunSessionActionOptions,
) => {
const actionStartedAt = performance.now();
const targetStatus: SessionStatus = action === 'delete' ? 'deleted' : 'archived';
const statusWriteTarget = await sessionService.resolveStatusWriteTarget(sessionId);
const isDeviceLinkSession = statusWriteTarget.kind === 'device-link';
+ // 预先隐藏的远程归档在等预检 / 确认期间已被更新的操作取代(「全部」筛选里行仍可见,
+ // 用户可能已点了恢复):以最后一次操作为准,这次过时的归档不再写库。检查放在最后一个
+ // await 之后,从这里到 setStatusInOrder 入队全程同步,恢复插不进来。
+ if (
+ remoteArchiveToken &&
+ isDeviceLinkSession &&
+ !remoteProjectsStore.isPendingStatusCurrent(remoteArchiveToken)
+ ) {
+ return;
+ }
let statusTransition: SessionStatusTransitionToken | null = null;
- // device-link 远程会话:status 写经隧道(setStatus 内部按来源路由 patch-meta),被控端写库后
- // 广播 sessions:patched{status} → 控制端 applyPatch 把它移出分片(纯镜像,无需乐观/重拉)。
+ // device-link 远程会话:status 写经隧道(setStatus 内部按来源路由 patch-meta)。归档走
+ // remoteProjectsStore 的状态迁移叠加层乐观换桶,写库成功即落被控端返回的行,不等
+ // sessions:patched 回流。
+ let remoteStatus: RemotePendingStatusToken | null = null;
+ if (remoteArchiveToken && !isDeviceLinkSession) {
+ // 远程 id 撞上本机行(该设备已停用控制)时改走本机状态桶,提前登记的远程叠加层作废。
+ remoteProjectsStore.rollbackPendingStatus(remoteArchiveToken);
+ }
- if (action === 'archive') {
+ if (action === 'archive' && isDeviceLinkSession) {
+ remoteStatus =
+ remoteArchiveToken ??
+ beginRemoteArchive(sessionId, statusWriteTarget.deviceId, activeSessionId);
+ } else if (action === 'archive') {
// 乐观更新的顺序取决于**被归档的行还会不会留在当前列表里**,两种情况相反:
//
// · 会留下(调用方在 'all' 桶):patchLocal 只是把它重排到归档段,行还在。
@@ -108,23 +199,21 @@ export function useSessionLifecycleActions(options?: { includeArchived?: ListSta
if (archivedRowStaysInList) {
flushSync(leaveArchivedSession);
}
- if (!isDeviceLinkSession) {
- statusTransition = await sessionsStore.beginStatusTransitionWhenReady(
- sessionId,
- {
- status: 'archived',
- pinnedAt: null,
- },
- (begin) => {
- let transition: SessionStatusTransitionToken | null = null;
- flushSync(() => {
- transition = begin();
- });
- return transition;
- },
- );
- if (!statusTransition) return;
- }
+ statusTransition = await sessionsStore.beginStatusTransitionWhenReady(
+ sessionId,
+ {
+ status: 'archived',
+ pinnedAt: null,
+ },
+ (begin) => {
+ let transition: SessionStatusTransitionToken | null = null;
+ flushSync(() => {
+ transition = begin();
+ });
+ return transition;
+ },
+ );
+ if (!statusTransition) return;
if (!archivedRowStaysInList) {
leaveArchivedSession();
}
@@ -140,14 +229,16 @@ export function useSessionLifecycleActions(options?: { includeArchived?: ListSta
try {
// setStatus 按来源路由(远程走隧道 set-status,本机走原 update);archive 时
// handler 内部一并 unpin —— 归档列表里不该再保留 pin 标记。
- persisted = await sessionService.setStatus(sessionId, targetStatus, statusWriteTarget);
+ persisted = await setStatusInOrder(sessionId, targetStatus, statusWriteTarget);
statusWriteFinishedAt = performance.now();
if (statusTransition) {
sessionsStore.completeStatusTransition(statusTransition, persisted);
}
+ if (remoteStatus) remoteProjectsStore.completePendingStatus(remoteStatus, persisted);
} catch (err) {
log.error('[session action]', err);
if (statusTransition) sessionsStore.rollbackStatusTransition(statusTransition);
+ if (remoteStatus) remoteProjectsStore.rollbackPendingStatus(remoteStatus);
if (action === 'archive') {
const failedAt = performance.now();
log.warn('archive timing', {
@@ -209,8 +300,9 @@ export function useSessionLifecycleActions(options?: { includeArchived?: ListSta
// sessionsStore 已用任一缓存桶中的完整 row 同步迁移 active / archived / all;
// 完全找不到 row 时也只合并补查目标桶。这里不再发全局 refresh,避免连续归档
// 把每次状态写放大成所有已加载桶的一轮 fresh 查询。
- // 远程会话从侧边栏消失由被控端 sessions:patched{status} 回流(applyPatch 移出分片)驱动,
- // 控制端不再主动重拉 / 不再埋「主动移除」标记(掉线 vs 删除的区分见 CCAgentSessionView 优雅退出)。
+ // 远程归档已由叠加层换桶并落了写库返回的行;远程删除仍由被控端 sessions:patched{status}
+ // 回流(applyPatch 移出分片)驱动,控制端不主动重拉 / 不埋「主动移除」标记(掉线 vs 删除的
+ // 区分见 CCAgentSessionView 优雅退出)。
// Archive 已在前面乐观跳到 /cc-agent/new,这里只处理 delete。调用方有列表
// 上下文时会传入按当前可见顺序解析好的 route;否则回落到 /cc-agent
@@ -219,12 +311,13 @@ export function useSessionLifecycleActions(options?: { includeArchived?: ListSta
navigate(deleteRedirectRoute ?? '/cc-agent');
}
},
- [navigate, patchLocal, listFilter, t],
+ [navigate, patchLocal, listFilter, beginRemoteArchive, t],
);
/**
* unarchive:archive 的反向状态事务,不弹确认。若归档仍在写库,先等它收敛,
- * 再以完整归档行作为恢复失败时的回滚基线。
+ * 再以完整归档行作为恢复失败时的回滚基线。远程任务同样乐观换桶(叠加层),
+ * 写库成功后释放归档墓碑,被控端后续 patch 不再被丢弃、也不必等 reseed。
*/
const unarchiveSession = useCallback(
async (sessionId: string) => {
@@ -234,14 +327,22 @@ export function useSessionLifecycleActions(options?: { includeArchived?: ListSta
? null
: await sessionsStore.beginStatusTransitionWhenReady(sessionId, { status: 'active' });
if (!isDeviceLinkSession && !statusTransition) return;
+ const remoteStatus = isDeviceLinkSession
+ ? remoteProjectsStore.beginPendingStatus(statusWriteTarget.deviceId, sessionId, 'active')
+ : null;
try {
- const persisted = await sessionService.setStatus(sessionId, 'active', statusWriteTarget);
+ const persisted = await setStatusInOrder(sessionId, 'active', statusWriteTarget);
if (statusTransition) {
sessionsStore.completeStatusTransition(statusTransition, persisted);
}
+ if (remoteStatus) {
+ makerChatStore.releaseRemoteArchivedTombstone(sessionId, remoteStatus.deviceId);
+ remoteProjectsStore.completePendingStatus(remoteStatus, persisted);
+ }
} catch (err) {
log.error('[session unarchive]', err);
if (statusTransition) sessionsStore.rollbackStatusTransition(statusTransition);
+ if (remoteStatus) remoteProjectsStore.rollbackPendingStatus(remoteStatus);
toast.error(t('ccAgent.sidebar.unarchiveFailed'));
if (!statusTransition && !isDeviceLinkSession) await refreshSessions();
return;
@@ -250,5 +351,5 @@ export function useSessionLifecycleActions(options?: { includeArchived?: ListSta
[refreshSessions, t],
);
- return { runSessionAction, unarchiveSession };
+ return { runSessionAction, unarchiveSession, beginRemoteArchive, cancelRemoteArchive };
}
diff --git a/apps/desktop/src/renderer/features/cc-agent/lib/sessionHardwareTaskActions.ts b/apps/desktop/src/renderer/features/cc-agent/lib/sessionHardwareTaskActions.ts
index 2e65ffb8ab..21b00b2b8c 100644
--- a/apps/desktop/src/renderer/features/cc-agent/lib/sessionHardwareTaskActions.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/lib/sessionHardwareTaskActions.ts
@@ -29,7 +29,8 @@ export function useSessionHardwareTaskActions({
} {
const { t } = useTranslation();
const { confirm: confirmDialog } = useConfirmDialog();
- const { runSessionAction } = useSessionLifecycleActions();
+ const { runSessionAction, beginRemoteArchive, cancelRemoteArchive } =
+ useSessionLifecycleActions();
const { runningSessionIds } = useSessionRunningStatus(session?.id);
const sessionId = session?.id ?? null;
const pinnedAt = session?.pinnedAt ?? null;
@@ -74,6 +75,10 @@ export function useSessionHardwareTaskActions({
toast.warning(t('ccAgent.sidebar.archiveBlocked.attached'));
return;
}
+ // 远程任务先乐观隐藏行并跳离,再等隧道预检(与 sidebar handleActionClick 同口径)。
+ const remoteArchiveToken = deviceLinkDeviceId
+ ? beginRemoteArchive(sessionId, deviceLinkDeviceId, sessionId)
+ : null;
const preflight = await resolveWorktreeRemovalPreflight(sessionId, deviceLinkDeviceId);
if (preflight !== 'clean') {
const ok = await confirmDialog({
@@ -86,10 +91,15 @@ export function useSessionHardwareTaskActions({
confirmText: t('ccAgent.sidebar.confirmArchive.confirm'),
cancelText: t('ccAgent.sidebar.confirmArchive.cancel'),
});
- if (!ok) return;
+ if (!ok) {
+ if (remoteArchiveToken) cancelRemoteArchive(remoteArchiveToken);
+ return;
+ }
}
- await runSessionAction(sessionId, 'archive', { activeSessionId: sessionId });
+ await runSessionAction(sessionId, 'archive', { activeSessionId: sessionId, remoteArchiveToken });
}, [
+ beginRemoteArchive,
+ cancelRemoteArchive,
confirmDialog,
deviceLinkDeviceId,
onRemoteWriteBlocked,
diff --git a/apps/desktop/src/renderer/features/device-link/remoteProjectsStore.ts b/apps/desktop/src/renderer/features/device-link/remoteProjectsStore.ts
index 74ed3cea77..e9377b065a 100644
--- a/apps/desktop/src/renderer/features/device-link/remoteProjectsStore.ts
+++ b/apps/desktop/src/renderer/features/device-link/remoteProjectsStore.ts
@@ -17,10 +17,11 @@ import { normalizeTaskTags, reconcileTaskTags } from '@cindy/maker-shared';
* · 增量(`applyPatch`):收到被控端 `local-db:sessions:patched` push 时就地幂等合并;
* status=deleted → 移出分片;active/archived → 在状态桶间迁移。
* · 新建(`requestRemoteReseed`):`sessions:created` push 无 row 数据 → 触发该设备重拉。
- * 唯一例外是**投影层**的两个叠加层:标题预览(`setPendingTitlePreview`)只在权威
+ * 唯一例外是**投影层**的三个叠加层:标题预览(`setPendingTitlePreview`)只在权威
* 标题仍是系统占位(默认名 / fork 占位 / 本端登记过的合成占位)时顶替显示;首条发送
* 时刻(`setPendingFirstSend`)只在权威 userSendAt 仍为空时补上。被控端写下真实值
- * 一到就自动让位。分片数据仍是纯镜像。
+ * 一到就自动让位。归档 / 恢复(`beginPendingStatus`)在写库往返期间先把行换桶,
+ * 失败回滚、成功后由写库之后的新列表确认让位。分片数据仍是纯镜像。
* - **复用本地渲染管线**:每条 session 注入 `deviceLinkDeviceId/Name/ConnectionStatus`
* 后喂给 `groupSessions`。
* - **origin 注册表**:`sessionId → deviceId`(`getSessionDeviceId`),供传输层 / SessionView 用。
@@ -360,6 +361,84 @@ function dropSessionOverlays(sessionId: string): void {
pendingFirstSendAt.delete(sessionId);
}
+/**
+ * 一次远程归档 / 恢复的乐观状态迁移凭据(按对象身份比较,调用方只透传)。
+ * 同一任务以最后一次 begin 为准,被取代的旧凭据 complete / rollback 一律 no-op。
+ */
+export interface RemotePendingStatusToken {
+ readonly deviceId: string;
+ readonly sessionId: string;
+ readonly status: RemoteSessionStatus;
+}
+
+interface PendingStatusEntry {
+ token: RemotePendingStatusToken;
+ /**
+ * 写库成功那一刻两个状态桶的 snapshot epoch;null = 写库仍在途。
+ * 只有 epoch 大于栅栏的列表(写库确认之后才发出的 sessions:list)落地,才算权威确认。
+ */
+ fence: Record<RemoteSessionStatus, number> | null;
+ /** 已容忍过一份内容对不上的写库后列表(可能是被控端合并进写库前查询的旧结果)。 */
+ toleratedMismatch: boolean;
+}
+
+/**
+ * 「状态迁移中」叠加层 —— 远程任务归档 / 恢复的乐观投影,与标题预览同一性质,**不写分片**。
+ *
+ * 远程归档要等 patch-meta 往返 + 被控端 `sessions:patched` 回流,行才会离开 active 桶;
+ * 本机任务早已靠 sessionsStore 的状态事务即时迁移。这里在投影层先把 status 顶成目标值,
+ * 行当帧换桶;分片里的权威行一个字节不动。
+ *
+ * 生命周期:
+ * - begin:登记叠加层(同一任务后来者覆盖先来者);
+ * - rollback:写库失败 / 用户取消 → 撤掉,行照权威数据回到原位;
+ * - complete:写库成功 → 用被控端返回的行就地 applyPatch(不等 push 回流),叠加层
+ * **继续保留**到写库确认后才发出的列表(epoch 栅栏)落地为止。写库前已在途的列表
+ * (含 10s 周期对账)被栅栏挡住;写库后的列表还可能被被控端并进写库前的查询、带着
+ * 旧值回来 —— 内容(行在目标桶 / 不在另一桶)对不上的**第一份**容忍一次,之后的
+ * 写库后列表无论内容一律让位:被控端状态写不推进 updatedAt,分不清「合并的旧结果」
+ * 和「另一控制端随后又改了」,只容忍一次才不会把后者永远顶住。
+ * 不让在途列表 superseded,是为了不连带打断 bootstrap / 归档桶按需读取的收尾。
+ * - 状态 push 同样分不清迟到的旧推送和之后的新改动,一律不撤叠加层,交给上面的列表
+ * 判定;只有 status=deleted、设备移除、整体清空立即回收。
+ */
+const pendingStatuses = new Map<string, PendingStatusEntry>();
+
+function withPendingStatus(session: Session, deviceId: string): Session {
+ const entry = pendingStatuses.get(session.id);
+ if (!entry || entry.token.deviceId !== deviceId) return session;
+ const { status } = entry.token;
+ // 归档一并 unpin(与被控端写库、本机 sessionsStore 乐观补丁同口径)。
+ const unpin = status === 'archived' && session.pinnedAt != null;
+ if (session.status === status && !unpin) return session;
+ return { ...session, status, ...(unpin ? { pinnedAt: null } : {}) };
+}
+
+/**
+ * 该设备该状态桶的列表落地时,撤掉被它确认过的叠加层:必须是写库后才发出的列表(epoch
+ * 越过栅栏);内容与写库结果对不上的第一份容忍一次(见 {@link pendingStatuses})。
+ */
+function settlePendingStatuses(
+ deviceId: string,
+ status: RemoteSessionStatus,
+ incoming: readonly Session[],
+): boolean {
+ if (pendingStatuses.size === 0) return false;
+ const epoch = snapshotEpoch.get(snapshotEpochKey(deviceId, status)) ?? 0;
+ let settled = false;
+ for (const [sessionId, entry] of pendingStatuses) {
+ if (entry.token.deviceId !== deviceId || !entry.fence || epoch <= entry.fence[status]) continue;
+ const listed = incoming.some((session) => session.id === sessionId);
+ if (listed !== (status === entry.token.status) && !entry.toleratedMismatch) {
+ entry.toleratedMismatch = true;
+ continue;
+ }
+ pendingStatuses.delete(sessionId);
+ settled = true;
+ }
+ return settled;
+}
+
/** 重算扁平快照 + origin 注册表,然后通知订阅者。所有 mutation 走这里。 */
function recompute(): void {
recomputeScheduleIndex();
@@ -374,7 +453,10 @@ function recompute(): void {
const flat: Session[] = [];
for (const shard of shards.values()) {
for (const s of shard.sessions) {
- const projected = withPendingFirstSend(withPendingTitle(s));
+ const projected = withPendingStatus(
+ withPendingFirstSend(withPendingTitle(s)),
+ shard.deviceId,
+ );
flat.push(projected);
sessionDeviceIndex.set(s.id, shard.deviceId);
if (projected.title) sessionTitleIndex.set(s.id, projected.title);
@@ -508,6 +590,8 @@ const actions = {
const failedStateCleared =
status === 'active' ? false : setSessionStatusFailed(deviceId, 'archived', false);
const statusWasLoaded = existing?.loadedStatuses.has(status) ?? false;
+ // 写库确认之后才发出的列表(epoch 越过栅栏)落地 = 状态迁移叠加层的权威确认。
+ const pendingStatusSettled = settlePendingStatuses(deviceId, status, stamped);
const incomingIds = new Set(stamped.map((session) => session.id));
const preserved =
existing?.sessions
@@ -536,7 +620,9 @@ const actions = {
existing.loadedStatuses.add(status);
recomputeArchivedLoadedDeviceIds();
}
- if (loadingStateCleared || failedStateCleared || !statusWasLoaded) {
+ if (pendingStatusSettled) {
+ recompute();
+ } else if (loadingStateCleared || failedStateCleared || !statusWasLoaded) {
subs.forEach((fn) => fn());
}
return;
@@ -707,6 +793,11 @@ const actions = {
// 「别的控制端刚删掉的会话」的正文一直留在盘上,直到 LRU 逐出 / 设备移除 / 登出
// (review: codex P1)。归档仍可从 Archived / All 打开,必须保留缓存供离线查看。
if (deleted) clearCachedMessages(deviceId, sessionId);
+ // 状态迁移叠加层:删除一律让位。active / archived 推送不带 updatedAt,可能是写库前
+ // 迟到的旧推送,不动叠加层,交给写库后的列表按内容确认(见 pendingStatuses)。
+ if (deleted && pendingStatuses.get(sessionId)?.token.deviceId === deviceId) {
+ pendingStatuses.delete(sessionId);
+ }
const shard = shards.get(deviceId);
if (!shard) return;
const idx = shard.sessions.findIndex((s) => s.id === sessionId);
@@ -849,6 +940,10 @@ const actions = {
for (const session of shards.get(deviceId)?.sessions ?? []) {
dropSessionOverlays(session.id);
}
+ // 状态迁移叠加层按设备回收(行可能已不在分片里);在途写库之后的 complete / rollback 随之 no-op。
+ for (const [sessionId, entry] of pendingStatuses) {
+ if (entry.token.deviceId === deviceId) pendingStatuses.delete(sessionId);
+ }
const shardDeleted = shards.delete(deviceId);
const bootstrapStateCleared = setBootstrapState(deviceId, 'idle');
const archivedLoadingCleared = setSessionStatusLoading(deviceId, 'archived', false);
@@ -871,6 +966,7 @@ const actions = {
landedSystemTitles.clear();
synthesizedPreviewSessions.clear();
pendingFirstSendAt.clear();
+ pendingStatuses.clear();
const bootstrapStateChanged =
bootstrapLoadingDeviceIds.size > 0 ||
archivedLoadingDeviceIds.size > 0 ||
@@ -959,12 +1055,67 @@ const actions = {
recompute();
},
- /** 测试专用:清空标题预览与首条发送叠加层。 */
+ /**
+ * 远程归档 / 恢复的乐观起点(见 {@link pendingStatuses}):投影层立即换桶,分片不动。
+ * 同一任务再次 begin 会取代前一次;返回的凭据交给 complete / rollback 收尾。
+ */
+ beginPendingStatus(
+ deviceId: string,
+ sessionId: string,
+ status: RemoteSessionStatus,
+ ): RemotePendingStatusToken {
+ const token: RemotePendingStatusToken = { deviceId, sessionId, status };
+ pendingStatuses.set(sessionId, { token, fence: null, toleratedMismatch: false });
+ recompute();
+ return token;
+ },
+
+ /**
+ * 写库成功:用被控端返回的行(status / pinnedAt / updatedAt)就地落进分片,不等
+ * `sessions:patched` 回流;叠加层留到写库后的新列表确认为止。凭据已被取代 / 设备
+ * 已移除时 no-op —— 旧写库的结果不能盖过更新的一次迁移,权威值交给 push 回流。
+ */
+ completePendingStatus(
+ token: RemotePendingStatusToken,
+ persisted?: Partial<Session> | null,
+ ): boolean {
+ const entry = pendingStatuses.get(token.sessionId);
+ if (entry?.token !== token) return false;
+ entry.fence = {
+ active: snapshotEpoch.get(snapshotEpochKey(token.deviceId, 'active')) ?? 0,
+ archived: snapshotEpoch.get(snapshotEpochKey(token.deviceId, 'archived')) ?? 0,
+ };
+ const patch: Record<string, unknown> = { status: token.status };
+ if (persisted && Object.prototype.hasOwnProperty.call(persisted, 'pinnedAt')) {
+ patch.pinnedAt = persisted.pinnedAt ?? null;
+ } else if (token.status === 'archived') {
+ patch.pinnedAt = null;
+ }
+ if (typeof persisted?.updatedAt === 'string') patch.updatedAt = persisted.updatedAt;
+ actions.applyPatch(token.deviceId, token.sessionId, patch);
+ return true;
+ },
+
+ /** 凭据仍是该任务最新的一次迁移(未被后来的 begin 取代、未被删除 / 设备移除回收)。 */
+ isPendingStatusCurrent(token: RemotePendingStatusToken): boolean {
+ return pendingStatuses.get(token.sessionId)?.token === token;
+ },
+
+ /** 写库失败 / 用户取消:撤掉叠加层,行回到权威位置。凭据已被取代时 no-op。 */
+ rollbackPendingStatus(token: RemotePendingStatusToken): boolean {
+ if (pendingStatuses.get(token.sessionId)?.token !== token) return false;
+ pendingStatuses.delete(token.sessionId);
+ recompute();
+ return true;
+ },
+
+ /** 测试专用:清空标题预览、首条发送与状态迁移叠加层。 */
__resetPendingTitlePreviewForTest(): void {
pendingTitlePreview.clear();
landedSystemTitles.clear();
synthesizedPreviewSessions.clear();
pendingFirstSendAt.clear();
+ pendingStatuses.clear();
},
/** 测试专用:清空 origin 钉子(生产期刻意不清,见 pinnedOrigins)。 */
diff --git a/apps/desktop/src/renderer/lib/makerChatStore.ts b/apps/desktop/src/renderer/lib/makerChatStore.ts
index 416e460185..1a9310ded1 100644
--- a/apps/desktop/src/renderer/lib/makerChatStore.ts
+++ b/apps/desktop/src/renderer/lib/makerChatStore.ts
@@ -290,23 +290,38 @@ function isRemoteDeletedSessionSendBlocked(sessionId: string): boolean {
* session row from a fresh remote snapshot can release that tombstone; an
* out-of-order `status: active` patch is intentionally ignored and merely
* requests a reseed through remoteProjectsStore.
+ *
+ * 读分片里的权威行,不读投影:恢复写库仍在途时,乐观叠加层已把行投影成 active,
+ * 写库失败回滚后墓碑却已经没了。
*/
function releaseArchivedRemoteTerminalTombstones(): void {
if (remoteTerminalSessionTombstones.size === 0) return;
- const activeSessions = remoteProjectsStore.getMergedRemoteSessions();
for (const [sessionId, tombstone] of remoteTerminalSessionTombstones) {
if (tombstone.status !== 'archived') continue;
- const active = activeSessions.some(
- (session) =>
- session.id === sessionId &&
- session.deviceLinkDeviceId === tombstone.deviceId &&
- session.status !== 'archived' &&
- session.status !== 'deleted',
- );
+ const active = remoteProjectsStore
+ .getDeviceSessions(tombstone.deviceId)
+ .some(
+ (session) =>
+ session.id === sessionId &&
+ session.status !== 'archived' &&
+ session.status !== 'deleted',
+ );
if (active) remoteTerminalSessionTombstones.delete(sessionId);
}
}
+/**
+ * 本端发起的远程恢复(unarchive)写库已成功:被控端已确认任务回到 active,直接释放
+ * 归档墓碑,后续 patch / 消息帧不再被丢弃,也不必等一次 reseed 快照来解除。
+ * 删除墓碑不可逆,不在此列。
+ */
+function releaseRemoteArchivedTombstone(sessionId: string, deviceId: string): void {
+ const tombstone = remoteTerminalSessionTombstones.get(sessionId);
+ if (tombstone?.status === 'archived' && tombstone.deviceId === deviceId) {
+ remoteTerminalSessionTombstones.delete(sessionId);
+ }
+}
+
function resolveEstimatedTurnCostUsd(
rawCostUsd: number,
turnCostIsEstimate: boolean,
@@ -17481,6 +17496,8 @@ export const makerChatStore = {
* listeners, and any cached base64 images are garbage-collected.
*/
purgeSession: _purgeSession,
+ /** 远程恢复写库成功后释放归档墓碑(见函数注释)。 */
+ releaseRemoteArchivedTombstone,
/** Seed runtime-only state before a session view has mounted and loaded DB metadata. */
setSessionRuntime,
noteAgentSwitched,
diff --git a/apps/mobile/app/sessions/[sessionId].tsx b/apps/mobile/app/sessions/[sessionId].tsx
index 71b3b382a8..027081b9f5 100644
--- a/apps/mobile/app/sessions/[sessionId].tsx
+++ b/apps/mobile/app/sessions/[sessionId].tsx
@@ -598,6 +598,7 @@ import { compactSessionMessageLabel, mobileSessionMessageDisplayText } from '@/s
import { copyMessageText } from '@/session/messageActions';
import {
remoteSessionStore,
+ resolveSessionWriteDevices,
sessionMetaWriteGuard,
sessionMetaWriteQueue,
sessionPendingWrites,
@@ -8609,6 +8610,10 @@ export default function SessionScreen() {
) => {
const session = currentSession;
if (!deviceId || !session) return;
+ // 出网沿用本页路由设备;乐观 patch / 回滚 / reseed 落行真实所在的物理 shard(与首页
+ // 同一解析):re-link 后两者可能不同,按路由 id 落 shard 会让归档移行落空、回滚插错 shard。
+ const { rpcDeviceId, shardId } = resolveSessionWriteDevices(sessionId, session, deviceId)
+ ?? { rpcDeviceId: deviceId, shardId: deviceId };
if (patch.status === 'archived' || patch.status === 'deleted') {
goBackToHome();
}
@@ -8618,7 +8623,7 @@ export default function SessionScreen() {
// pickWriteFields 字段级对账/回滚。
const fields = Object.keys(patch);
const write = sessionMetaWriteGuard.begin(sessionId, writeGuardFields(patch));
- remoteSessionStore.applySessionPatch(deviceId, sessionId, patch as Partial<RemoteSession>);
+ remoteSessionStore.applySessionPatch(shardId, sessionId, patch as Partial<RemoteSession>);
// 在途登记 + 共享队列:本页写同样遮蔽 push 回流 / 全量对账,并与首页写同字段串行。
const releasePending = sessionPendingWrites.track(sessionId, fields);
void (async () => {
@@ -8628,7 +8633,7 @@ export default function SessionScreen() {
// preSend:重连等待(最长 1.5s)之后、真正出网之前再查一次让位——本页同
// 字段连续两次操作时,前笔在等待中被取代不得再发出(review P2)。
(assertStillLatest) => invoke<RemoteSession>(
- deviceId,
+ rpcDeviceId,
'local-db:sessions:patch-meta',
[sessionId, patch],
{ preSend: assertStillLatest },
@@ -8640,33 +8645,35 @@ export default function SessionScreen() {
const currentUpdatedAt = remoteSessionStore.getSessions()
.find((s) => s.id === sessionId)?.updatedAt ?? null;
remoteSessionStore.applySessionPatch(
- deviceId,
+ shardId,
sessionId,
pickWriteFields(updated, fields, currentUpdatedAt),
);
// 与首页成功分支同口径(review P1):在途期间被遮的同字段外部更新可能晚于
// 本机写落库——回包是旧值,命中遮蔽留痕即 reseed 收敛。
if (sessionPendingWrites.consumeMaskedPush(sessionId, fields)) {
- remoteSessionStore.requestReseed(deviceId);
+ remoteSessionStore.requestReseed(shardId);
}
}
} catch (err) {
if (write.isLatest()) {
if (fields.includes('status')) {
// 归档/删除/恢复失败:行可能已被移出列表,反向 patch 复活不了,整对象
- // 插回。回滚设备名优先取 shard 当前值(同首页 review P2 教训):用旧
- // stamp 会把整台设备改名。
+ // 插回原物理 shard。回滚设备名优先取 shard 当前值(同首页 review P2 教训):
+ // 用旧 stamp 会把整台设备改名。先释放本笔在途登记:upsertDeviceSession
+ // 会挡掉 status 在途、已被乐观移出的行。
+ releasePending();
const shardName = remoteSessionStore.getSessions()
- .find((s) => s.deviceLinkDeviceId === deviceId)?.deviceLinkDeviceName
+ .find((s) => s.deviceLinkDeviceId === shardId)?.deviceLinkDeviceName
?? session.deviceLinkDeviceName
- ?? deviceId;
- remoteSessionStore.upsertDeviceSession(deviceId, shardName, session);
+ ?? shardId;
+ remoteSessionStore.upsertDeviceSession(shardId, shardName, session);
} else {
// 置顶/重命名失败:只还原本笔字段,不整对象覆盖其它字段的并发写。
const currentUpdatedAt = remoteSessionStore.getSessions()
.find((s) => s.id === sessionId)?.updatedAt ?? null;
remoteSessionStore.applySessionPatch(
- deviceId,
+ shardId,
sessionId,
pickWriteFields(session, fields, currentUpdatedAt),
);
@@ -8674,7 +8681,7 @@ export default function SessionScreen() {
}
// 无论是否最新写都 reseed:回滚可能吞并行结果 / 被遮的外部值 / 被让位前笔
// 污染的快照值(与首页失败分支同口径);离线时 reseed 失败无害。
- remoteSessionStore.requestReseed(deviceId);
+ remoteSessionStore.requestReseed(shardId);
// 与首页同款人话文案(review P2):不把 [NOT_CONNECTED] 原始错误码怼给用户。
Alert.alert(t('session.screen.operationFailed'), humanizeRemoteError(err));
} finally {
diff --git a/apps/mobile/src/__tests__/orcaTeam.test.ts b/apps/mobile/src/__tests__/orcaTeam.test.ts
index fa829df383..43629eb844 100644
--- a/apps/mobile/src/__tests__/orcaTeam.test.ts
+++ b/apps/mobile/src/__tests__/orcaTeam.test.ts
@@ -1,6 +1,7 @@
import { beforeAll, describe, expect, it, vi } from 'vitest';
import { i18n } from '@/i18n';
import {
+ archiveOrcaWorker,
buildOrcaEnableOptions,
convergeOrcaWorkerModel,
createOrcaWorker,
@@ -93,6 +94,27 @@ describe('mobile Orca collaboration entry', () => {
});
describe('mobile Orca collaboration mutations', () => {
+ it('settles a timed-out Worker archive by rechecking the team once', async () => {
+ const timeout = new Error('[INVOKE_TIMEOUT] timed out');
+ const gone = fakeMaker({ orca: { archiveWorker: vi.fn(async () => { throw timeout; }), listWorkers: vi.fn(async () => []) } });
+ await expect(archiveOrcaWorker(gone, 'lead-1', 'w-1')).resolves.toBeUndefined();
+ const stillListed = fakeMaker({ orca: {
+ archiveWorker: vi.fn(async () => { throw timeout; }),
+ listWorkers: vi.fn(async () => [{ id: 'w-1', sessionId: 's-1' }]),
+ } });
+ await expect(archiveOrcaWorker(stillListed, 'lead-1', 'w-1')).rejects.toThrow('ORCA_ACTION_UNCONFIRMED');
+ const recheckFailed = fakeMaker({ orca: {
+ archiveWorker: vi.fn(async () => { throw timeout; }),
+ listWorkers: vi.fn(async () => { throw new Error('[NOT_CONNECTED] offline'); }),
+ } });
+ await expect(archiveOrcaWorker(recheckFailed, 'lead-1', 'w-1')).rejects.toThrow('ORCA_ACTION_UNCONFIRMED');
+ // 非超时错误是权威失败:原样抛出,不回查。
+ const listWorkers = vi.fn(async () => []);
+ const rejected = fakeMaker({ orca: { archiveWorker: vi.fn(async () => { throw new Error('[WORKER_NOT_FOUND] x'); }), listWorkers } });
+ await expect(archiveOrcaWorker(rejected, 'lead-1', 'w-1')).rejects.toThrow('WORKER_NOT_FOUND');
+ expect(listWorkers).not.toHaveBeenCalled();
+ });
+
const form = {
...orcaWorkerFormFromPrefs({ ...defaultOrcaWorkerCreationPrefs(), workerPermissionMode: 'auto' }, 'codex'),
model: null,
diff --git a/apps/mobile/src/__tests__/remoteSessionStore.test.ts b/apps/mobile/src/__tests__/remoteSessionStore.test.ts
index 274ba8250c..6562834dad 100644
--- a/apps/mobile/src/__tests__/remoteSessionStore.test.ts
+++ b/apps/mobile/src/__tests__/remoteSessionStore.test.ts
@@ -2,7 +2,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
import { MAKER_EVENT_BATCH_CHANNEL, SESSION_SYNC_CHANNEL } from '@cindy/device-link';
import { clampLiveRowCreatedAt } from '@/session/messagePaging';
import { MOBILE_TOOL_INPUT_PROJECTION_THRESHOLD_BYTES } from '@/session/messageToolPayloadProjection';
-import { remoteSessionStore, sessionPendingWrites } from '@/session/remoteSessionStore';
+import { remoteSessionStore, resolveSessionWriteDevices, sessionPendingWrites } from '@/session/remoteSessionStore';
import type { InputProjection, PendingInteraction, RemoteMessage, RemoteSession } from '@/session/types';
function session(id: string, patch: Partial<RemoteSession> = {}): RemoteSession {
@@ -5082,6 +5082,62 @@ describe('setDeviceSessions 在途元数据写保护(sessionPendingWrites)', ()
});
});
+describe('upsertDeviceSession 在途元数据写保护(sessionPendingWrites)', () => {
+ beforeEach(() => remoteSessionStore.clear());
+
+ it('归档在途、行已被乐观移出:单条读回的旧行不插回;release 后恢复正常 upsert', () => {
+ remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [session('s1'), session('s2')]);
+ const release = sessionPendingWrites.track('s1', ['status']);
+ remoteSessionStore.applySessionPatch('dev-1', 's1', { status: 'archived' });
+ // 会话页 getSession 慢回包:被控端还没处理归档,带回旧 status
+ remoteSessionStore.upsertDeviceSession('dev-1', 'Mac', session('s1', { status: 'active' }));
+ expect(remoteSessionStore.getSessions().map((s) => s.id)).toEqual(['s2']);
+ // 失败回滚先 release 再整行插回:不被自己的在途登记挡掉
+ release();
+ remoteSessionStore.upsertDeviceSession('dev-1', 'Mac', session('s1'));
+ expect(remoteSessionStore.getSessions().map((s) => s.id).sort()).toEqual(['s1', 's2']);
+ });
+
+ it('行仍在本地:在途字段保留本地乐观值并留差异痕,其余字段照常吃读回', () => {
+ remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [session('s1', { title: '旧名' })]);
+ const release = sessionPendingWrites.track('s1', ['title']);
+ remoteSessionStore.applySessionPatch('dev-1', 's1', { title: '新名' });
+ remoteSessionStore.upsertDeviceSession('dev-1', 'Mac', session('s1', {
+ title: '旧名',
+ updatedAt: '2026-01-02T00:00:00.000Z',
+ }));
+ const row = remoteSessionStore.getSessions().find((s) => s.id === 's1');
+ expect(row?.title).toBe('新名');
+ expect(row?.updatedAt).toBe('2026-01-02T00:00:00.000Z');
+ expect(sessionPendingWrites.consumeMaskedPush('s1', ['title'])).toBe(true);
+ release();
+ });
+
+ it('只有非 status 字段在途时,本地缺行的读回照常插入', () => {
+ remoteSessionStore.setDeviceSessions('dev-1', 'Mac', []);
+ const release = sessionPendingWrites.track('s1', ['title']);
+ remoteSessionStore.upsertDeviceSession('dev-1', 'Mac', session('s1'));
+ expect(remoteSessionStore.getSessions().map((s) => s.id)).toEqual(['s1']);
+ release();
+ });
+});
+
+describe('resolveSessionWriteDevices', () => {
+ beforeEach(() => remoteSessionStore.clear());
+
+ it('乐观 patch / 回滚落行所在的物理 shard,出网走规范 id 或调用方指定的路由设备', () => {
+ remoteSessionStore.setDeviceSessions('dev-old', 'Mac', [session('s1')]);
+ const row = { ...remoteSessionStore.getSessions().find((s) => s.id === 's1')!, canonicalDeviceId: 'dev-new' };
+ expect(resolveSessionWriteDevices('s1', row)).toEqual({ rpcDeviceId: 'dev-new', shardId: 'dev-old' });
+ // 会话页:出网沿用路由设备,shard 仍是物理 shard(不是路由 id)
+ expect(resolveSessionWriteDevices('s1', row, 'dev-route')).toEqual({ rpcDeviceId: 'dev-route', shardId: 'dev-old' });
+ // 调用方没有会话对象时按 store 索引解析
+ expect(resolveSessionWriteDevices('s1', null, 'dev-route')).toEqual({ rpcDeviceId: 'dev-route', shardId: 'dev-old' });
+ expect(resolveSessionWriteDevices('missing', null)).toBeNull();
+ expect(resolveSessionWriteDevices('missing', null, 'dev-route')).toEqual({ rpcDeviceId: 'dev-route', shardId: 'dev-route' });
+ });
+});
+
describe('引用调和(2026-07-18 首页重渲染风暴修复)', () => {
beforeEach(() => remoteSessionStore.clear());
diff --git a/apps/mobile/src/__tests__/sessionSwipe.test.ts b/apps/mobile/src/__tests__/sessionSwipe.test.ts
index 08ae7e31ba..c17e3b4cc2 100644
--- a/apps/mobile/src/__tests__/sessionSwipe.test.ts
+++ b/apps/mobile/src/__tests__/sessionSwipe.test.ts
@@ -1,3 +1,5 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
import { beforeAll, describe, expect, it, vi } from 'vitest';
import { i18n } from '@/i18n';
import {
@@ -474,3 +476,29 @@ describe('swipeActionPatch', () => {
expect(swipeActionPatch('delete')).toEqual({ status: 'deleted' });
});
});
+
+describe('会话元数据写的设备解析(首页与会话页同口径)', () => {
+ const read = (path: string) => readFileSync(resolve(process.cwd(), path), 'utf8').replace(/\r\n/g, '\n');
+
+ it('会话页乐观 patch / 对账 / 回滚落物理 shard,出网沿用路由设备', () => {
+ const source = read('app/sessions/[sessionId].tsx');
+ const start = source.indexOf('const patchSessionMeta = useCallback((');
+ const block = source.slice(start, source.indexOf('const previewRewindAtMessage', start));
+ expect(block).toContain('resolveSessionWriteDevices(sessionId, session, deviceId)');
+ expect(block).toContain('remoteSessionStore.applySessionPatch(shardId, sessionId, patch as Partial<RemoteSession>);');
+ expect(block).toContain('remoteSessionStore.upsertDeviceSession(shardId, shardName, session);');
+ expect(block).toContain('remoteSessionStore.requestReseed(shardId);');
+ expect(block).toMatch(/invoke<RemoteSession>\(\s*rpcDeviceId,/);
+ // 路由 id 不再直接当 shard 用。
+ expect(block).not.toMatch(/applySessionPatch\(\s*deviceId,/);
+ expect(block).not.toContain('upsertDeviceSession(deviceId,');
+ // 整行回滚前先释放本笔在途登记,否则会被 upsertDeviceSession 的在途保护挡掉。
+ expect(block.indexOf('releasePending();')).toBeLessThan(block.indexOf('upsertDeviceSession(shardId'));
+ });
+
+ it('首页 / 设备页写路径共用同一解析,回滚同样先释放在途登记', () => {
+ const source = read('src/session/useSessionListActions.ts');
+ expect(source).toContain('resolveSessionWriteDevices(session.id, session)');
+ expect(source.indexOf('releasePending();')).toBeLessThan(source.indexOf('upsertDeviceSession(shardId'));
+ });
+});
diff --git a/apps/mobile/src/__tests__/useOrcaTeam.test.tsx b/apps/mobile/src/__tests__/useOrcaTeam.test.tsx
index bb87ea5c0e..aa47474fcb 100644
--- a/apps/mobile/src/__tests__/useOrcaTeam.test.tsx
+++ b/apps/mobile/src/__tests__/useOrcaTeam.test.tsx
@@ -15,9 +15,9 @@ vi.mock('@/device-link/DeviceLinkContext', () => ({
}));
vi.mock('@/session/ContextSheetCollabView', () => ({ canSubmitOrcaWorkerForm: () => true }));
vi.mock('@/session/fullAccessConfirmation', () => ({ confirmFullAccessChange: async () => true }));
-vi.mock('@/session/remoteSessionStore', () => ({ remoteSessionStore: { applySessionPatch: vi.fn() } }));
const { useOrcaTeam } = await import('@/session/useSessionOrcaCollab');
+const { sessionPendingWrites } = await import('@/session/remoteSessionStore');
let root: Root;
let host: HTMLDivElement;
@@ -140,3 +140,35 @@ it('leaves limits unknown instead of assuming defaults when they were never read
await act(async () => root.render(<Probe maker={maker} leadSessionId="lead-1" />));
expect(latest?.settings).toBeNull();
});
+
+it('hides a Worker whose archive is in flight, even when a refresh brings it back', async () => {
+ const listWorkers = vi.fn(async () => [
+ { id: 'w-1', sessionId: 's-1', status: 'idle' },
+ { id: 'w-2', sessionId: 's-2', status: 'idle' },
+ ]);
+ await act(async () => root.render(<Probe maker={fakeMaker(listWorkers)} leadSessionId="lead-1" />));
+ const release = sessionPendingWrites.track('s-1', ['status']);
+ try {
+ // 在途期间的整表重拉(被控端还没处理归档)不得把它带回来。
+ await act(async () => { await latest!.refresh(); });
+ expect(latest?.workers.map((worker) => worker.workerId)).toEqual(['w-2']);
+ } finally {
+ release();
+ }
+ await act(async () => { await latest!.refresh(); });
+ expect(latest?.workers.map((worker) => worker.workerId)).toEqual(['w-1', 'w-2']);
+});
+
+it('drops a Worker locally and restores it at its original position', async () => {
+ const listWorkers = vi.fn(async () => [
+ { id: 'w-1', sessionId: 's-1' },
+ { id: 'w-2', sessionId: 's-2' },
+ ]);
+ await act(async () => root.render(<Probe maker={fakeMaker(listWorkers)} leadSessionId="lead-1" />));
+ const target = latest!.workers[0]!;
+ let restore: () => void = () => undefined;
+ act(() => { restore = latest!.dropWorker(target); });
+ expect(latest?.workers.map((worker) => worker.workerId)).toEqual(['w-2']);
+ act(() => restore());
+ expect(latest?.workers.map((worker) => worker.workerId)).toEqual(['w-1', 'w-2']);
+});
diff --git a/apps/mobile/src/__tests__/useOrcaWorkerForm.test.tsx b/apps/mobile/src/__tests__/useOrcaWorkerForm.test.tsx
index 46088c20e2..8d29be6a20 100644
--- a/apps/mobile/src/__tests__/useOrcaWorkerForm.test.tsx
+++ b/apps/mobile/src/__tests__/useOrcaWorkerForm.test.tsx
@@ -1,8 +1,9 @@
// @vitest-environment jsdom
import { act } from 'react';
import { createRoot, type Root } from 'react-dom/client';
-import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { MobileMakerTransport } from '@/device-link/mobileMakerTransport';
+import type { RemoteSession } from '@/session/types';
const storage = new Map<string, string>();
vi.mock('@react-native-async-storage/async-storage', () => ({
@@ -18,7 +19,6 @@ vi.mock('@/session/ContextSheetCollabView', () => ({
isPredefinedOrcaRole: (role: string) => ['developer', 'designer', 'reviewer', 'tester', 'merger'].includes(role),
}));
vi.mock('@/session/fullAccessConfirmation', () => ({ confirmFullAccessChange: async () => true }));
-vi.mock('@/session/remoteSessionStore', () => ({ remoteSessionStore: { applySessionPatch: vi.fn() } }));
const { useOrcaWorkerForm } = await import('@/session/useSessionOrcaCollab');
const { resetOrcaWorkerCreationPrefsMemory, saveOrcaWorkerCreationPrefs, defaultOrcaWorkerCreationPrefs } =
@@ -48,6 +48,11 @@ function fakeMaker(): MobileMakerTransport {
const flush = async () => { for (let i = 0; i < 4; i += 1) await Promise.resolve(); };
+/** store 里的 Worker 任务行(只填乐观归档 / 回滚用得到的字段)。 */
+const workerRow = (id: string) => ({
+ id, title: id, status: 'active', orcaRole: 'worker', updatedAt: '2026-01-01T00:00:00.000Z',
+}) as unknown as RemoteSession;
+
beforeEach(() => {
Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
storage.clear();
@@ -274,11 +279,16 @@ it('still restores remembered choices when the Agent list lands before the memor
}
});
-it('treats a timed-out Worker archive as unconfirmed and rechecks the team', async () => {
+it('treats a timed-out Worker archive as unconfirmed when the recheck still lists it, and rolls back', async () => {
const { Alert } = await import('react-native');
const { useSessionOrcaCollab } = await import('@/session/useSessionOrcaCollab');
+ const { remoteSessionStore, sessionPendingWrites } = await import('@/session/remoteSessionStore');
+ remoteSessionStore.clear();
+ remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [workerRow('s-1')]);
+ const reseeds = vi.fn();
+ const unregister = remoteSessionStore.registerReseedHandler('dev-1', reseeds);
let collab: ReturnType<typeof useSessionOrcaCollab> | null = null;
- const listWorkers = vi.fn(async () => []);
+ const listWorkers = vi.fn(async () => [{ id: 'w-1', sessionId: 's-1', role: 'developer', status: 'idle' }]);
const maker = {
...fakeMaker(),
orca: {
@@ -296,15 +306,25 @@ it('treats a timed-out Worker archive as unconfirmed and rechecks the team', asy
});
return null;
}
- await act(async () => root.render(<Host />));
- const loads = listWorkers.mock.calls.length;
- const worker = { workerId: 'w-1', sessionId: 's-1', role: 'developer', label: null, status: 'idle' as const, focused: false, agentKind: 'codex' as const, model: null, effort: null, title: null };
- act(() => collab!.showWorkerActions({ ...worker, focused: true }));
- act(() => vi.mocked(Alert.alert).mock.calls.at(-1)![2]!.find((button) => button.style === 'destructive')!.onPress?.());
- const confirm = vi.mocked(Alert.alert).mock.calls.at(-1)![2]!.find((button) => button.style === 'destructive')!;
- await act(async () => { confirm.onPress?.(); await flush(); });
- expect(collab!.error).toMatch(/timed out|超时/);
- expect(listWorkers.mock.calls.length).toBeGreaterThan(loads);
+ try {
+ await act(async () => { root.render(<Host />); await flush(); });
+ const loads = listWorkers.mock.calls.length;
+ const worker = collab!.team.workers[0]!;
+ act(() => collab!.showWorkerActions(worker));
+ act(() => vi.mocked(Alert.alert).mock.calls.at(-1)![2]!.find((button) => button.style === 'destructive')!.onPress?.());
+ const confirm = vi.mocked(Alert.alert).mock.calls.at(-1)![2]!.find((button) => button.style === 'destructive')!;
+ await act(async () => { confirm.onPress?.(); await flush(); await flush(); });
+ expect(collab!.error).toMatch(/timed out|超时|confirm/i);
+ expect(listWorkers.mock.calls.length).toBeGreaterThan(loads);
+ // 回查仍在 → 回滚:任务插回原 shard、团队视图恢复、在途登记释放并 reseed。
+ expect(remoteSessionStore.getSessions().map((item) => item.id)).toEqual(['s-1']);
+ expect(collab!.team.workers.map((item) => item.workerId)).toEqual(['w-1']);
+ expect(sessionPendingWrites.pendingFields('s-1')).toEqual([]);
+ expect(reseeds).toHaveBeenCalled();
+ } finally {
+ unregister();
+ remoteSessionStore.clear();
+ }
});
it('restores the remembered Agent after a device switch instead of the previous computer fallback', async () => {
@@ -434,3 +454,200 @@ it('does not let a late capability response from the previous computer fill the
await act(async () => { releaseA(); await flush(); });
expect(latest!.modelPicker.flatModelOptions.map((option) => option.id)).toEqual(['b-model']);
});
+
+describe('optimistic Worker archive', () => {
+ type Deferred = { promise: Promise<unknown>; resolve(value?: unknown): void; reject(error: unknown): void };
+ const deferred = (): Deferred => {
+ let resolve!: (value?: unknown) => void;
+ let reject!: (error: unknown) => void;
+ const promise = new Promise<unknown>((res, rej) => { resolve = res; reject = rej; });
+ return { promise, resolve, reject };
+ };
+
+ async function mountCollab(params: {
+ sessionId: string;
+ role: 'lead' | 'worker';
+ listWorkers: ReturnType<typeof vi.fn>;
+ archiveWorker: ReturnType<typeof vi.fn>;
+ openSession?: ReturnType<typeof vi.fn>;
+ }) {
+ const { useSessionOrcaCollab } = await import('@/session/useSessionOrcaCollab');
+ const ref: { current: ReturnType<typeof useSessionOrcaCollab> | null } = { current: null };
+ const maker = {
+ ...fakeMaker(),
+ orca: {
+ listWorkers: params.listWorkers,
+ getCollaborationSettings: vi.fn(async () => ({})),
+ getTeamByWorkerSession: vi.fn(async () => ({ leadSessionId: 'lead-1' })),
+ archiveWorker: params.archiveWorker,
+ },
+ } as unknown as MobileMakerTransport;
+ function Host() {
+ ref.current = useSessionOrcaCollab({
+ maker, deviceId: 'dev-1', sessionId: params.sessionId, prefsScope: 'user-1', enabled: true,
+ session: { id: params.sessionId, orcaRole: params.role, workspaceKind: 'project', workingDir: '/repo', agentKind: 'codex' } as never,
+ sheetView: null, sheetOpen: false, setSheetView: () => undefined, setSheetOpen: () => undefined,
+ openSession: params.openSession ?? vi.fn(),
+ });
+ return null;
+ }
+ await act(async () => { root.render(<Host />); await flush(); });
+ await act(async () => { await flush(); });
+ return ref;
+ }
+
+ async function confirmLatestAlert() {
+ const { Alert } = await import('react-native');
+ const confirm = vi.mocked(Alert.alert).mock.calls.at(-1)![2]!.find((button) => button.style === 'destructive')!;
+ await act(async () => { confirm.onPress?.(); await flush(); });
+ }
+
+ it('removes the Worker from the panel and the store at once, and keeps it gone until the host confirms', async () => {
+ const { Alert } = await import('react-native');
+ const { remoteSessionStore, sessionPendingWrites } = await import('@/session/remoteSessionStore');
+ remoteSessionStore.clear();
+ // Worker 任务行在物理 shard dev-old(re-link 前的 shard),路由设备是 dev-1。
+ remoteSessionStore.setDeviceSessions('dev-old', 'Old Mac', [workerRow('s-1'), workerRow('s-2')]);
+ let hostArchived = false;
+ const listWorkers = vi.fn(async () => [
+ ...(hostArchived ? [] : [{ id: 'w-1', sessionId: 's-1', role: 'developer', status: 'idle' }]),
+ { id: 'w-2', sessionId: 's-2', role: 'tester', status: 'idle' },
+ ]);
+ const rpc = deferred();
+ const archiveWorker = vi.fn(() => rpc.promise);
+ const collab = await mountCollab({ sessionId: 'lead-1', role: 'lead', listWorkers, archiveWorker });
+ const reseeds = vi.fn();
+ const unregister = remoteSessionStore.registerReseedHandler('dev-old', reseeds);
+ try {
+ act(() => collab.current!.showWorkerActions(collab.current!.team.workers[0]!));
+ act(() => vi.mocked(Alert.alert).mock.calls.at(-1)![2]!.find((button) => button.style === 'destructive')!.onPress?.());
+ await confirmLatestAlert();
+ expect(archiveWorker).toHaveBeenCalledWith('lead-1', 'w-1');
+ expect(collab.current!.busy).toBe(false);
+ expect(collab.current!.team.workers.map((worker) => worker.workerId)).toEqual(['w-2']);
+ expect(remoteSessionStore.getSessions().map((item) => item.id)).toEqual(['s-2']);
+ expect(sessionPendingWrites.pendingFields('s-1')).toEqual(['status']);
+
+ // 在途期间:旧快照对账、单条读回、整表重拉都不得把它带回来。
+ remoteSessionStore.setDeviceSessions('dev-old', 'Old Mac', [workerRow('s-1'), workerRow('s-2')]);
+ remoteSessionStore.upsertDeviceSession('dev-old', 'Old Mac', workerRow('s-1'));
+ await act(async () => { await collab.current!.team.refresh(); });
+ expect(remoteSessionStore.getSessions().map((item) => item.id)).toEqual(['s-2']);
+ expect(collab.current!.team.workers.map((worker) => worker.workerId)).toEqual(['w-2']);
+
+ hostArchived = true;
+ await act(async () => { rpc.resolve({ ok: true }); await flush(); await flush(); });
+ expect(collab.current!.error).toBeNull();
+ expect(sessionPendingWrites.pendingFields('s-1')).toEqual([]);
+ expect(collab.current!.team.workers.map((worker) => worker.workerId)).toEqual(['w-2']);
+ expect(remoteSessionStore.getSessions().map((item) => item.id)).toEqual(['s-2']);
+ // 成功后主动对账该 shard:归档前发出、成功后才落地的旧读取由写库后的权威列表收敛。
+ expect(reseeds).toHaveBeenCalled();
+ } finally {
+ unregister();
+ remoteSessionStore.clear();
+ }
+ });
+
+ it('settles a timed-out panel archive as success when the recheck no longer lists the Worker', async () => {
+ const { Alert } = await import('react-native');
+ const { remoteSessionStore } = await import('@/session/remoteSessionStore');
+ remoteSessionStore.clear();
+ remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [workerRow('s-1')]);
+ let hostArchived = false;
+ const listWorkers = vi.fn(async () => (hostArchived ? [] : [{ id: 'w-1', sessionId: 's-1', role: 'developer' }]));
+ const archiveWorker = vi.fn(async () => { hostArchived = true; throw new Error('[INVOKE_TIMEOUT] timed out'); });
+ const collab = await mountCollab({ sessionId: 'lead-1', role: 'lead', listWorkers, archiveWorker });
+ try {
+ act(() => collab.current!.showWorkerActions(collab.current!.team.workers[0]!));
+ act(() => vi.mocked(Alert.alert).mock.calls.at(-1)![2]!.find((button) => button.style === 'destructive')!.onPress?.());
+ await confirmLatestAlert();
+ await act(async () => { await flush(); });
+ expect(collab.current!.error).toBeNull();
+ expect(collab.current!.team.workers).toEqual([]);
+ expect(remoteSessionStore.getSessions()).toEqual([]);
+ } finally {
+ remoteSessionStore.clear();
+ }
+ });
+
+ it('returns a self-archiving Worker to the Lead before the host replies', async () => {
+ const { remoteSessionStore } = await import('@/session/remoteSessionStore');
+ remoteSessionStore.clear();
+ remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [workerRow('worker-1')]);
+ const rpc = deferred();
+ const archiveWorker = vi.fn(() => rpc.promise);
+ const openSession = vi.fn();
+ const listWorkers = vi.fn(async () => [{ id: 'w-1', sessionId: 'worker-1', role: 'tester' }]);
+ const collab = await mountCollab({ sessionId: 'worker-1', role: 'worker', listWorkers, archiveWorker, openSession });
+ try {
+ expect(collab.current!.workerSelf?.workerId).toBe('w-1');
+ const closeMenu = vi.fn();
+ act(() => collab.current!.confirmArchiveSelf(closeMenu));
+ await confirmLatestAlert();
+ expect(closeMenu).toHaveBeenCalledTimes(1);
+ expect(openSession).toHaveBeenCalledWith('lead-1');
+ expect(remoteSessionStore.getSessions()).toEqual([]);
+ await act(async () => { rpc.resolve({ ok: true }); await flush(); });
+ expect(remoteSessionStore.getSessions()).toEqual([]);
+ } finally {
+ remoteSessionStore.clear();
+ }
+ });
+
+ it('rolls a failed self-archive back into the same shard and tells the user', async () => {
+ const { Alert } = await import('react-native');
+ const { remoteSessionStore, sessionPendingWrites } = await import('@/session/remoteSessionStore');
+ remoteSessionStore.clear();
+ remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [workerRow('worker-1')]);
+ const reseeds = vi.fn();
+ const unregister = remoteSessionStore.registerReseedHandler('dev-1', reseeds);
+ const rpc = deferred();
+ const openSession = vi.fn();
+ const listWorkers = vi.fn(async () => [{ id: 'w-1', sessionId: 'worker-1', role: 'tester' }]);
+ const collab = await mountCollab({
+ sessionId: 'worker-1', role: 'worker', listWorkers, archiveWorker: vi.fn(() => rpc.promise), openSession,
+ });
+ try {
+ act(() => collab.current!.confirmArchiveSelf());
+ await confirmLatestAlert();
+ expect(openSession).toHaveBeenCalledWith('lead-1');
+ vi.mocked(Alert.alert).mockClear();
+ await act(async () => { rpc.reject(new Error('[WORKER_NOT_FOUND] gone')); await flush(); await flush(); });
+ expect(remoteSessionStore.getSessions().map((item) => item.id)).toEqual(['worker-1']);
+ expect(remoteSessionStore.getSessionDeviceId('worker-1')).toBe('dev-1');
+ expect(collab.current!.workerSelf?.workerId).toBe('w-1');
+ expect(sessionPendingWrites.pendingFields('worker-1')).toEqual([]);
+ expect(reseeds).toHaveBeenCalled();
+ expect(Alert.alert).toHaveBeenCalledTimes(1);
+ } finally {
+ unregister();
+ remoteSessionStore.clear();
+ }
+ });
+
+ it('leaves the row to a newer write when the archive was superseded before it failed', async () => {
+ const { remoteSessionStore, sessionMetaWriteGuard } = await import('@/session/remoteSessionStore');
+ remoteSessionStore.clear();
+ remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [workerRow('worker-1')]);
+ const reseeds = vi.fn();
+ const unregister = remoteSessionStore.registerReseedHandler('dev-1', reseeds);
+ const rpc = deferred();
+ const listWorkers = vi.fn(async () => [{ id: 'w-1', sessionId: 'worker-1', role: 'tester' }]);
+ const collab = await mountCollab({
+ sessionId: 'worker-1', role: 'worker', listWorkers, archiveWorker: vi.fn(() => rpc.promise),
+ });
+ try {
+ act(() => collab.current!.confirmArchiveSelf());
+ await confirmLatestAlert();
+ // 列表里随后又删除了这个任务:同会话后续 status 写取代了归档。
+ sessionMetaWriteGuard.begin('worker-1', ['status', 'title', 'pinnedAt']);
+ await act(async () => { rpc.reject(new Error('[INTERNAL] failed')); await flush(); await flush(); });
+ expect(remoteSessionStore.getSessions()).toEqual([]);
+ expect(reseeds).toHaveBeenCalled();
+ } finally {
+ unregister();
+ remoteSessionStore.clear();
+ }
+ });
+});
diff --git a/apps/mobile/src/session/orcaTeam.ts b/apps/mobile/src/session/orcaTeam.ts
index 967d30529f..b8c97ea7b4 100644
--- a/apps/mobile/src/session/orcaTeam.ts
+++ b/apps/mobile/src/session/orcaTeam.ts
@@ -416,6 +416,28 @@ export async function createOrcaWorker(
throw new Error('[DUPLICATE_LABEL] no unique worker label available');
}
+/**
+ * 归档 Worker(协同面板长按与 Worker 自身菜单共用)。隧道超时不是权威失败:只读回查一次
+ * 团队,Worker 已不在列表里即归档已生效,按成功返回;仍在或回查失败时抛
+ * ORCA_ACTION_UNCONFIRMED(提示以列表为准),由调用方回滚乐观状态。
+ */
+export async function archiveOrcaWorker(
+ maker: MobileMakerTransport,
+ leadSessionId: string,
+ workerId: string,
+): Promise<void> {
+ try {
+ await maker.orca.archiveWorker(leadSessionId, workerId);
+ } catch (error) {
+ if (!isAmbiguousTimeout(error)) throw error;
+ const archived = await maker.orca.listWorkers(leadSessionId)
+ .then((raw) => !parseOrcaTeamWorkers(raw).some((worker) => worker.workerId === workerId))
+ .catch(() => false);
+ if (archived) return;
+ throw new Error('[ORCA_ACTION_UNCONFIRMED] worker archive timed out and could not be confirmed');
+ }
+}
+
/** 新建页协同草稿所属目标(设备 + 工作区):目标变了草稿作废。 */
export function orcaCollabDraftTargetKey(
deviceId: string | null | undefined,
diff --git a/apps/mobile/src/session/remoteSessionStore.ts b/apps/mobile/src/session/remoteSessionStore.ts
index f3e8bfc78c..808fc769e2 100644
--- a/apps/mobile/src/session/remoteSessionStore.ts
+++ b/apps/mobile/src/session/remoteSessionStore.ts
@@ -116,6 +116,26 @@ export const sessionPendingWrites = createPendingWriteTracker();
export const sessionMetaWriteGuard = createLatestWriteGuard();
export const sessionMetaWriteQueue = createSessionWriteQueue();
+/**
+ * 会话元数据写的两个设备 id(首页 / 设备详情 / 会话页菜单 / 协同 Worker 归档共用):
+ * - rpcDeviceId:出网目标,默认取展示用规范 id(re-link 后认领回当前设备);调用方已按
+ * 路由连着某台设备(会话页)时传 preferredRpcDeviceId 沿用它;
+ * - shardId:乐观 patch 与失败回滚落的**物理** shard(行真实所在)。re-link 后两者可能
+ * 不同:按规范 id 落 shard 会让乐观移行落空、回滚插进另一个 shard 成重复行。
+ * 都解析不到时返回 null(调用方按「找不到设备」处理)。
+ */
+export function resolveSessionWriteDevices(
+ sessionId: string,
+ session: Pick<RemoteSession, 'canonicalDeviceId' | 'deviceLinkDeviceId'> | null | undefined,
+ preferredRpcDeviceId?: string | null,
+): { rpcDeviceId: string; shardId: string } | null {
+ const indexedDeviceId = sessionDeviceIndex.get(sessionId);
+ const rpcDeviceId = preferredRpcDeviceId || session?.canonicalDeviceId || session?.deviceLinkDeviceId
+ || indexedDeviceId;
+ if (!rpcDeviceId) return null;
+ return { rpcDeviceId, shardId: session?.deviceLinkDeviceId || indexedDeviceId || rpcDeviceId };
+}
+
export interface RemoteSessionRunStatus {
isRunning: boolean;
/** Terminal failure remains sticky until the next run, even after read acknowledgement. */
@@ -3305,13 +3325,37 @@ export const remoteSessionStore = {
upsertDeviceSession(deviceId: string, deviceName: string, rawSession: RemoteSession): void {
let stamped = stamp(rawSession, deviceId, deviceName);
const shard = shards.get(deviceId);
+ const existing = shard?.sessions.find((s) => s.id === rawSession.id);
+ // 在途元数据写保护(与 setDeviceSessions 同口径):单条读回(会话页 getSession、资源页、
+ // 发件箱回包)可能是被控端尚未处理本机写的旧值——
+ // - 行已被本地乐观移出且 status 在途(归档/删除):不插回,终态由该写的结局负责;
+ // - 行仍在本地:在途字段用本地当前值覆盖,差异留痕由该写的结局 consume 后 reseed。
+ // 写失败的整行回滚必须先 release 自己的在途登记再 upsert,否则会被这里当成旧读回挡掉。
+ const pendingFields = sessionPendingWrites.pendingFields(rawSession.id);
+ if (pendingFields.length > 0) {
+ if (!existing) {
+ if (pendingFields.includes('status')) return;
+ } else {
+ const overlay: Record<string, unknown> = {};
+ for (const field of pendingFields) {
+ const localValue = (existing as unknown as Record<string, unknown>)[field];
+ overlay[field] = localValue;
+ sessionPendingWrites.noteMaskedValue(
+ rawSession.id,
+ field,
+ (stamped as unknown as Record<string, unknown>)[field],
+ localValue,
+ );
+ }
+ stamped = { ...stamped, ...overlay } as RemoteSession;
+ }
+ }
if (!shard) {
shards.set(deviceId, { deviceId, deviceName, sessions: [stamped] });
recomputeSessions();
return;
}
const next = shard.sessions.filter((s) => s.id !== rawSession.id);
- const existing = shard.sessions.find((s) => s.id === rawSession.id);
stamped = preserveSessionRuntimeFields(stamped, existing);
if (
existing
diff --git a/apps/mobile/src/session/useSessionListActions.ts b/apps/mobile/src/session/useSessionListActions.ts
index 6529584143..cd543660d7 100644
--- a/apps/mobile/src/session/useSessionListActions.ts
+++ b/apps/mobile/src/session/useSessionListActions.ts
@@ -7,6 +7,7 @@ import { humanizeRemoteError } from '@/device-link/remoteStatus';
import type { SessionMetaPatch } from '@/device-link/mobileMakerTransport';
import {
remoteSessionStore,
+ resolveSessionWriteDevices,
sessionMetaWriteGuard,
sessionMetaWriteQueue,
sessionPendingWrites,
@@ -44,10 +45,9 @@ export function useSessionListActions(options?: { animateListChange?: (apply: ()
const pendingSheetActionRef = useRef<(() => void) | null>(null);
const patchSession = useCallback(async (session: RemoteSession, patch: SessionMetaPatch) => {
- const rpcDeviceId = session.canonicalDeviceId ?? session.deviceLinkDeviceId
- ?? remoteSessionStore.getSessionDeviceId(session.id);
- if (!rpcDeviceId) throw new Error(t('devices.list.error.sessionDeviceNotFound'));
- const shardId = session.deviceLinkDeviceId ?? remoteSessionStore.getSessionDeviceId(session.id) ?? rpcDeviceId;
+ const devices = resolveSessionWriteDevices(session.id, session);
+ if (!devices) throw new Error(t('devices.list.error.sessionDeviceNotFound'));
+ const { rpcDeviceId, shardId } = devices;
const fields = Object.keys(patch);
const write = sessionMetaWriteGuard.begin(session.id, writeGuardFields(patch));
const applyOptimistic = () => remoteSessionStore.applySessionPatch(shardId, session.id, patch);
@@ -86,6 +86,8 @@ export function useSessionListActions(options?: { animateListChange?: (apply: ()
.find((s) => s.deviceLinkDeviceId === shardId)?.deviceLinkDeviceName
?? session.deviceLinkDeviceName
?? shardId;
+ // 先释放本笔在途登记:upsertDeviceSession 会挡掉 status 在途、已被乐观移出的行。
+ releasePending();
const rollback = () => {
remoteSessionStore.upsertDeviceSession(shardId, shardName, session);
remoteSessionStore.requestReseed(shardId);
diff --git a/apps/mobile/src/session/useSessionOrcaCollab.ts b/apps/mobile/src/session/useSessionOrcaCollab.ts
index 6c8f5fd9d7..9151e461e9 100644
--- a/apps/mobile/src/session/useSessionOrcaCollab.ts
+++ b/apps/mobile/src/session/useSessionOrcaCollab.ts
@@ -6,7 +6,8 @@
* - useSessionOrcaCollab:会话页 + 面板「协同模式」二级视图、团队操作与 Lead / Worker 导航。
*
* 真身在被控端;所有写操作完成后以被控端列表为准(整表重拉),本地只在开启 / 结束协同时
- * 乐观改 orcaRole,权威值随 sessions 推送回流。
+ * 乐观改 orcaRole、归档 Worker 时乐观移出 Worker 任务(见 beginOptimisticWorkerArchive),
+ * 权威值随 sessions 推送回流。
*/
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { Alert } from 'react-native';
@@ -15,6 +16,7 @@ import type { AgentKind } from '@cindy/model-providers/types';
import type { MobileModelOption } from '@/session/agentCapabilities';
import { confirmFullAccessChange } from '@/session/fullAccessConfirmation';
import {
+ archiveOrcaWorker,
buildOrcaEnableOptions,
convergeOrcaWorkerModel,
createOrcaWorker,
@@ -52,7 +54,13 @@ import {
rememberOrcaWorkerChoice,
type OrcaWorkerCreationPrefs,
} from '@/session/orcaWorkerPrefs';
-import { remoteSessionStore } from '@/session/remoteSessionStore';
+import {
+ remoteSessionStore,
+ resolveSessionWriteDevices,
+ sessionMetaWriteGuard,
+ sessionPendingWrites,
+} from '@/session/remoteSessionStore';
+import { writeGuardFields } from '@/session/swipeRowRegistry';
import { i18n } from '@/i18n';
import type { MobileMakerTransport } from '@/device-link/mobileMakerTransport';
import type { MobileModelConfiguration } from '@/session/unifiedMobileModels';
@@ -83,6 +91,51 @@ const EMPTY_TEAM: OrcaTeamSnapshot = {
error: null,
};
+/** Worker 任务有 status 在途写(乐观归档中):团队视图不展示它。 */
+function isWorkerArchivePending(worker: OrcaTeamWorker): boolean {
+ return sessionPendingWrites.pendingFields(worker.sessionId).includes('status');
+}
+
+/**
+ * Worker 归档的乐观落地(协同面板长按与 Worker 自身菜单共用),写序与在途登记复用任务列表
+ * 归档那一套 app 级单例(sessionMetaWriteGuard / sessionPendingWrites):
+ * - 先登记 status 在途写,再按物理 shard 把 Worker 任务移出 store——在途期间 sessions 推送、
+ * 全量对账与单条 upsert 都不会把它复活,useOrcaTeam 也据此把它从团队视图藏起;
+ * - 返回 settle(ok):成功释放登记并主动对账该 shard(防归档前发出的读取迟到复活);
+ * 失败先释放登记(否则回滚的 upsert 会被在途保护挡掉),仍是最新写才把原会话整行插回
+ * 同一 shard,并一律 reseed——被同会话后续写取代时终态由新写负责。
+ */
+export function beginOptimisticWorkerArchive(
+ workerSessionId: string,
+ routeDeviceId: string | null,
+): (ok: boolean) => void {
+ const session = remoteSessionStore.getSessions().find((item) => item.id === workerSessionId) ?? null;
+ const devices = resolveSessionWriteDevices(workerSessionId, session, routeDeviceId);
+ const patch = { status: 'archived' } as const;
+ const write = sessionMetaWriteGuard.begin(workerSessionId, writeGuardFields(patch));
+ const releasePending = sessionPendingWrites.track(workerSessionId, ['status']);
+ if (devices) remoteSessionStore.applySessionPatch(devices.shardId, workerSessionId, patch);
+ return (ok) => {
+ releasePending();
+ if (!devices) return;
+ const { shardId } = devices;
+ if (ok) {
+ // 归档 RPC 不回行:释放在途登记后,归档前已发出、成功后才落地的列表 / 单条读取
+ // 可能把旧 active 行插回。主动对账一次该 shard,以写库后的权威列表收敛。
+ remoteSessionStore.requestReseed(shardId);
+ return;
+ }
+ if (write.isLatest() && session) {
+ const shardName = remoteSessionStore.getSessions()
+ .find((item) => item.deviceLinkDeviceId === shardId)?.deviceLinkDeviceName
+ ?? session.deviceLinkDeviceName
+ ?? shardId;
+ remoteSessionStore.upsertDeviceSession(shardId, shardName, session);
+ }
+ remoteSessionStore.requestReseed(shardId);
+ };
+}
+
/**
* Lead 任务的 Worker 列表 + 协同设置。`leadSessionId` 为 null 时不拉取。被控端推送
* worker-changed(需会话页持有 `session:<leadId>` topic)或调用 refresh 时整表重拉;
@@ -94,12 +147,20 @@ export function useOrcaTeam(params: {
leadSessionId: string | null;
/** 隧道重连代次:断线期间可能漏掉 worker-changed 推送,重连后整表重拉一次。 */
connectionEpoch?: number;
-}): OrcaTeamSnapshot & { refresh(): Promise<void> } {
+}): OrcaTeamSnapshot & {
+ refresh(): Promise<void>;
+ /** 乐观归档:把 Worker 从本地视图摘掉;返回的 restore 在失败时把它插回原位(团队没换时)。 */
+ dropWorker(worker: OrcaTeamWorker): () => void;
+} {
const { maker, deviceId, leadSessionId, connectionEpoch } = params;
const [snapshot, setSnapshot] = useState<OrcaTeamSnapshot>(EMPTY_TEAM);
const generationRef = useRef(0);
const makerRef = useRef(maker);
makerRef.current = maker;
+ const snapshotRef = useRef(snapshot);
+ snapshotRef.current = snapshot;
+ const teamKeyRef = useRef(`${deviceId ?? ''}\n${leadSessionId ?? ''}`);
+ teamKeyRef.current = `${deviceId ?? ''}\n${leadSessionId ?? ''}`;
const refresh = useCallback(async () => {
const generation = ++generationRef.current;
@@ -150,7 +211,28 @@ export function useOrcaTeam(params: {
});
}, [deviceId, leadSessionId, refresh]);
- return { ...snapshot, refresh };
+ const dropWorker = useCallback((worker: OrcaTeamWorker) => {
+ const teamKey = teamKeyRef.current;
+ const index = snapshotRef.current.workers.findIndex((item) => item.workerId === worker.workerId);
+ setSnapshot((current) => (current.workers.some((item) => item.workerId === worker.workerId)
+ ? { ...current, workers: current.workers.filter((item) => item.workerId !== worker.workerId) }
+ : current));
+ return () => {
+ if (index < 0 || teamKeyRef.current !== teamKey) return;
+ setSnapshot((current) => {
+ if (current.workers.some((item) => item.workerId === worker.workerId)) return current;
+ const workers = [...current.workers];
+ workers.splice(Math.min(index, workers.length), 0, worker);
+ return { ...current, workers };
+ });
+ };
+ }, []);
+
+ // 归档在途的 Worker 不展示:在途期间迟到的整表重拉、其它页面加载过的旧快照都不得把它带回来。
+ const workers = snapshot.workers.some(isWorkerArchivePending)
+ ? snapshot.workers.filter((worker) => !isWorkerArchivePending(worker))
+ : snapshot.workers;
+ return { ...snapshot, workers, refresh, dropWorker };
}
/** Worker 任务 → 所属 Lead(被控端团队记录为准;查不到 = null,「返回 Lead」入口不出现)。 */
@@ -530,6 +612,7 @@ export function useSessionOrcaCollab(params: {
// 协同视图展示中时顺带刷新一次团队(推送之外的兜底)。
const refreshTeam = team.refresh;
+ const dropTeamWorker = team.dropWorker;
useEffect(() => {
if (sheetOpen && sheetView === 'collab' && isLead) void refreshTeam();
}, [sheetOpen, sheetView, isLead, refreshTeam]);
@@ -609,6 +692,32 @@ export function useSessionOrcaCollab(params: {
}
}, [refreshTeam]);
+ /**
+ * 乐观归档 Worker(面板与 Worker 自身菜单共用):当帧从团队视图摘掉并把 Worker 任务移出
+ * store,RPC 在后台跑。成功后再摘一次(在途期间迟到的整表重拉可能把它带回快照)并以被控端
+ * 列表收敛;失败(含超时回查仍未确认)回滚 store 与团队视图并整表重拉。返回失败原因,null = 成功。
+ */
+ const runWorkerArchive = useCallback(async (
+ leadId: string,
+ worker: OrcaTeamWorker,
+ view: { dropWorker(worker: OrcaTeamWorker): () => void; refresh(): Promise<void> },
+ ): Promise<unknown> => {
+ const restoreView = view.dropWorker(worker);
+ const settle = beginOptimisticWorkerArchive(worker.sessionId, deviceId);
+ try {
+ await archiveOrcaWorker(makerRef.current, leadId, worker.workerId);
+ settle(true);
+ view.dropWorker(worker);
+ void view.refresh();
+ return null;
+ } catch (err) {
+ settle(false);
+ restoreView();
+ void view.refresh();
+ return err;
+ }
+ }, [deviceId]);
+
const openWorker = useCallback((worker: OrcaTeamWorker) => {
setSheetOpen(false);
// 看到「已完成」即确认(对齐桌面:可见的 done Worker 自动 acknowledge);状态已变则忽略。
@@ -628,15 +737,16 @@ export function useSessionOrcaCollab(params: {
text: i18n.t('session.collab.archiveConfirm'),
style: 'destructive',
onPress: () => {
- void runTeamAction(
- () => makerRef.current.orca.archiveWorker(sessionId, worker.workerId),
- 'session.collab.errors.archiveFailed',
- );
+ setError(null);
+ void runWorkerArchive(sessionId, worker, { dropWorker: dropTeamWorker, refresh: refreshTeam })
+ .then((err) => {
+ if (err) setError(describeOrcaError(err, 'session.collab.errors.archiveFailed'));
+ });
},
},
],
);
- }, [runTeamAction, sessionId]);
+ }, [dropTeamWorker, refreshTeam, runWorkerArchive, sessionId]);
/**
* 长按 Worker 行:管理操作(点按直接打开 Worker,不弹窗)。手机上只提供归档;「焦点」只决定
@@ -685,8 +795,12 @@ export function useSessionOrcaCollab(params: {
// ─── Worker 任务自身的操作(详情菜单) ─────────────────────────────────────
const refreshWorkerTeam = workerTeam.refresh;
+ const dropWorkerTeamWorker = workerTeam.dropWorker;
- /** 归档自身:确认弹窗在调用方的面板上直接弹出;用户确认后先调 onConfirmed(如收起详情面板)再归档。 */
+ /**
+ * 归档自身:确认弹窗在调用方的面板上直接弹出;用户确认后先调 onConfirmed(如收起详情面板),
+ * 立即回到 Lead(这个 Worker 任务即将不可用)并乐观归档;失败时 Worker 任务已插回,弹窗提示。
+ */
const confirmArchiveSelf = useCallback((onConfirmed?: () => void) => {
if (!workerLeadSessionId || !workerSelf) return;
const leadId = workerLeadSessionId;
@@ -701,34 +815,16 @@ export function useSessionOrcaCollab(params: {
style: 'destructive',
onPress: () => {
onConfirmed?.();
- void (async () => {
- try {
- await makerRef.current.orca.archiveWorker(leadId, worker.workerId);
- // 归档后这个 Worker 任务不再可用,回到 Lead。
- openSession(leadId);
- } catch (err) {
- if (isOrcaAmbiguousTimeout(err)) {
- // 超时不是权威失败:只读回查一次,Worker 已不在团队里就说明归档已生效,照样回到 Lead。
- const archived = await makerRef.current.orca.listWorkers(leadId)
- .then((raw) => !parseOrcaTeamWorkers(raw).some((item) => item.workerId === worker.workerId))
- .catch(() => false);
- if (archived) {
- openSession(leadId);
- return;
- }
- }
- Alert.alert(describeOrcaError(
- isOrcaAmbiguousTimeout(err) ? new Error('[ORCA_ACTION_UNCONFIRMED] timed out') : err,
- 'session.collab.errors.archiveFailed',
- ));
- void refreshWorkerTeam();
- }
- })();
+ openSession(leadId);
+ void runWorkerArchive(leadId, worker, { dropWorker: dropWorkerTeamWorker, refresh: refreshWorkerTeam })
+ .then((err) => {
+ if (err) Alert.alert(describeOrcaError(err, 'session.collab.errors.archiveFailed'));
+ });
},
},
],
);
- }, [openSession, refreshWorkerTeam, workerLeadSessionId, workerSelf]);
+ }, [dropWorkerTeamWorker, openSession, refreshWorkerTeam, runWorkerArchive, workerLeadSessionId, workerSelf]);
return {
eligible,
diff --git a/docs/dev-rules/orca-team-architecture.md b/docs/dev-rules/orca-team-architecture.md
index 5a2f842723..ea41ce1d87 100644
--- a/docs/dev-rules/orca-team-architecture.md
+++ b/docs/dev-rules/orca-team-architecture.md
@@ -51,7 +51,7 @@ Orca 是 Cindy Desktop 内的多 agent 协同能力:一个 **Lead session**
- workflow_run / CC Workflow 编排还未纳入当前实现。
- side_chat 尚未登记为 side activity 对象,也未挂进 pane;PR #107 只是 fork 数据动作。
- device-link 协同的 Lead / Worker / team 全部在被控端进程内编排,控制端只按 session 来源经隧道路由(`makerTransport` 的 `makerApiFor` / `orcaWorkflowsFor` / `subscribeOrcaWorkerChanged`,channel 见 `packages/device-link/src/allowlist.ts` 的 Orca 段)。collab 开关同样查被控端(`maker:plugins:get-state` 经 `pluginEnableStateFor`):项目读取被控端项目级策略,对话读取被控端用户级/全局级策略。控制端本机状态不能代表被控端真相。老被控端没有该 channel 时回 `CHANNEL_NOT_ALLOWED`,控制端 fail-closed 置灰入口并提示设备版本过旧,而不是放行到 `enableOrca` 才撞错。
-- 手机端是同一套 device-link 控制端:Lead / Worker 任务与普通任务一样可操作(发消息、处理确认、编辑队列、Fork / Rewind、任务设置),协同编排经 `apps/mobile/src/device-link/mobileMakerTransport.ts` 的 `orca` 组走与桌面控制端相同的 channel(开启 / 创建 / 确认完成 / 归档 / 结束、Worker 列表、协同设置只读);「焦点」只决定电脑端协同面板展开哪个 Worker,手机上既不展示也不提供切换。入口判定、超时回查与错误文案在 `apps/mobile/src/session/orcaTeam.ts`,会话页与新建任务页的状态在 `useSessionOrcaCollab.ts`。新建任务开启协同不走二段派单:createSession 后、首条消息入队前即时 `enable-orca`,Worker 任务按 `buildDraftWorkerInitialTask` 附带待发送的 Lead 输入作为上下文;失败时任务照单任务继续并在会话页提示。协同设置(Worker 上限、空闲释放)在手机上只读。「创建 Worker」的记忆规则与桌面 `workerCreationPrefs` 一致(上次的 Agent、每个 Agent 的模型 / 推理强度 / Fast、Worker 权限;初始任务不记;首次默认值共用 `@cindy/maker-shared/orca-team`),与桌面控制端一样存在发起创建的一端(`apps/mobile/src/session/orcaWorkerPrefs.ts`,按账号隔离),不读写被控端偏好;记住的模型不在该电脑可用列表时回落被控端默认。
+- 手机端是同一套 device-link 控制端:Lead / Worker 任务与普通任务一样可操作(发消息、处理确认、编辑队列、Fork / Rewind、任务设置),协同编排经 `apps/mobile/src/device-link/mobileMakerTransport.ts` 的 `orca` 组走与桌面控制端相同的 channel(开启 / 创建 / 确认完成 / 归档 / 结束、Worker 列表、协同设置只读);「焦点」只决定电脑端协同面板展开哪个 Worker,手机上既不展示也不提供切换。入口判定、超时回查与错误文案在 `apps/mobile/src/session/orcaTeam.ts`,会话页与新建任务页的状态在 `useSessionOrcaCollab.ts`。归档 Worker(协同面板长按与 Worker 自身菜单)乐观生效:点击当帧把 Worker 任务移出其物理 shard、从团队视图摘掉(归档自身同时立即回到 Lead),在途登记复用任务归档的 `sessionMetaWriteGuard` / `sessionPendingWrites`,在途期间推送、全量对账与单条 upsert 都不会把它带回;超时回查 Worker 已不在即按成功收口,否则回滚(插回同一 shard、恢复团队视图并 reseed)并提示。被控端 `archiveWorkerSession` 与普通归档一样只等 status 落库就回执,worktree 回收经 `scheduleWorktreeRecycleForStatusChange` 放后台。新建任务开启协同不走二段派单:createSession 后、首条消息入队前即时 `enable-orca`,Worker 任务按 `buildDraftWorkerInitialTask` 附带待发送的 Lead 输入作为上下文;失败时任务照单任务继续并在会话页提示。协同设置(Worker 上限、空闲释放)在手机上只读。「创建 Worker」的记忆规则与桌面 `workerCreationPrefs` 一致(上次的 Agent、每个 Agent 的模型 / 推理强度 / Fast、Worker 权限;初始任务不记;首次默认值共用 `@cindy/maker-shared/orca-team`),与桌面控制端一样存在发起创建的一端(`apps/mobile/src/session/orcaWorkerPrefs.ts`,按账号隔离),不读写被控端偏好;记住的模型不在该电脑可用列表时回落被控端默认。
- SSH 远端协同支持 Claude Code、Codex 与 Pi Lead / Worker;Worker 继承 Lead 的 `remoteHostId` 与远端工作目录,在同一台远端主机执行,启动前复用远端就绪检查。cc 远端经 `cc-remote-mcp.ts` 把 `cindy_orca` / `orca_worker_bridge` 以 http 形态追加进 `startParams.mcpServers`(persistent token + `?session=` 路由,白名单仅此两个 server)。远端 worker 手动 `send_to_lead` 依赖 daemon 侧 `orca_worker_bridge` 经同一 bridge 可达;auto-bridge 回报不依赖 worker 侧 MCP,天然可用。Claude Code / Codex 共享 userData 多实例连同一远端 host 时,只有先建立 SSH 转发的实例能持有该 host 的 MCP bridge 端口,其余实例按“远端无 MCP”降级(与历史行为一致)。远端会话的项目级 collab 开关不查本机 fs;`assertCollabProjectEnabled` 对 remote 只查用户级/全局级开关,远端项目级配置机制是 follow-up。
Pi 的远端 Lead 沿用统一的 Lead 身份与 prompt 装配;内部 MCP(含 `cindy_orca`、