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。

fix(orca): 取消未落地的 worker 唤醒,避免归档后被重新拉起

Zhang Yunjina816525b6448
diff --git a/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts b/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
index d44d953537..133e21abfd 100644
--- a/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
+++ b/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
@@ -789,6 +789,23 @@ describe('sendToSession ordering', () => {
'orcaWorkerResumeScheduler.requestInBackground(target, (err) => {',
);
expect(switchFocusMcpBlock).not.toContain('await resumeOrcaWorkerSessionIfMissing(target)');
+ // 关闭协同 / 归档 / 显式 idle 与冷启动交错时,唤醒必须可取消,并在 bootstrap
+ // 返回后关掉刚拉起的 session(review P1:不得把已归档 worker 留在运行态)。
+ expect(resumeBranch).toContain('if (resumeOpts?.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 --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerResumeScheduler.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerResumeScheduler.test.ts
index ea65c45cd2..b023ef2add 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerResumeScheduler.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerResumeScheduler.test.ts
@@ -106,4 +106,93 @@ describe('createOrcaWorkerResumeScheduler', () => {
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('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 --git a/apps/desktop/src/main/maker-ipc/orcaTeamService.ts b/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
index 381f304328..235a2040f2 100644
--- a/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
@@ -230,6 +230,8 @@ export interface OrcaTeamServiceDeps {
worker: OrcaWorkerRecordSnapshot,
link: OrcaWorkerLinkSnapshot,
): Promise<void>;
+ /** 取消该 worker session 尚未落地的后台唤醒(focus 预热);释放 runtime 前调用。 */
+ cancelWorkerResume?(sessionId: string): void;
updateWorkerStatus(workerId: string, status: OrcaWorkerStatus): Promise<void>;
markWorkerIdle(workerId: string): Promise<void>;
markWorkerIdleIfStatus(workerId: string, expectedStatus: 'done'): Promise<boolean>;
@@ -1195,6 +1197,8 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
};
}
}
+ // 显式 idle 会释放 runtime;先取消未落地的后台预热,避免释放后被重新拉起。
+ deps.cancelWorkerResume?.(worker.sessionId);
clearRuntimeState(worker.sessionId);
if (!params.expectedStatus) {
await closeWorkerSessionBestEffort(worker.sessionId, 'idleWorker');
@@ -1231,6 +1235,8 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
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);
diff --git a/apps/desktop/src/main/maker-ipc/orcaWorkerResumeScheduler.ts b/apps/desktop/src/main/maker-ipc/orcaWorkerResumeScheduler.ts
index 2498b9e9b1..b03e90ef5e 100644
--- a/apps/desktop/src/main/maker-ipc/orcaWorkerResumeScheduler.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaWorkerResumeScheduler.ts
@@ -7,12 +7,15 @@
* gateway)才返回,面板切换被冷启动阻塞。唤醒本身仍然需要(发送、派活都依赖 live
* runtime),但它可以后台化:worker 历史来自 DB,不需要 runtime。
*
- * 本调度器给出两个保证:
+ * 本调度器给出三个保证:
* 1. per-session 去重:并发的 focus 切换 / 派活共享同一次 resume,不会把同一个会话
* bootstrap 两次(两个调用方都会看到同一结果);
* 2. 与发送路径共用同一把 per-session 锁(由调用方注入 `withSessionLock`,main 侧注入
* `withSendToSessionLock`):resume 期间到达的发送排在锁后;发送先持锁完成 lazy
- * bootstrap 时,resume 在锁内重查 live 并直接跳过。
+ * bootstrap 时,resume 在锁内重查 live 并直接跳过;
+ * 3. 可取消:关闭协同 / 归档 / 显式 idle 等释放路径通过 `cancel` 取消尚未落地的唤醒。
+ * 等锁中的唤醒直接放弃;已经在冷启动的由 `resume` 实现按 `isCancelled` 在
+ * bootstrap 返回后关掉刚起的 session,避免把已归档 worker 重新拉活。
*
* 唤醒实现与锁都由调用方注入,逻辑本身可单测。
*/
@@ -23,8 +26,12 @@ export interface OrcaWorkerResumeTarget {
}
export interface OrcaWorkerResumeSchedulerDeps<Target extends OrcaWorkerResumeTarget> {
- /** 真正的唤醒实现;返回是否真的启动了 runtime(已 live 时 false)。 */
- resume(target: Target): Promise<boolean>;
+ /**
+ * 真正的唤醒实现;返回是否真的启动了 runtime(已 live 时 false)。
+ * `isCancelled` 在释放路径取消本次唤醒后变为 true:实现必须在冷启动前检查一次,
+ * 并在 bootstrap 返回后再检查一次——已启动的 session 要自己关掉。
+ */
+ resume(target: Target, isCancelled: () => boolean): Promise<boolean>;
/** per-session 串行锁;必须与发送路径共用同一把。 */
withSessionLock<T>(sessionId: string, task: () => Promise<T>): Promise<T>;
}
@@ -37,32 +44,51 @@ export interface OrcaWorkerResumeScheduler<Target extends OrcaWorkerResumeTarget
* focus 切换用这个入口,resume 结果不构成切换成功与否的一部分。
*/
requestInBackground(target: Target, onError: (error: unknown) => void): 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, Promise<boolean>>();
+ const inFlight = new Map<string, InFlightResume>();
function request(target: Target): Promise<boolean> {
const existing = inFlight.get(target.sessionId);
- if (existing) return existing;
+ if (existing) return existing.promise;
+ const entry: InFlightResume = {
+ cancelled: false,
+ promise: Promise.resolve(false),
+ };
// 锁在 resume 内部持有整个冷启动窗口:与发送、idle 释放等同一 session 的 critical
// section 串行;失败也要清掉 in-flight,让下一次 focus / 派活可以重试。
- const promise = deps
- .withSessionLock(target.sessionId, () => deps.resume(target))
+ entry.promise = deps
+ .withSessionLock(target.sessionId, () => deps.resume(target, () => entry.cancelled))
.finally(() => {
- if (inFlight.get(target.sessionId) === promise) inFlight.delete(target.sessionId);
+ if (inFlight.get(target.sessionId) === entry) inFlight.delete(target.sessionId);
});
- inFlight.set(target.sessionId, promise);
- return promise;
+ inFlight.set(target.sessionId, entry);
+ return entry.promise;
}
function requestInBackground(target: Target, onError: (error: unknown) => void): void {
void request(target).catch(onError);
}
- return { request, requestInBackground, pendingCount: () => inFlight.size };
+ function cancel(sessionId: string): void {
+ const entry = inFlight.get(sessionId);
+ if (entry) entry.cancelled = true;
+ }
+
+ return { request, requestInBackground, cancel, pendingCount: () => inFlight.size };
}
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 27779da878..81807a90db 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -7373,14 +7373,20 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
}
// switchFocus 和 sendToWorker 都可能唤醒 idle worker;统一走这里才能保留 extraDirs。
- async function resumeOrcaWorkerSessionIfMissing(target: {
- id: string;
- teamId: string;
- leadSessionId: string;
- sessionId: string;
- }): Promise<boolean> {
+ // resumeOpts.isCancelled:关闭协同 / 归档 / 显式 idle 会取消尚未落地的唤醒;冷启动前与
+ // bootstrap 返回后都要检查,已经拉起的 runtime 要自己关掉(review P1)。
+ async function resumeOrcaWorkerSessionIfMissing(
+ target: {
+ id: string;
+ teamId: string;
+ leadSessionId: string;
+ sessionId: string;
+ },
+ resumeOpts?: { isCancelled?: () => boolean },
+ ): Promise<boolean> {
const live = maker.getSession(target.sessionId);
if (live) return false;
+ if (resumeOpts?.isCancelled?.()) return false;
const db = getDbClient().drizzle;
const [row] = await db
@@ -7389,6 +7395,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
.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;
const workerVendorOptions = {
orcaRole: 'worker' as const,
@@ -7419,22 +7428,55 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
...(writableDirs.length > 0 ? { writableDirs } : {}),
});
await ensureRemoteReadyForSessionStart({ createOpts: opts });
+ if (resumeOpts?.isCancelled?.()) return false;
const { session: resumedSession } = await bootstrapSession(opts);
+ // 关闭协同 / 归档 / 显式 idle 可能和冷启动交错:bootstrap 返回后必须重新确认这次
+ // 唤醒仍然有效,否则关掉刚拉起的 runtime,不能把已归档 worker 留在运行态。
+ if (resumeOpts?.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;
- }) => {
- const didResume = await resumeOrcaWorkerSessionIfMissing(target);
+ resume: async (
+ target: {
+ id: string;
+ teamId: string;
+ leadSessionId: string;
+ sessionId: string;
+ },
+ isCancelled,
+ ) => {
+ const didResume = await resumeOrcaWorkerSessionIfMissing(target, { isCancelled });
if (didResume) {
log.info('orcaWorkerResume: resumed idle worker (session only, no status change)', {
workerId: target.id,
@@ -10973,6 +11015,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
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) {
orcaTeamService.clearAutoBridgeState(w.sessionId);
await cancelIOSSimulatorSessionOperations(w.sessionId);
@@ -11154,6 +11201,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// 与 focus 后台预热共享同一套去重/锁:派活不会和切换触发两次 bootstrap。
await orcaWorkerResumeScheduler.request(target);
},
+ // 归档 / 显式 idle 会释放 runtime;先取消未落地的后台预热,避免释放后被重新拉起。
+ cancelWorkerResume: (sessionId) => orcaWorkerResumeScheduler.cancel(sessionId),
updateWorkerStatus,
markWorkerIdle: async (workerId) => {
const now = Date.now();
diff --git a/docs/dev-rules/orca-team-architecture.md b/docs/dev-rules/orca-team-architecture.md
index 50e5a8c67e..b4816ffe2f 100644
--- a/docs/dev-rules/orca-team-architecture.md
+++ b/docs/dev-rules/orca-team-architecture.md
@@ -320,7 +320,7 @@ Worker turn 被 vendor 报终止型 error,但 interrupted-turn auto-resume 仍
idle worker 被 `switch_focus` 或 `send_to_worker` 唤醒时,要从 DB 读取 `extra_dirs` 并带回 `bootstrapSession`,否则恢复后的 worker 会丢附加目录上下文。实现指针:`register.ts` 的 idle worker resume helper。
3a. **focus 切换不等待 worker 冷启动(状态:不变量)**<br>
- `switch_focus` 是纯 UI focus 操作:`setWorkerFocus` 成功并广播 `ORCA_WORKER_CHANGED` 后必须立即返回,不得同步 `await` 冷会话的 resume / `bootstrapSession`(Pi 冷启实测 2~3s,会阻塞面板切换)。idle worker 的 runtime 预热转后台,并与发送/派活路径共享同一套 per-session 去重 + `sendToSession` 锁:并发 focus / 派活只 bootstrap 一次;发送先取得锁完成懒恢复时,后台 resume 在锁内重查 live 并跳过;预热失败只告警,不改变 `switch_focus` 结果。worker 历史来自 DB,展示不需要 live runtime。实现指针:`register.ts` 的 `resumeOrcaWorkerSessionIfMissing` / `orcaWorkerResumeScheduler.ts`。
+ `switch_focus` 是纯 UI focus 操作:`setWorkerFocus` 成功并广播 `ORCA_WORKER_CHANGED` 后必须立即返回,不得同步 `await` 冷会话的 resume / `bootstrapSession`(Pi 冷启实测 2~3s,会阻塞面板切换)。idle worker 的 runtime 预热转后台,并与发送/派活路径共享同一套 per-session 去重 + `sendToSession` 锁:并发 focus / 派活只 bootstrap 一次;发送先取得锁完成懒恢复时,后台 resume 在锁内重查 live 并跳过;预热失败只告警,不改变 `switch_focus` 结果。worker 历史来自 DB,展示不需要 live runtime。后台预热必须可取消:关闭协同 / 归档 / 显式 idle 在释放 runtime 前先取消未落地的唤醒;冷启动前与 `bootstrapSession` 返回后都要复核会话仍为 active,失效则关掉刚拉起的 runtime,不得把已归档 worker 留在运行态。实现指针:`register.ts` 的 `resumeOrcaWorkerSessionIfMissing` / `disableOrcaInternal` / `orcaWorkerResumeScheduler.ts`、`orcaTeamService.ts` 的 `cancelWorkerResume`。
4. **worker 状态变更必须广播给 renderer(状态:不变量)**
创建 worker、`enableOrca` 创建首个 worker、任意真实 worker turn 开始后的 running、idle、archive、terminal done/error 都必须广播 `ORCA_WORKER_CHANGED`。worker DB `status` 跟随真实 turn 生命周期:Lead 派活或用户直接对话 worker 时,只有真实 turn 开始才置 `running`,**产品** terminal 才置 `done/error`(auto-resume 仍 pending/deferred 的 vendor 终态不是产品终态,见消息派发与 auto-bridge 5a);`switch_focus` / resume / restore 只能恢复可访问性,不能凭空置 `running`。实现指针:`orcaLifecycleService.ts` 的 `createWorker` / `enableTeam`、`orcaWorkerCreationService.ts` 的 `createWorkerInTeam`、`orcaTeamService.ts` 的 `dispatchWorkerTask` / `handleWorkerTurnStarted` / `handleWorkerTerminalTurn`、`register.ts` 的 status event adapter、`useWorkers.ts` 的 `useWorkers`。