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。

Merge remote-tracking branch 'upstream/main' into fix/orca-focus-async-resume

Zhang Yunjin6973045e0f13
diff --cc apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
index 133e21abfd,198c39f6e6..077131da1b
--- a/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
+++ b/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
@@@ -778,34 -778,9 +778,32 @@@ describe('sendToSession ordering', () =
);
expectOrder(resumeBranch, '...directoryGrantsForRuntime(storedExtraDirs),', 'await bootstrapSession(opts);');
expect(serviceDepsBlock).toContain('resumeWorkerSession: async (target) => {');
- expect(serviceDepsBlock).toContain('await resumeOrcaWorkerSessionIfMissing(target);');
- expect(switchFocusIpcBlock).toContain('const didResume = await resumeOrcaWorkerSessionIfMissing(target);');
- expect(switchFocusMcpBlock).toContain('await resumeOrcaWorkerSessionIfMissing(target);');
+ expect(serviceDepsBlock).toContain('await orcaWorkerResumeScheduler.request(target);');
+ // focus 切换是纯 UI 操作:resume 只能后台调度,不能在 IPC / MCP handler 里同步 await
- // 冷启动(首次切 dormant worker 的 ~5s 卡顿回归点)。
- expect(switchFocusIpcBlock).toContain(
- 'orcaWorkerResumeScheduler.requestInBackground(target, (err) => {',
- );
++ // 冷启动(首次切 dormant worker 的 ~5s 卡顿回归点)。MCP 路径仍透传 assertCurrent,
++ // 权威校验在后台预热内部继续生效。
++ expect(switchFocusIpcBlock).toContain('orcaWorkerResumeScheduler.requestInBackground(target,');
+ expect(switchFocusIpcBlock).not.toContain('await resumeOrcaWorkerSessionIfMissing(target)');
- expect(switchFocusMcpBlock).toContain(
- 'orcaWorkerResumeScheduler.requestInBackground(target, (err) => {',
- );
- expect(switchFocusMcpBlock).not.toContain('await resumeOrcaWorkerSessionIfMissing(target)');
++ expect(switchFocusMcpBlock).toContain('orcaWorkerResumeScheduler.requestInBackground(');
++ expect(switchFocusMcpBlock).toContain('{ assertCurrent },');
++ expect(switchFocusMcpBlock).not.toContain('await resumeOrcaWorkerSessionIfMissing(target');
+ // 关闭协同 / 归档 / 显式 idle 与冷启动交错时,唤醒必须可取消,并在 bootstrap
+ // 返回后关掉刚拉起的 session(review P1:不得把已归档 worker 留在运行态)。
- expect(resumeBranch).toContain('if (resumeOpts?.isCancelled?.()) return false;');
++ expect(resumeBranch).toContain('if (isCancelled?.()) return false;');
+ expect(resumeBranch).toContain('await maker.closeSession(resumedSession.id).catch((err) => {');
+ expect(serviceDepsBlock).toContain(
+ 'cancelWorkerResume: (sessionId) => orcaWorkerResumeScheduler.cancel(sessionId),',
+ );
+ });
+
+ it('cancels pending worker resumes before releasing runtimes', () => {
+ const disableOrcaBlock = extractBetween(
+ source,
+ 'async function disableOrcaInternal',
+ 'ipcMain.handle(MAKER_INVOKE.SESSION_DISABLE_ORCA',
+ );
+ expect(disableOrcaBlock).toContain('orcaWorkerResumeScheduler.cancel(w.sessionId);');
+ expect(orcaTeamServiceSource).toContain('deps.cancelWorkerResume?.(worker.sessionId);');
});
it('keeps IPC and MCP createWorker delegated to the shared lifecycle service', () => {
diff --cc apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
index 24f18e78e2,1f3ab4f788..5c659681c1
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
@@@ -34,6 -39,131 +39,147 @@@ function createWorker(overrides: Partia
};
}
+ describe('model Orca cleanup authority', () => {
+ const source = readFileSync(new URL('../register.ts', import.meta.url), 'utf8');
+ const callbacks = source.slice(source.indexOf(' switchFocus: async ('), source.indexOf(' listAvailableModels: async ('));
+ const disable = source.slice(source.indexOf(' async function clearLeadOrcaRoleState('), source.indexOf(' ipcMain.handle(MAKER_INVOKE.SESSION_DISABLE_ORCA'));
+ function compile(bindings: Record<string, unknown>, text = `return ({${callbacks}});`) {
+ return new Function(...Object.keys(bindings), ts.transpileModule(text, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText)(...Object.values(bindings));
+ }
+ it.each(['idleWorker', 'archiveWorker'].flatMap(action => ['revoked', 'close-error', 'healthy'].map(outcome => ({ action, outcome }))))(
+ 'preserves $action close semantics after abort: $outcome', async ({ action, outcome }) => {
+ let allowed = true;
+ const assertCurrent = async () => { if (!allowed) throw Error('Revoked'); };
+ const from = source.indexOf(' closeWorkerSession: async (sessionId, beforeClose)');
+ const to = source.indexOf(' closeWorkerSessionIfIdle:', from);
+ expect(from).toBeGreaterThan(0); expect(to).toBeGreaterThan(from);
+ const closeSession = vi.fn(async () => { if (outcome === 'close-error') throw Error('ordinary close error'); });
+ const adapter = compile({ maker: {
+ getSession: () => ({ abort: async () => { allowed = outcome !== 'revoked'; } }), closeSession,
+ } }, `return ({${source.slice(from, to)}});`);
+ const { deps, service, setWorker } = createDeps(adapter);
+ setWorker(createWorker({ status: 'running' }));
+ const result = action === 'idleWorker'
+ ? service.idleWorker({ callerLeadSessionId: 'lead-1', workerId: 'worker-1' }, { assertCurrent })
+ : service.archiveWorker({ callerLeadSessionId: 'lead-1', workerId: 'worker-1', beforeArchive: assertCurrent });
+ if (outcome === 'revoked') {
+ await expect(result).rejects.toThrow('Revoked');
+ expect(closeSession).not.toHaveBeenCalled();
+ expect(deps.archiveWorkerSession).not.toHaveBeenCalled();
+ } else {
+ await expect(result).resolves.toMatchObject({ ok: true });
+ expect(closeSession).toHaveBeenCalledOnce();
+ expect(deps.archiveWorkerSession).toHaveBeenCalledTimes(action === 'archiveWorker' ? 1 : 0);
+ }
+ },
+ );
+ it.each(['turn', 'send'].flatMap(reason => ['guarded', 'guarded-user', 'user-guarded', 'healthy'].map(order => ({ reason, order }))))(
+ 'retains $reason deferred acknowledgement authority for $order', async ({ reason, order }) => {
+ let busy = true, allowed = true;
+ const assertCurrent = async () => { if (!allowed) throw Error('Revoked'); };
+ const { service, deps, setWorker, getWorker } = createDeps({
+ getLiveSession: () => ({ isTurnRunning: () => reason === 'turn' && busy }),
+ hasSendToSessionLock: () => reason === 'send' && busy,
+ });
+ setWorker(createWorker({ status: 'done' }));
+ for (const caller of order.split('-')) {
+ await service.idleWorker({ callerLeadSessionId: 'lead-1', workerId: 'worker-1', expectedStatus: 'done' }, caller === 'user' ? undefined : { assertCurrent });
+ }
+ busy = false; allowed = order === 'healthy';
+ await service.handleWorkerTerminalTurn({ sessionId: 'worker-session-1', status: 'done', finalText: 'finished' });
+ expect(getWorker().status).toBe(order === 'guarded' ? 'done' : 'idle');
+ const closes = vi.mocked(deps.closeWorkerSessionIfIdle).mock.calls.length;
+ await service.handleWorkerTerminalTurn({ sessionId: 'worker-session-1', status: 'done', finalText: 'finished' });
+ expect(deps.closeWorkerSessionIfIdle).toHaveBeenCalledTimes(closes);
+ },
+ );
+ it('restores done when authority is revoked during the acknowledgement write', async () => {
+ let allowed = true;
+ const { deps, service, setWorker, getWorker } = createDeps();
+ setWorker(createWorker({ status: 'done' }));
+ const mark = deps.markWorkerIdleIfStatus;
+ deps.markWorkerIdleIfStatus = async (...args) => { const result = await mark(...args); allowed = false; return result; };
+ await expect(service.idleWorker({ callerLeadSessionId: 'lead-1', workerId: 'worker-1', expectedStatus: 'done' },
+ { assertCurrent: async () => { if (!allowed) throw Error('Revoked'); } })).rejects.toThrow('Revoked');
+ expect(getWorker().status).toBe('done');
+ expect(deps.closeWorkerSessionIfIdle).not.toHaveBeenCalled();
+ });
+
+ it.each(['idleWorker', 'archiveWorker', 'switchFocus'].flatMap(action => ['admission', 'lookup', 'after-write', 'healthy'].map(phase => ({ action, phase }))))(
+ 'guards model $action at $phase', async ({ action, phase }) => {
+ let allowed = phase !== 'admission';
+ const assertCurrent = async () => { if (!allowed) throw Error('Revoked'); };
+ const { deps, service, setWorker } = createDeps();
+ setWorker(createWorker({ status: action === 'switchFocus' ? 'idle' : 'running' }));
+ const list = deps.listWorkersByLead;
+ deps.listWorkersByLead = vi.fn(async id => { const result = await list(id); if (phase === 'lookup') allowed = false; return result; });
+ const mark = deps.markWorkerIdle;
+ deps.markWorkerIdle = vi.fn(async id => { await mark(id); if (phase === 'after-write') allowed = false; });
+ deps.cancelWorkerSessionOperations = vi.fn(async () => { if (phase === 'after-write') allowed = false; });
+ const focus = vi.fn(async () => { if (phase === 'after-write') allowed = false; });
+ const resume = vi.fn(async () => undefined);
++ // switch_focus 的冷启预热现在走共享调度器(MCP 与 renderer 两条路径一致):
++ // 权威校验留在同步路径(撤销则整个 switchFocus 失败,与上游一致),调度器
++ // 只负责不阻塞。这里同步触发 resume 保持断言确定性,错误交给 onError。
++ const orcaWorkerResumeScheduler = {
++ requestInBackground: (
++ _target: unknown,
++ onError: (error: unknown) => void,
++ opts?: { assertCurrent?: () => Promise<void> },
++ ) => {
++ void opts?.assertCurrent?.().catch(onError);
++ void resume().catch(onError);
++ },
++ };
+ const api = compile({
+ captureOrcaPluginAuthority: async () => { await assertCurrent(); return { assertCurrent }; },
+ orcaTeamService: service, listWorkersByLead: deps.listWorkersByLead, findFocusTargetWorker,
+ setWorkerFocus: focus, resumeOrcaWorkerSessionIfMissing: resume,
++ orcaWorkerResumeScheduler, log: { warn: vi.fn() },
+ broadcastToAllWindows: vi.fn(), MAKER_PUSH: { ORCA_WORKER_CHANGED: 'changed' },
+ });
+ const result = await api[action]({ callerLeadSessionId: 'lead-1', leadSessionId: 'lead-1', workerId: 'worker-1', workerIdOrLabel: 'worker-1' });
+ expect(result.ok).toBe(phase === 'healthy');
+ const effect = action === 'switchFocus' ? resume : deps.closeWorkerSession;
+ expect(effect).toHaveBeenCalledTimes(phase === 'healthy' ? 1 : 0);
+ if (phase !== 'healthy') expect(deps.archiveWorkerSession).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each([true, false].flatMap(team => ['admission', 'lookup', 'before-close', 'healthy', 'user'].map(phase => ({ team, phase }))))(
+ 'guards model endTeam with team=$team at $phase, preserving direct user cleanup', async ({ team, phase }) => {
+ let allowed = phase !== 'admission' && phase !== 'user';
+ const assertCurrent = async () => { if (!allowed) throw Error('Revoked'); };
+ const close = vi.fn(async () => undefined), archive = vi.fn(async () => []);
+ const bindings = {
+ captureOrcaPluginAuthority: async () => { await assertCurrent(); return { assertCurrent }; },
+ getActiveTeamByLead: async () => team ? { id: 'team-1' } : null,
+ getSessionOrcaRole: async () => { if (phase === 'lookup') allowed = false; return 'lead'; },
+ listWorkersByLead: async () => { if (phase === 'lookup') allowed = false; return [createWorker()]; },
+ maker: { getSession: () => ({ isTurnRunning: () => false, setVendorOptions: vi.fn() }), closeSession: close },
+ orcaTeamService: { clearAutoBridgeState: vi.fn() },
+ cancelIOSSimulatorSessionOperations: async () => { if (phase === 'before-close') allowed = false; },
+ setSessionOrcaRole: vi.fn(), knownNonOrcaSessionIds: new Set(),
+ reconcileInactiveTeamWorkersForLead: vi.fn(async () => { if (phase === 'before-close') allowed = false; return ['worker-session-1']; }),
+ recycleSessionWorktreeForStatusChange: vi.fn(), captureSessionRecycleScope: vi.fn(),
+ cleanupPendingInteractionsForSession: vi.fn(), forgetKnownOrcaWorkerSession: vi.fn(),
+ markTeamEnded: vi.fn(), markWorkersStatusByTeam: vi.fn(), archiveWorkersByTeam: archive,
++ // 关闭协同会先取消未落地的后台预热(review P1)。
++ orcaWorkerResumeScheduler: { cancel: vi.fn() },
+ broadcastToAllWindows: vi.fn(), MAKER_PUSH: { ORCA_WORKER_CHANGED: 'changed' }, log: { info: vi.fn(), warn: vi.fn() },
+ };
+ const api = compile(bindings, `${disable}\nreturn { api: {${callbacks}}, disableOrcaInternal };`);
+ const result = phase === 'user' ? await api.disableOrcaInternal('lead-1') : await api.api.endTeam({ leadSessionId: 'lead-1' });
+ expect(result.ok).toBe(['healthy', 'user'].includes(phase));
+ if (!['healthy', 'user'].includes(phase)) {
+ expect(close).not.toHaveBeenCalled();
+ expect(archive).not.toHaveBeenCalled();
+ expect(bindings.setSessionOrcaRole).not.toHaveBeenCalled();
+ }
+ },
+ );
+ });
+
describe('findFocusTargetWorker', () => {
const a = createWorker({ id: 'wid-a', sessionId: 'sid-a', label: 'tester' });
const b = createWorker({ id: 'wid-b', sessionId: 'sid-b', label: 'dev' });
diff --cc apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerResumeScheduler.test.ts
index b023ef2add,0000000000..a3d9a683c2
mode 100644,000000..100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerResumeScheduler.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerResumeScheduler.test.ts
@@@ -1,198 -1,0 +1,216 @@@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createOrcaWorkerResumeScheduler } from '../orcaWorkerResumeScheduler';
+
+describe('createOrcaWorkerResumeScheduler', () => {
+ it('shares one in-flight resume per session and clears it when settled', async () => {
+ let release!: (value: boolean) => void;
+ const resume = vi.fn(
+ () =>
+ new Promise<boolean>((resolve) => {
+ release = resolve;
+ }),
+ );
+ const scheduler = createOrcaWorkerResumeScheduler({
+ resume,
+ withSessionLock: (_sessionId, task) => task(),
+ });
+
+ const first = scheduler.request({ sessionId: 'worker-1' });
+ const second = scheduler.request({ sessionId: 'worker-1' });
+
+ expect(second).toBe(first);
+ expect(scheduler.pendingCount()).toBe(1);
+ expect(resume).toHaveBeenCalledTimes(1);
+
+ release(true);
+ await expect(first).resolves.toBe(true);
+ expect(scheduler.pendingCount()).toBe(0);
+
+ // A settled entry must not be reused: the next request starts a fresh resume.
+ resume.mockResolvedValueOnce(false);
+ await expect(scheduler.request({ sessionId: 'worker-1' })).resolves.toBe(false);
+ expect(resume).toHaveBeenCalledTimes(2);
+ });
+
+ it('runs resume inside the injected per-session lock', async () => {
+ let releaseLock!: () => void;
+ const lockGate = new Promise<void>((resolve) => {
+ releaseLock = resolve;
+ });
+ let lockEntered = false;
+ const resume = vi.fn(async () => true);
+ const scheduler = createOrcaWorkerResumeScheduler({
+ resume,
+ withSessionLock: async (_sessionId, task) => {
+ lockEntered = true;
+ await lockGate;
+ return task();
+ },
+ });
+
+ const pending = scheduler.request({ sessionId: 'worker-1' });
+ await Promise.resolve();
+
+ expect(lockEntered).toBe(true);
+ expect(resume).not.toHaveBeenCalled();
+
+ releaseLock();
+ await expect(pending).resolves.toBe(true);
+ expect(resume).toHaveBeenCalledTimes(1);
+ });
+
+ it('resumes different sessions without coupling them', async () => {
+ const releases = new Map<string, (value: boolean) => void>();
+ const resume = vi.fn(
+ (target: { sessionId: string }) =>
+ new Promise<boolean>((resolve) => {
+ releases.set(target.sessionId, resolve);
+ }),
+ );
+ const scheduler = createOrcaWorkerResumeScheduler({
+ resume,
+ withSessionLock: (_sessionId, task) => task(),
+ });
+
+ const first = scheduler.request({ sessionId: 'worker-1' });
+ const second = scheduler.request({ sessionId: 'worker-2' });
+
+ expect(resume).toHaveBeenCalledTimes(2);
+ expect(scheduler.pendingCount()).toBe(2);
+
+ releases.get('worker-2')?.(true);
+ await expect(second).resolves.toBe(true);
+ expect(scheduler.pendingCount()).toBe(1);
+
+ releases.get('worker-1')?.(false);
+ await expect(first).resolves.toBe(false);
+ expect(scheduler.pendingCount()).toBe(0);
+ });
+
+ it('reports background failures without rejecting and retries next time', async () => {
+ const onError = vi.fn();
+ const resume = vi
+ .fn(async () => true)
+ .mockRejectedValueOnce(new Error('boot failed'))
+ .mockResolvedValueOnce(true);
+ const scheduler = createOrcaWorkerResumeScheduler({
+ resume,
+ withSessionLock: (_sessionId, task) => task(),
+ });
+
+ expect(() => scheduler.requestInBackground({ sessionId: 'worker-1' }, onError)).not.toThrow();
+ await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+ expect(scheduler.pendingCount()).toBe(0);
+
+ await expect(scheduler.request({ sessionId: 'worker-1' })).resolves.toBe(true);
+ expect(resume).toHaveBeenCalledTimes(2);
+ });
+
+ it('aborts a cancelled resume before it starts booting', async () => {
+ let releaseLock!: () => void;
+ const lockGate = new Promise<void>((resolve) => {
+ releaseLock = resolve;
+ });
+ const resume = vi.fn(async (_target: unknown, isCancelled: () => boolean) => {
+ return !isCancelled();
+ });
+ const scheduler = createOrcaWorkerResumeScheduler({
+ resume,
+ withSessionLock: async (_sessionId, task) => {
+ await lockGate;
+ return task();
+ },
+ });
+
+ const pending = scheduler.request({ sessionId: 'worker-1' });
+ await Promise.resolve();
+ scheduler.cancel('worker-1');
+ releaseLock();
+
+ await expect(pending).resolves.toBe(false);
+ expect(resume).toHaveBeenCalledTimes(1);
+ expect(resume.mock.calls[0]?.[1]?.()).toBe(true);
+ expect(scheduler.pendingCount()).toBe(0);
+ });
+
+ it('lets the resume implementation observe cancellation after bootstrap', async () => {
+ let releaseBoot!: () => void;
+ const bootGate = new Promise<void>((resolve) => {
+ releaseBoot = resolve;
+ });
+ const resume = vi.fn(async (_target: unknown, isCancelled: () => boolean) => {
+ await bootGate;
+ return !isCancelled();
+ });
+ const scheduler = createOrcaWorkerResumeScheduler({
+ resume,
+ withSessionLock: (_sessionId, task) => task(),
+ });
+
+ const pending = scheduler.request({ sessionId: 'worker-1' });
+ await Promise.resolve();
+ scheduler.cancel('worker-1');
+ releaseBoot();
+
+ await expect(pending).resolves.toBe(false);
+ expect(scheduler.pendingCount()).toBe(0);
+ });
+
+ it('keeps a cancelled in-flight entry deduplicated until it settles', async () => {
+ let releaseLock!: () => void;
+ const lockGate = new Promise<void>((resolve) => {
+ releaseLock = resolve;
+ });
+ const resume = vi.fn(async (_target: unknown, isCancelled: () => boolean) => !isCancelled());
+ const scheduler = createOrcaWorkerResumeScheduler({
+ resume,
+ withSessionLock: async (_sessionId, task) => {
+ await lockGate;
+ return task();
+ },
+ });
+
+ const first = scheduler.request({ sessionId: 'worker-1' });
+ await Promise.resolve();
+ scheduler.cancel('worker-1');
+ const second = scheduler.request({ sessionId: 'worker-1' });
+ expect(second).toBe(first);
+ expect(resume).toHaveBeenCalledTimes(0);
+
+ releaseLock();
+ await expect(first).resolves.toBe(false);
+ expect(scheduler.pendingCount()).toBe(0);
+
+ // A settled cancelled entry must not poison the next request.
+ await expect(scheduler.request({ sessionId: 'worker-1' })).resolves.toBe(true);
+ expect(resume).toHaveBeenCalledTimes(2);
+ });
+
++ it('forwards the authority check guard into the resume implementation', async () => {
++ const assertCurrent = vi.fn(async () => undefined);
++ const resume = vi.fn(
++ async (_target: unknown, _isCancelled: () => boolean, _assertCurrent?: () => Promise<void>) =>
++ true,
++ );
++ const scheduler = createOrcaWorkerResumeScheduler({
++ resume,
++ withSessionLock: (_sessionId, task) => task(),
++ });
++
++ scheduler.requestInBackground({ sessionId: 'worker-1' }, () => undefined, { assertCurrent });
++
++ await vi.waitFor(() => expect(resume).toHaveBeenCalledTimes(1));
++ expect(resume.mock.calls[0]?.[2]).toBe(assertCurrent);
++ expect(scheduler.pendingCount()).toBe(0);
++ });
++
+ it('ignores cancel for sessions without an in-flight resume', () => {
+ const scheduler = createOrcaWorkerResumeScheduler({
+ resume: async () => true,
+ withSessionLock: (_sessionId, task) => task(),
+ });
+ expect(() => scheduler.cancel('worker-1')).not.toThrow();
+ expect(scheduler.pendingCount()).toBe(0);
+ });
+});
diff --cc apps/desktop/src/main/maker-ipc/orcaTeamService.ts
index 235a2040f2,1ddca03a78..8e86339209
--- a/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
@@@ -1197,11 -1251,10 +1253,12 @@@ export function createOrcaTeamService(d
};
}
}
+ // 显式 idle 会释放 runtime;先取消未落地的后台预热,避免释放后被重新拉起。
+ deps.cancelWorkerResume?.(worker.sessionId);
+ await assertAfterIdle();
clearRuntimeState(worker.sessionId);
if (!params.expectedStatus) {
- await closeWorkerSessionBestEffort(worker.sessionId, 'idleWorker');
+ await closeWorkerSessionBestEffort(worker.sessionId, 'idleWorker', opts?.assertCurrent);
}
deferredDoneAcknowledgements.delete(worker.id);
deps.broadcastOrcaWorkerChanged(link.leadSessionId);
@@@ -1235,11 -1298,11 +1302,13 @@@
clearRuntimeState(worker.sessionId);
deps.forgetWorkerSession?.(worker.sessionId);
deferredDoneAcknowledgements.delete(worker.id);
+ // 归档会释放 runtime;先取消未落地的后台预热,避免归档后被重新拉起(review P1)。
+ deps.cancelWorkerResume?.(worker.sessionId);
await deps.cancelWorkerSessionOperations(worker.sessionId);
- await closeWorkerSessionBestEffort(worker.sessionId, 'archiveWorker');
- await deps.archiveWorkerSession(worker.sessionId);
+ await params.beforeArchive?.();
+ await closeWorkerSessionBestEffort(worker.sessionId, 'archiveWorker', params.beforeArchive);
+ await params.beforeArchive?.();
+ await deps.archiveWorkerSession(worker.sessionId, params.beforeArchive);
// The archived status is the admission barrier for new Host work. Cancel
// once more after publishing it to catch a build that registered between
// the pre-close cancellation and the status transition.
diff --cc apps/desktop/src/main/maker-ipc/orcaWorkerResumeScheduler.ts
index b03e90ef5e,0000000000..63b150e20d
mode 100644,000000..100644
--- a/apps/desktop/src/main/maker-ipc/orcaWorkerResumeScheduler.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaWorkerResumeScheduler.ts
@@@ -1,94 -1,0 +1,115 @@@
+/**
+ * orcaWorkerResumeScheduler —— 「冷 Worker 唤醒」的进程内调度器。
+ *
+ * 背景(2026-09 实报:协同里第一次切到某个 dormant worker 要等 ~5s,第二次很快):
+ * `switch_focus` 过去在 IPC / MCP handler 里同步 `await resumeOrcaWorkerSessionIfMissing`,
+ * 而 focus 切换是纯 UI 操作 —— 冷会话会 spawn 整个 agent runtime(Pi 实测 2~3s,含 MCP
+ * gateway)才返回,面板切换被冷启动阻塞。唤醒本身仍然需要(发送、派活都依赖 live
+ * runtime),但它可以后台化:worker 历史来自 DB,不需要 runtime。
+ *
+ * 本调度器给出三个保证:
+ * 1. per-session 去重:并发的 focus 切换 / 派活共享同一次 resume,不会把同一个会话
+ * bootstrap 两次(两个调用方都会看到同一结果);
+ * 2. 与发送路径共用同一把 per-session 锁(由调用方注入 `withSessionLock`,main 侧注入
+ * `withSendToSessionLock`):resume 期间到达的发送排在锁后;发送先持锁完成 lazy
+ * bootstrap 时,resume 在锁内重查 live 并直接跳过;
+ * 3. 可取消:关闭协同 / 归档 / 显式 idle 等释放路径通过 `cancel` 取消尚未落地的唤醒。
+ * 等锁中的唤醒直接放弃;已经在冷启动的由 `resume` 实现按 `isCancelled` 在
+ * bootstrap 返回后关掉刚起的 session,避免把已归档 worker 重新拉活。
+ *
+ * 唤醒实现与锁都由调用方注入,逻辑本身可单测。
+ */
+
+/** 调度所需的 worker 身份;真实调用点传完整 worker 记录,只要求 sessionId 稳定。 */
+export interface OrcaWorkerResumeTarget {
+ sessionId: string;
+}
+
+export interface OrcaWorkerResumeSchedulerDeps<Target extends OrcaWorkerResumeTarget> {
+ /**
+ * 真正的唤醒实现;返回是否真的启动了 runtime(已 live 时 false)。
+ * `isCancelled` 在释放路径取消本次唤醒后变为 true:实现必须在冷启动前检查一次,
+ * 并在 bootstrap 返回后再检查一次——已启动的 session 要自己关掉。
++ * `assertCurrent` 是能力权威校验,同样在冷启动前 / bootstrap 后各校验一次。
+ */
- resume(target: Target, isCancelled: () => boolean): Promise<boolean>;
++ resume(
++ target: Target,
++ isCancelled: () => boolean,
++ assertCurrent?: () => Promise<void>,
++ ): Promise<boolean>;
+ /** per-session 串行锁;必须与发送路径共用同一把。 */
+ withSessionLock<T>(sessionId: string, task: () => Promise<T>): Promise<T>;
+}
+
++/** 单次唤醒请求的附加守卫;去重期间以首个请求的 options 为准。 */
++export interface OrcaWorkerResumeRequestOptions {
++ /** 能力权威校验;失效(throw)即放弃本次唤醒。 */
++ assertCurrent?: () => Promise<void>;
++}
++
+export interface OrcaWorkerResumeScheduler<Target extends OrcaWorkerResumeTarget> {
+ /** 去重 + 串行的 resume;需要结果的调用方 await 它。 */
- request(target: Target): Promise<boolean>;
++ request(target: Target, opts?: OrcaWorkerResumeRequestOptions): Promise<boolean>;
+ /**
+ * 后台唤醒:不阻塞调用方,错误只经 onError 上报(避免 unhandled rejection)。
+ * focus 切换用这个入口,resume 结果不构成切换成功与否的一部分。
+ */
- requestInBackground(target: Target, onError: (error: unknown) => void): void;
++ requestInBackground(
++ target: Target,
++ onError: (error: unknown) => void,
++ opts?: OrcaWorkerResumeRequestOptions,
++ ): void;
+ /**
+ * 取消该 session 尚未落地的唤醒。取消不删除 in-flight 条目——条目要等真正 settle,
+ * 期间新的 request 仍复用它,避免同一会话被 boot 两次;settle 之后的新请求照常重试。
+ */
+ cancel(sessionId: string): void;
+ /** 诊断/测试用:当前处于 in-flight 的 session 数。 */
+ pendingCount(): number;
+}
+
+interface InFlightResume {
+ cancelled: boolean;
+ promise: Promise<boolean>;
+}
+
+export function createOrcaWorkerResumeScheduler<Target extends OrcaWorkerResumeTarget>(
+ deps: OrcaWorkerResumeSchedulerDeps<Target>,
+): OrcaWorkerResumeScheduler<Target> {
+ const inFlight = new Map<string, InFlightResume>();
+
- function request(target: Target): Promise<boolean> {
++ function request(target: Target, opts?: OrcaWorkerResumeRequestOptions): Promise<boolean> {
+ const existing = inFlight.get(target.sessionId);
+ if (existing) return existing.promise;
+ const entry: InFlightResume = {
+ cancelled: false,
+ promise: Promise.resolve(false),
+ };
+ // 锁在 resume 内部持有整个冷启动窗口:与发送、idle 释放等同一 session 的 critical
+ // section 串行;失败也要清掉 in-flight,让下一次 focus / 派活可以重试。
+ entry.promise = deps
- .withSessionLock(target.sessionId, () => deps.resume(target, () => entry.cancelled))
++ .withSessionLock(target.sessionId, () =>
++ deps.resume(target, () => entry.cancelled, opts?.assertCurrent),
++ )
+ .finally(() => {
+ if (inFlight.get(target.sessionId) === entry) inFlight.delete(target.sessionId);
+ });
+ inFlight.set(target.sessionId, entry);
+ return entry.promise;
+ }
+
- function requestInBackground(target: Target, onError: (error: unknown) => void): void {
- void request(target).catch(onError);
++ function requestInBackground(
++ target: Target,
++ onError: (error: unknown) => void,
++ opts?: OrcaWorkerResumeRequestOptions,
++ ): void {
++ void request(target, opts).catch(onError);
+ }
+
+ function cancel(sessionId: string): void {
+ const entry = inFlight.get(sessionId);
+ if (entry) entry.cancelled = true;
+ }
+
+ return { request, requestInBackground, cancel, pendingCount: () => inFlight.size };
+}
diff --cc apps/desktop/src/main/maker-ipc/register.ts
index 81807a90db,0356fe8450..7a946c0c08
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@@ -7373,20 -7498,14 +7499,22 @@@ export function registerMakerIpc(maker
}
// switchFocus 和 sendToWorker 都可能唤醒 idle worker;统一走这里才能保留 extraDirs。
- // resumeOpts.isCancelled:关闭协同 / 归档 / 显式 idle 会取消尚未落地的唤醒;冷启动前与
- async function resumeOrcaWorkerSessionIfMissing(target: {
- id: string;
- teamId: string;
- leadSessionId: string;
- sessionId: string;
- }, assertCurrent?: () => Promise<void>): Promise<boolean> {
++ // assertCurrent:插件能力权威校验,冷启动前 / bootstrap 后各一次。
++ // isCancelled:关闭协同 / 归档 / 显式 idle 会取消尚未落地的唤醒;冷启动前与
+ // bootstrap 返回后都要检查,已经拉起的 runtime 要自己关掉(review P1)。
+ async function resumeOrcaWorkerSessionIfMissing(
+ target: {
+ id: string;
+ teamId: string;
+ leadSessionId: string;
+ sessionId: string;
+ },
- resumeOpts?: { isCancelled?: () => boolean },
++ assertCurrent?: () => Promise<void>,
++ isCancelled?: () => boolean,
+ ): Promise<boolean> {
const live = maker.getSession(target.sessionId);
if (live) return false;
- if (resumeOpts?.isCancelled?.()) return false;
++ if (isCancelled?.()) return false;
const db = getDbClient().drizzle;
const [row] = await db
@@@ -7395,9 -7514,6 +7523,9 @@@
.where(eq(sessions.id, target.sessionId))
.limit(1);
if (!row) return false;
+ // 归档 / 删除后的 worker 不允许被唤醒:关闭协同与 archive 可能和后台预热交错。
+ if (row.status !== 'active') return false;
- if (resumeOpts?.isCancelled?.()) return false;
++ if (isCancelled?.()) return false;
const workerVendorOptions = {
orcaRole: 'worker' as const,
@@@ -7427,68 -7543,15 +7555,76 @@@
...directoryGrantsForRuntime(storedExtraDirs),
...(writableDirs.length > 0 ? { writableDirs } : {}),
});
+ await assertCurrent?.();
await ensureRemoteReadyForSessionStart({ createOpts: opts });
- if (resumeOpts?.isCancelled?.()) return false;
+ await assertCurrent?.();
++ if (isCancelled?.()) return false;
const { session: resumedSession } = await bootstrapSession(opts);
+ await assertCurrent?.();
+ // 关闭协同 / 归档 / 显式 idle 可能和冷启动交错:bootstrap 返回后必须重新确认这次
+ // 唤醒仍然有效,否则关掉刚拉起的 runtime,不能把已归档 worker 留在运行态。
- if (resumeOpts?.isCancelled?.() || !(await isOrcaWorkerSessionResumable(target.sessionId))) {
++ if (isCancelled?.() || !(await isOrcaWorkerSessionResumable(target.sessionId))) {
+ await maker.closeSession(resumedSession.id).catch((err) => {
+ log.warn('orcaWorkerResume: cancelled after bootstrap, close failed', {
+ sessionId: resumedSession.id,
+ err: err instanceof Error ? err.message : String(err),
+ });
+ });
+ return false;
+ }
await markOrcaRoleIfNeeded(resumedSession.id, 'worker');
return true;
}
+ /** 唤醒后的会话仍必须是 active;读不到状态按不可唤醒处理(fail-closed)。 */
+ async function isOrcaWorkerSessionResumable(sessionId: string): Promise<boolean> {
+ try {
+ const [row] = await getDbClient()
+ .drizzle.select({ status: sessions.status })
+ .from(sessions)
+ .where(eq(sessions.id, sessionId))
+ .limit(1);
+ return row?.status === 'active';
+ } catch (err) {
+ log.warn('orcaWorkerResume: read session status failed', {
+ sessionId,
+ err: err instanceof Error ? err.message : String(err),
+ });
+ return false;
+ }
+ }
+
+ // focus 切换是纯 UI 操作,不再同步等待冷启动(2026-09 实报: 首次切到 dormant worker
+ // 要等 ~5s)。resume 仍要发生,但转后台并走共享调度器: per-session 去重 + 与发送路径
+ // 共用 sendToSession 锁,避免并发双 bootstrap(实现与不变量见 orcaWorkerResumeScheduler.ts)。
+ const orcaWorkerResumeScheduler = createOrcaWorkerResumeScheduler({
+ resume: async (
+ target: {
+ id: string;
+ teamId: string;
+ leadSessionId: string;
+ sessionId: string;
+ },
+ isCancelled,
++ assertCurrent,
+ ) => {
- const didResume = await resumeOrcaWorkerSessionIfMissing(target, { isCancelled });
++ const didResume = await resumeOrcaWorkerSessionIfMissing(
++ target,
++ assertCurrent,
++ isCancelled,
++ );
+ if (didResume) {
+ log.info('orcaWorkerResume: resumed idle worker (session only, no status change)', {
+ workerId: target.id,
+ sessionId: target.sessionId,
+ });
+ }
+ return didResume;
+ },
+ withSessionLock: (sessionId, task) =>
+ withSendToSessionLock(sessionId, task, () => 'orca-worker-resume'),
+ });
+
// sessionId → remoteHostId 的进程内缓存 reader(lazy resume 路径每次 send 都
// 经过 ensureRemoteReadyForSessionStart;实现与缓存语义见 localDb/ipc/sessions.ts,
// DB 异常不缓存 null)。
@@@ -11015,14 -11597,11 +11670,16 @@@
const workers = await listWorkersByLead(leadSessionId);
const activeWorkers = workers.filter((w) => w.teamId === team.id);
+ // 先取消尚未落地的后台预热:关闭流程不等待 sendToSession 锁,若不取消,等锁中或
+ // 冷启动中的 resume 会在归档之后把 worker 重新拉活(review P1)。
+ for (const w of workers) {
+ orcaWorkerResumeScheduler.cancel(w.sessionId);
+ }
for (const w of activeWorkers) {
+ await assertCurrent?.();
orcaTeamService.clearAutoBridgeState(w.sessionId);
await cancelIOSSimulatorSessionOperations(w.sessionId);
+ await assertCurrent?.();
const sess = maker.getSession(w.sessionId);
if (sess) {
try {
@@@ -12802,22 -13515,16 +13589,30 @@@
message: `no worker matching "${workerIdOrLabel}"`,
};
+ await assertCurrent();
await setWorkerFocus(target.teamId, target.id);
- // Resume closed session so it's ready to receive tasks, but DON'T change
- // worker status — status only transitions to 'running' when actual work is
- // dispatched (sendToWorker). Setting 'running' here without a task causes
- // the icon to flash indefinitely (no turn → turn-done never fires).
+ // Resume a closed session in the background so it's ready to receive tasks,
+ // but DON'T change worker status — status only transitions to 'running' when
+ // actual work is dispatched (sendToWorker). Setting 'running' here without a
+ // task causes the icon to flash indefinitely (no turn → turn-done never fires).
+ // Focus must not wait for the cold boot: the transcript is DB-backed, and the
- // send path lazily resumes through the same deduped scheduler.
++ // send path lazily resumes through the same deduped scheduler. The authority
++ // check stays on the synchronous path (a revoked authority fails the whole
++ // switch, as before) and is re-checked inside the background resume.
if (target.status === 'idle') {
- orcaWorkerResumeScheduler.requestInBackground(target, (err) => {
- log.warn('switchFocus: resume failed', {
- workerId: target.id,
- sessionId: target.sessionId,
- err: err instanceof Error ? err.message : String(err),
- });
- });
+ await assertCurrent();
- await resumeOrcaWorkerSessionIfMissing(target, assertCurrent);
++ orcaWorkerResumeScheduler.requestInBackground(
++ target,
++ (err) => {
++ log.warn('switchFocus: resume failed', {
++ workerId: target.id,
++ sessionId: target.sessionId,
++ err: err instanceof Error ? err.message : String(err),
++ });
++ },
++ { assertCurrent },
++ );
}
broadcastToAllWindows(MAKER_PUSH.ORCA_WORKER_CHANGED, { leadSessionId });
return { ok: true, workerId: target.id };