Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
Merge remote-tracking branch 'upstream/main' into fix/orca-focus-async-resume
Zhang Yunjin6973045e0f13
diff --cc apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.tsindex 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.tsindex 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.tsindex b023ef2add,0000000000..a3d9a683c2mode 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.tsindex 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.tsindex b03e90ef5e,0000000000..63b150e20dmode 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.tsindex 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 };