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: retain plugin authority through Worker acceptance and controls

Dash68be7616ba18
diff --git a/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts b/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
index 8a53aa28cc..f0d04db511 100644
--- a/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
+++ b/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
@@ -53,6 +53,23 @@ describe('orcaTeamStore', () => {
rawDb = null;
});
+ it.each(['team', 'stranded', 'single'])('rechecks %s archive authority after the existing route lock wait', async action => {
+ const store = await import('../orcaTeamStore.js');
+ const client = createTestDbClient();
+ setCurrentDbClient(client, 'test-user');
+ await seedOrcaWorkers(client);
+ if (action === 'stranded') await client.exec('UPDATE orca_teams SET status = ?', ['completed']);
+ let allowed = true;
+ setSessionRouteLockImplementation(async (_id, task) => { allowed = false; return task(); });
+ const assertCurrent = async () => { if (!allowed) throw Error('Revoked'); };
+ const result = action === 'team' ? store.archiveWorkersByTeam('team-1', assertCurrent)
+ : action === 'stranded' ? store.reconcileInactiveTeamWorkersForLead('lead-session-1', assertCurrent)
+ : store.archiveSingleWorkerSession('worker-session-1', assertCurrent);
+ await expect(result).rejects.toThrow('Revoked');
+ expect(await client.queryOne('SELECT status FROM sessions WHERE id = ?', ['worker-session-1'])).toEqual({ status: 'active' });
+ expect(h.runtimeCleanup).not.toHaveBeenCalled();
+ });
+
it('requires workerId and workerSessionId to match the same row when both are supplied', async () => {
const { getWorkerLink } = await import('../orcaTeamStore.js');
const client = createTestDbClient();
diff --git a/apps/desktop/src/main/localDb/orcaTeamStore.ts b/apps/desktop/src/main/localDb/orcaTeamStore.ts
index bbd8cfe461..c7e7e5acdf 100644
--- a/apps/desktop/src/main/localDb/orcaTeamStore.ts
+++ b/apps/desktop/src/main/localDb/orcaTeamStore.ts
@@ -289,10 +289,11 @@ export async function markTeamEnded(
* sessions.status='archived' 让 sidebar 自然隐藏(其他列表 / 历史搜索仍可查到)。
* orca_role 字段保留 'worker' 不动 — 历史上下文识别需要它。
*/
-export async function archiveWorkersByTeam(teamId: string): Promise<string[]> {
+export async function archiveWorkersByTeam(teamId: string, beforeMutation?: () => Promise<void>): Promise<string[]> {
const client = getDbClient();
const candidateIds = await listActiveWorkerSessionIdsForTeam(teamId);
const updatedIds = await withSessionRouteLocks(candidateIds, async () => {
+ await beforeMutation?.();
const ids = await client.tx('orca.archiveWorkersByTeam', {
teamId,
sessionIds: candidateIds,
@@ -336,10 +337,12 @@ export async function markWorkersStatusByTeam(
*/
export async function reconcileInactiveTeamWorkersForLead(
leadSessionId: string,
+ beforeMutation?: () => Promise<void>,
): Promise<string[]> {
const client = getDbClient();
const candidateIds = await listActiveWorkerSessionIdsForInactiveTeams(leadSessionId);
const updatedIds = await withSessionRouteLocks(candidateIds, async () => {
+ await beforeMutation?.();
const ids = await client.tx('orca.reconcileInactiveTeamWorkersForLead', {
leadSessionId,
sessionIds: candidateIds,
@@ -575,9 +578,10 @@ export async function setWorkerFocus(teamId: string, workerId: string): Promise<
/**
* 归档单个 worker session, 不牵连同 team 其他 worker。
*/
-export async function archiveSingleWorkerSession(sessionId: string): Promise<void> {
+export async function archiveSingleWorkerSession(sessionId: string, beforeMutation?: () => Promise<void>): Promise<void> {
const client = getDbClient();
const changed = await withSessionRouteLock(sessionId, async () => {
+ await beforeMutation?.();
const result = await client.drizzle
.update(sessions)
.set({ status: 'archived', updatedAt: Date.now() })
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaLifecycleService.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaLifecycleService.test.ts
index 6e624f0d21..b2d53fef96 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaLifecycleService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaLifecycleService.test.ts
@@ -129,13 +129,19 @@ function createDeps(overrides: Partial<OrcaLifecycleDeps> = {}) {
}
describe('OrcaLifecycleService', () => {
- it.each(['create-task', 'create-placeholder', 'enable-task', 'enable-placeholder', 'enable-deferred'].flatMap(action => [true, false].map(revoked => ({ action, revoked }))))(
- 'guards $action at acceptance, revoked=$revoked, and cleans up outside dispatch', async ({ action, revoked }) => {
+ it.each(['create-task', 'create-placeholder', 'enable-task', 'enable-placeholder', 'enable-deferred'].flatMap(action => [true, false].flatMap(revoked => ['source', 'directory'].map(scope => ({ action, revoked, scope }))))) (
+ 'guards $action $scope at acceptance, revoked=$revoked, and cleans up outside dispatch', async ({ action, revoked, scope }) => {
let allowed = true, insideSend = false, nativeCalls = 0;
const { deps, service } = createDeps({
getActiveTeamByLead: async () => action.startsWith('create') ? activeTeam() : null,
- getWorkerPermissionModeOverride: async () => ({ permissionMode: 'auto', assertCurrent: async () => { if (!allowed) throw new Error('Revoked'); } }),
+ getWorkerPermissionModeOverride: async () => ({ permissionMode: 'auto', assertCurrent: async () => { if (scope === 'source' && !allowed) throw new Error('Revoked'); } }),
});
+ const create = deps.createWorkerInTeam;
+ deps.createWorkerInTeam = async (params, assertCurrent, onCreated) => {
+ const result = await create(params, assertCurrent);
+ onCreated?.(async () => { await assertCurrent?.(); if (scope === 'directory' && !allowed) throw Error('Revoked'); });
+ return result;
+ };
deps.dispatchWorkerTask = vi.fn(async (params, assertCurrent): Promise<DispatchWorkerTaskResult> => {
insideSend = true; allowed = !revoked;
try {
@@ -171,14 +177,14 @@ describe('OrcaLifecycleService', () => {
},
);
- it.each(['createWorker', 'enableTeam'] as const)(
- 'keeps the Worker when queued acceptance rejects before %s returns', async action => {
+ it.each((['createWorker', 'enableTeam'] as const).flatMap(action => ['source', 'directory'].map(scope => ({ action, scope }))))(
+ 'keeps the Worker when queued $scope acceptance rejects before $action returns', async ({ action, scope }) => {
let allowed = true;
const { deps, service } = createDeps({
getActiveTeamByLead: async () => action === 'createWorker' ? activeTeam() : null,
getWorkerPermissionModeOverride: async () => ({
permissionMode: 'auto',
- assertCurrent: async () => { if (!allowed) throw new Error('Revoked'); },
+ assertCurrent: async () => { if (scope === 'source' && !allowed) throw new Error('Revoked'); },
}),
dispatchWorkerTask: vi.fn(async (_params, assertCurrent): Promise<DispatchWorkerTaskResult> => {
// A coordinator drain can reject independently before the queued
@@ -197,6 +203,12 @@ describe('OrcaLifecycleService', () => {
};
}),
});
+ const create = deps.createWorkerInTeam;
+ deps.createWorkerInTeam = async (params, assertCurrent, onCreated) => {
+ const result = await create(params, assertCurrent);
+ onCreated?.(async () => { await assertCurrent?.(); if (scope === 'directory' && !allowed) throw Error('Revoked'); });
+ return result;
+ };
const result = action === 'createWorker'
? await service.createWorker({ leadSessionId: 'lead-1', agent: 'codex', role: 'reviewer', label: 'reviewer', initialTask: 'Evaluate' })
: await service.enableTeam({ leadSessionId: 'lead-1', workerAgent: 'codex', delegateTask: 'Evaluate' });
@@ -385,7 +397,7 @@ describe('OrcaLifecycleService', () => {
});
expect(deps.createActiveTeam).not.toHaveBeenCalled();
- expect(deps.createWorkerInTeam).toHaveBeenCalledWith(expect.objectContaining({ workingDir: '/remote/explicit-project' }), undefined);
+ expect(deps.createWorkerInTeam).toHaveBeenCalledWith(expect.objectContaining({ workingDir: '/remote/explicit-project' }), undefined, expect.any(Function));
expect(calls).toEqual([
'createWorkerInTeam:team-existing:reviewer',
'dispatchWorkerTask:create_worker/worker-session-1/initial_task',
@@ -422,8 +434,7 @@ describe('OrcaLifecycleService', () => {
expect(deps.createWorkerInTeam).toHaveBeenCalledWith(
expect.objectContaining({ workerPermissionMode: 'bypassPermissions' }),
- undefined,
- );
+ undefined, expect.any(Function));
});
it('keeps a created worker when initial task dispatch throws before vendor dispatch', async () => {
@@ -662,8 +673,7 @@ describe('OrcaLifecycleService', () => {
expect(deps.setWorkerPermissionMode).toHaveBeenCalledWith('bypassPermissions');
expect(deps.createWorkerInTeam).toHaveBeenCalledWith(
expect.objectContaining({ workerPermissionMode: 'bypassPermissions' }),
- undefined,
- );
+ undefined, expect.any(Function));
});
it('uses the worker role slug as the default label when enabling a team', async () => {
@@ -1093,7 +1103,7 @@ describe('host-scoped Worker permissions', () => {
});
expect(await service.startTeam({leadSessionId: 'lead-1', workerPermissionMode})).toMatchObject({ok: true, workerPermissionMode: 'auto'});
await service.createWorker({leadSessionId: 'lead-1', role: 'worker', label: 'sample', agent: 'codex', workerPermissionMode});
- expect(deps.createWorkerInTeam).toHaveBeenCalledWith(expect.objectContaining({workerPermissionMode: 'auto'}), expect.any(Function));
+ expect(deps.createWorkerInTeam).toHaveBeenCalledWith(expect.objectContaining({workerPermissionMode: 'auto'}), expect.any(Function), expect.any(Function));
expect(deps.setWorkerPermissionMode).not.toHaveBeenCalled();
});
it('does not create a Worker after host authorization is revoked', async () => {
@@ -1196,6 +1206,6 @@ describe('retained tasks after explicit plugin uninstall', () => {
: service.createWorker({ leadSessionId: 'lead-1', agent: 'codex', role: 'worker', label: 'sample' });
await expect(result).resolves.toMatchObject({ ok: true });
expect(get).not.toHaveBeenCalled();
- if (action !== 'startTeam') expect(deps.createWorkerInTeam).toHaveBeenCalledWith(expect.objectContaining({ workerPermissionMode: 'bypassPermissions' }), expect.any(Function));
+ if (action !== 'startTeam') expect(deps.createWorkerInTeam).toHaveBeenCalledWith(expect.objectContaining({ workerPermissionMode: 'bypassPermissions' }), expect.any(Function), expect.any(Function));
});
});
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
index 713f97bbe5..8d79ac9d1a 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
@@ -39,6 +39,131 @@ function createWorker(overrides: Partial<OrcaWorkerRecordSnapshot> = {}): OrcaWo
};
}
+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);
+ const api = compile({
+ captureOrcaPluginAuthority: async () => { await assertCurrent(); return { assertCurrent }; },
+ orcaTeamService: service, listWorkersByLead: deps.listWorkersByLead, findFocusTargetWorker,
+ setWorkerFocus: focus, resumeOrcaWorkerSessionIfMissing: resume,
+ 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,
+ 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 --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
index aad7b722a0..5f5186b171 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
@@ -1,4 +1,6 @@
import { hasAcceptedUserTaskInput } from '../pluginTaskInput.js';
+import { assertPluginWorkerDirectoryScope } from '../pluginWorkerDirectory.js';
+import { runAcceptedCallback } from '../acceptedCallbackRunner.js';
import path from 'node:path';
import { readFileSync } from 'node:fs';
import ts from 'typescript';
@@ -16,7 +18,7 @@ import {
type OrcaWorkerProviderRoutingContext,
type OrcaWorkerProviderSnapshot,
} from '../orcaWorkerCreationService';
-import type { DispatchWorkerTaskResult, OrcaWorkerStatus } from '../orcaTeamService';
+import { createOrcaTeamService, type OrcaTeamServiceDeps, type OrcaWorkerRecordSnapshot, type DispatchWorkerTaskResult, type OrcaWorkerStatus } from '../orcaTeamService';
import type { MakerSessionCreateOpts } from '../sessionRequest';
import { CredentialModeSwitchBusyError } from '../../maker-host/codex-credential-switch';
import { isActiveWorkerStatus } from '../../../shared/orca-worker-status';
@@ -32,7 +34,7 @@ describe('Host provenance across Orca creation waits', () => {
expect(from).toBeGreaterThan(0);
expect(to).toBeGreaterThan(from);
const js = ts.transpileModule(`${helper}\nreturn ({${source.slice(from, to)}});`, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText;
- return new Function('hasAcceptedUserTaskInput', ...Object.keys(bindings), js)(hasAcceptedUserTaskInput, ...Object.values(bindings));
+ return new Function('hasAcceptedUserTaskInput', 'assertPluginWorkerDirectoryScope', ...Object.keys(bindings), js)(hasAcceptedUserTaskInput, assertPluginWorkerDirectoryScope, ...Object.values(bindings));
}
type Action = 'createWorker' | 'enableTeam' | 'startNew' | 'startExisting';
const phases: Record<Action, string[]> = {
@@ -41,8 +43,13 @@ describe('Host provenance across Orca creation waits', () => {
startNew: ['team-query', 'team-create', 'lead-activation'],
startExisting: ['team-query', 'lead-activation'],
};
- function setup(action: Action, phase: string, change: string) {
+ function setup(action: Action, phase: string, change: string, entry = 'task') {
let epoch = { client: {} }, enabled = true;
+ const directoryCase = ['config', 'pick'].includes(change);
+ const candidate = path.resolve('synthetic-worker');
+ let configured = change === 'config' ? candidate : undefined, picked = change === 'pick';
+ let directoryResolved = false, directoryReads = 0;
+ let queuedAcceptance: (() => void | Promise<void>) | undefined;
let receipt: { operation: string; pluginId: string; payload: string } | null = {
operation: 'create', pluginId: 'plugin', payload: JSON.stringify({ ownershipRevoked: change === 'already-revoked' }),
};
@@ -58,51 +65,106 @@ describe('Host provenance across Orca creation waits', () => {
else if (change === 'plan') task.planModeEnabled = true;
else if (change === 'archived') task.status = 'archived';
else if (change === 'disabled') enabled = false;
+ else if (change === 'config') configured = undefined;
+ else if (change === 'pick') picked = false;
};
const bindings = {
maker: {getSession:()=>null}, inputCoordinator: { getAcceptedInputProvenance: () => null },
PluginTaskError, getCurrentDbClientSnapshot: () => epoch,
createPluginTaskStore: () => ({ get: async () => receipt && { ...receipt } }),
pluginTaskServiceForCurrentOwner: () => ({ get: async (pluginId: string) => {
+ if (directoryResolved) {
+ directoryReads++;
+ if (directoryReads === 2) mutate('final-task');
+ if (directoryReads === 3) mutate('final-source');
+ }
if (!receipt || receipt.pluginId !== pluginId || JSON.parse(receipt.payload).ownershipRevoked) throw new PluginTaskError('TASK_NOT_FOUND', 'Revoked');
return { ...task };
} }),
- isPluginTaskAuthorized: () => enabled, readGhostErrandConfig: () => ({ permissionMode: 'auto', workingDir: task.workingDir }),
- resolvePluginWorkerDirectory: async () => task.workingDir, isGhostPickedDir: () => false,
+ isPluginTaskAuthorized: () => enabled, readGhostErrandConfig: () => ({ permissionMode: 'auto', workingDir: directoryCase ? configured : task.workingDir }),
+ resolvePluginWorkerDirectory: async () => {
+ directoryResolved = true; directoryReads = 0;
+ if (directoryCase && !configured && !picked) throw new PluginTaskError('PERMISSION_DENIED', 'Directory revoked');
+ return directoryCase ? candidate : task.workingDir;
+ }, isGhostPickedDir: () => picked,
};
const { deps, service: creation } = createDeps(callback(' validateCreationPlan: async (', ' getLeadSessionRow: async (', bindings));
for (const [key, point] of [
['listWorkersByLead', 'worker-list'], ['bootstrapSession', 'bootstrap'],
['renewWorkerCreationReservation', 'renewal'], ['addOrUpdateWorker', 'worker-write'],
+ ['markOrcaRoleIfNeeded', 'role-write'], ['releaseWorkerCreationReservation', 'release'],
] as const) {
const original = deps[key] as (...args: unknown[]) => Promise<unknown>;
(deps as unknown as Record<string, unknown>)[key] = vi.fn(async (...args: unknown[]) => {
const result = await original(...args); mutate(point); return result;
});
}
+ const queuedWorker: OrcaWorkerRecordSnapshot = {
+ id: 'worker-1', teamId: 'team-1', leadSessionId: 'lead-1', sessionId: WORKER_SESSION_ID,
+ status: 'idle', label: 'sample', role: 'eval', focused: false, idleSince: null,
+ session: { title: 'Worker', agentKind: 'codex', model: 'gpt-5.4', effort: null, permissionMode: 'auto', fastMode: false },
+ };
+ const queuedTeamDeps = {
+ getWorkerLinkBySessionId: async () => ({ workerId: queuedWorker.id, teamId: queuedWorker.teamId, workerSessionId: WORKER_SESSION_ID, leadSessionId: 'lead-1' }),
+ listWorkersByLead: async () => [queuedWorker],
+ getLiveSession: () => ({ isTurnRunning: () => true }),
+ getManualInterrupt: () => null, clearManualInterrupt: vi.fn(), broadcastOrcaWorkerChanged: vi.fn(),
+ updateWorkerStatus: vi.fn(async () => undefined), log: { info: vi.fn(), warn: vi.fn() },
+ dispatchWorkerMessage: async ({ onAccepted }) => {
+ queuedAcceptance = onAccepted;
+ return { ok: true, mode: 'queued', clientId: 'queued-1', targetTitle: 'Worker', targetLastUserSendAt: null,
+ dispatchOutcome: { kind: 'session-dispatch', dispatched: true, source: 'test', wakeKind: 'queued' } };
+ },
+ } satisfies Partial<OrcaTeamServiceDeps>;
+ // This fixture exercises only the queued dispatch/accepted path; unexpected
+ // dependencies remain absent so the test cannot silently use another path.
+ const queuedTeam = createOrcaTeamService(queuedTeamDeps as unknown as OrcaTeamServiceDeps);
const lifecycleDeps: OrcaLifecycleDeps = {
...callback(' getWorkerPermissionModeOverride: async (', ' setWorkerPermissionMode: applyWorkerPermissionModePreference,', bindings),
...callback(' createWorkerInTeam: (params', ' dispatchWorkerTask: (params', { ...bindings, orcaWorkerCreationService: creation }),
getActiveTeamByLead: vi.fn(async () => { mutate('team-query'); return action === 'createWorker' || action === 'startExisting' ? { id: 'team-1', leadSessionId: 'lead-1' } : null; }),
createActiveTeam: vi.fn(async () => { mutate('team-create'); return { id: 'new-team', leadSessionId: 'lead-1' }; }),
isOrphanedTeamInit: vi.fn(async () => false), getWorkerPermissionMode: () => 'bypassPermissions', setWorkerPermissionMode: vi.fn(),
- dispatchWorkerTask: deps.dispatchWorkerTask, markTeamEnded: vi.fn(async () => undefined), setSessionOrcaRole: vi.fn(async () => undefined),
+ dispatchWorkerTask: async (params, assertCurrent) => {
+ if (entry === 'queued') {
+ return queuedTeam.dispatchWorkerTask(params, assertCurrent);
+ }
+ mutate('accepted'); await assertCurrent?.(); return deps.dispatchWorkerTask(params);
+ }, markTeamEnded: vi.fn(async () => undefined), setSessionOrcaRole: vi.fn(async () => undefined),
clearKnownNonOrcaSession: vi.fn(), setLeadVendorOptions: vi.fn(async () => { mutate('lead-activation'); }), clearLeadVendorOptions: vi.fn(async () => undefined),
- sendWorkerReadyPlaceholder: vi.fn(async () => undefined), rollbackCreatedWorker: vi.fn(async () => undefined),
+ sendWorkerReadyPlaceholder: vi.fn(async (_params, assertCurrent) => { mutate('accepted'); await assertCurrent?.(); }), rollbackCreatedWorker: vi.fn(async () => undefined),
broadcastSessionCreated: vi.fn(), broadcastOrcaWorkerChanged: vi.fn(),
};
const lifecycle = createOrcaLifecycleService(lifecycleDeps);
const run = () => action === 'createWorker'
- ? lifecycle.createWorker({ leadSessionId: 'lead-1', agent: 'codex', role: 'eval', label: 'sample', initialTask: 'Synthetic task' })
+ ? lifecycle.createWorker({ leadSessionId: 'lead-1', agent: 'codex', role: 'eval', label: 'sample', initialTask: ['task', 'queued'].includes(entry) ? 'Synthetic task' : undefined, ...(directoryCase ? { workingDir: candidate } : {}) })
: action === 'enableTeam'
- ? lifecycle.enableTeam({ leadSessionId: 'lead-1', workerAgent: 'codex', role: 'eval', label: 'sample', delegateTask: 'Synthetic task' })
+ ? lifecycle.enableTeam({ leadSessionId: 'lead-1', workerAgent: 'codex', role: 'eval', label: 'sample', delegateTask: entry === 'placeholder' ? undefined : 'Synthetic task', deferDelegateTask: entry === 'deferred', ...(directoryCase ? { workingDir: candidate } : {}) })
: lifecycle.startTeam({ leadSessionId: 'lead-1' });
- return { deps, lifecycleDeps, run };
+ return { deps, lifecycleDeps, run, acceptQueued: async () => {
+ expect(queuedAcceptance).toBeTypeOf('function');
+ mutate('accepted');
+ return runAcceptedCallback(queuedAcceptance, WORKER_SESSION_ID, 'queued-1');
+ } };
}
const cases = (Object.keys(phases) as Action[]).flatMap(action => phases[action].flatMap(phase =>
['uninstalled', 'reinstalled', 'account'].map(change => ({ action, phase, change }))));
cases.push(...(['createWorker', 'enableTeam'] as Action[]).flatMap(action =>
['owner', 'missing', 'ask', 'plan', 'archived', 'disabled'].map(change => ({ action, phase: 'bootstrap', change }))));
+ cases.push(...(['createWorker', 'enableTeam'] as Action[]).flatMap(action =>
+ ['worker-write', 'role-write', 'release', 'final-task', 'final-source', ...(action === 'enableTeam' ? ['lead-activation'] : [])].flatMap(phase =>
+ ['config', 'pick'].map(change => ({ action, phase, change })))));
+ it.each((['createWorker', 'enableTeam'] as const).flatMap(action => ['config', 'pick'].flatMap(change => ['', 'accepted'].map(phase => ({ action, change, phase }))))) (
+ 'retains $action $change directory authority after the queued reply: $phase', async ({ action, change, phase }) => {
+ const { run, acceptQueued, deps, lifecycleDeps } = setup(action, phase, change, 'queued');
+ expect(await run()).toMatchObject({ ok: true, dispatched: false });
+ if (phase) await expect(acceptQueued()).rejects.toMatchObject({ name: 'AcceptedCallbackDispatchCancelled' });
+ else await expect(acceptQueued()).resolves.toBeUndefined();
+ expect(deps.dispatchWorkerTask).not.toHaveBeenCalled();
+ expect(lifecycleDeps.rollbackCreatedWorker).not.toHaveBeenCalled();
+ expect(lifecycleDeps.markTeamEnded).not.toHaveBeenCalled();
+ },
+ );
it.each(cases)('rejects $action after $change during $phase without dispatch', async ({ action, phase, change }) => {
const { deps, lifecycleDeps, run } = setup(action, phase, change);
const result = await run().catch(() => ({ ok: false }));
@@ -115,12 +177,27 @@ describe('Host provenance across Orca creation waits', () => {
expect(deps.releaseWorkerCreationReservation).toHaveBeenCalled();
}
if (phase === 'worker-write' || (action === 'enableTeam' && phase === 'lead-activation')) {
- expect(lifecycleDeps.rollbackCreatedWorker).toHaveBeenCalled();
+ expect(vi.mocked(lifecycleDeps.rollbackCreatedWorker).mock.calls.length + vi.mocked(deps.removeWorker).mock.calls.length).toBeGreaterThan(0);
}
if (vi.mocked(lifecycleDeps.createActiveTeam).mock.calls.length) expect(lifecycleDeps.markTeamEnded).toHaveBeenCalledWith('new-team', 'failed');
else expect(lifecycleDeps.markTeamEnded).not.toHaveBeenCalled();
expect(lifecycleDeps.setWorkerPermissionMode).not.toHaveBeenCalled();
});
+ it.each((['createWorker', 'enableTeam'] as const).flatMap(action =>
+ (action === 'createWorker' ? ['task', 'placeholder'] : ['task', 'placeholder', 'deferred']).flatMap(entry =>
+ ['config', 'pick'].flatMap(change => ['', 'accepted'].map(phase => ({ action, entry, change, phase }))))))(
+ 'retains resolved scope until $action $entry acceptance: $change $phase', async ({ action, entry, change, phase }) => {
+ const { run, deps, lifecycleDeps } = setup(action, phase, change, entry);
+ const result = await run();
+ expect(result.ok).toBe(phase === '');
+ if (phase) {
+ expect(deps.dispatchWorkerTask).not.toHaveBeenCalled();
+ expect(lifecycleDeps.rollbackCreatedWorker).toHaveBeenCalled();
+ }
+ // Public result cannot carry the Host callback or captured authorization facts.
+ expect(JSON.parse(JSON.stringify(result))).toEqual(result);
+ },
+ );
it.each((Object.keys(phases) as Action[]).flatMap(action => ['healthy', 'already-revoked'].map(change => ({ action, change }))))(
'preserves $change behavior for $action', async ({ action, change }) => {
const { deps, lifecycleDeps, run } = setup(action, '', change);
@@ -2845,7 +2922,7 @@ it('uses one canonical label at every plan check without mutating the caller', a
const { service } = createDeps({ validateCreationPlan });
const params = Object.freeze({ leadSessionId: 'lead-1', teamId: 'team-1', role: 'eval', agent: 'codex' as const, label: ' SAMPLE ', workerPermissionMode: 'auto' as const });
await expect(service.createWorkerInTeam(params)).resolves.toMatchObject({ ok: true });
- expect(validateCreationPlan).toHaveBeenCalledTimes(3);
+ expect(validateCreationPlan).toHaveBeenCalledTimes(4);
for (const call of validateCreationPlan.mock.calls) expect(call[0]).toMatchObject({ label: 'sample' });
expect(params.label).toBe(' SAMPLE ');
});
@@ -2871,7 +2948,7 @@ it('checks the resolved creation directory before bootstrap and releases a rejec
const {deps, service} = createDeps({validateCreationPlan, resolveWorkerWorkingDir: vi.fn(async () => resolved)});
const params = {leadSessionId:'lead-1',role:'eval',agent:'codex' as const,label:'sample',workingDir:path.resolve('candidate')};
await expect(service.createWorker(params)).rejects.toThrow('Directory authorization revoked');
- expect(validateCreationPlan).toHaveBeenLastCalledWith(expect.objectContaining(params), resolved, expect.objectContaining({ model: 'gpt-5.5', providerId: 'xd' }));
+ expect(validateCreationPlan).toHaveBeenLastCalledWith(expect.objectContaining(params), resolved, expect.objectContaining({ model: 'gpt-5.5', providerId: 'xd' }), undefined);
expect(deps.bootstrapSession).not.toHaveBeenCalled();
expect(deps.releaseWorkerCreationReservation).toHaveBeenCalledTimes(1);
});
@@ -2879,12 +2956,12 @@ it('checks the resolved creation directory before bootstrap and releases a rejec
describe('production plugin Auto admission after reservation', () => {
const source = readFileSync(new URL('../register.ts', import.meta.url), 'utf8');
const helper = source.slice(source.indexOf(' const assertPluginWorkerAutoAuthorized ='), source.indexOf(' const orcaWorkerCreationService ='));
- const callback = source.slice(source.indexOf(' validateCreationPlan: async (params, resolvedWorkingDir, resolvedRoute) => {'), source.indexOf(' getLeadSessionRow: async (leadSessionId) => {'));
+ const callback = source.slice(source.indexOf(' validateCreationPlan: async ('), source.indexOf(' getLeadSessionRow: async (leadSessionId) => {'));
const js = ts.transpileModule(`${helper}\nreturn ({${callback}}).validateCreationPlan;`, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText;
it.each(['uninstalled', 'reinstalled', 'malformed'])('keeps ordinary Worker creation separate from %s plugin receipts', async state => {
const epoch = { client: {} }, get = vi.fn(async () => { throw new PluginTaskError('TASK_NOT_FOUND', 'Not owned'); });
- const callbackDeps = { getCurrentDbClientSnapshot: () => epoch, PluginTaskError,
+ const callbackDeps = { getCurrentDbClientSnapshot: () => epoch, PluginTaskError, assertPluginWorkerDirectoryScope,
createPluginTaskStore: () => ({ get: async () => ({ operation: 'create', pluginId: 'plugin', payload: state === 'malformed' ? '{' : JSON.stringify({ ownershipRevoked: true, teamPlan: { items: [] } }) }) }),
pluginTaskServiceForCurrentOwner: () => ({ get }), isPluginTaskAuthorized: () => state === 'reinstalled',
readGhostErrandConfig: () => ({ permissionMode: 'auto' }),
@@ -2922,6 +2999,7 @@ describe('production plugin Auto admission after reservation', () => {
const payload = () => JSON.stringify(planned ? { teamPlan: { concurrency: 2, items: [planItem] }, settledLabels: point === 'settled-label' ? ['sample'] : [] } : {});
const receipt = { pluginId: 'plugin', operation: 'create', payload: payload() };
const depsForCallback = {
+ assertPluginWorkerDirectoryScope,
getCurrentDbClientSnapshot: () => epoch,
createPluginTaskStore: () => ({ get: async () => { if (++receiptReads === 4 && point === 'receipt') revoke(); return structuredClone(receipt); } }),
pluginTaskServiceForCurrentOwner: () => ({ get: async () => {
diff --git a/apps/desktop/src/main/maker-ipc/orcaLifecycleService.ts b/apps/desktop/src/main/maker-ipc/orcaLifecycleService.ts
index f5fb4ff91d..3a8ce4efe7 100644
--- a/apps/desktop/src/main/maker-ipc/orcaLifecycleService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaLifecycleService.ts
@@ -93,7 +93,8 @@ export interface OrcaLifecycleDeps {
assertCurrent: () => Promise<void>;
}>;
setWorkerPermissionMode(workerPermissionMode: OrcaWorkerPermissionMode): void;
- createWorkerInTeam(params: OrcaWorkerCreateInTeamParams, assertCurrent?: () => Promise<void>): Promise<OrcaWorkerCreationResult>;
+ createWorkerInTeam(params: OrcaWorkerCreateInTeamParams, assertCurrent?: () => Promise<void>,
+ onCreated?: (assertCreatedCurrent: () => Promise<void>) => void): Promise<OrcaWorkerCreationResult>;
dispatchWorkerTask(params: {
targetSessionId: string;
message: string;
@@ -254,14 +255,15 @@ export function createOrcaLifecycleService(deps: OrcaLifecycleDeps): OrcaLifecyc
}
const { workerPermissionMode, assertCurrent } = workerPermissionModeForCreate(params.workerPermissionMode, override);
const initialTask = hasNonEmptyInitialTask(params.initialTask) ? params.initialTask : undefined;
+ let assertCreatedCurrent = assertCurrent;
const created = await deps.createWorkerInTeam({
...params,
teamId: team.id,
workerPermissionMode,
- }, assertCurrent);
+ }, assertCurrent, guard => { assertCreatedCurrent = guard; });
if (!created.ok) return created;
try {
- await assertCurrent?.();
+ await assertCreatedCurrent?.();
} catch (err) {
await deps.rollbackCreatedWorker(created).catch(() => undefined);
return internalFailure(err);
@@ -274,14 +276,14 @@ export function createOrcaLifecycleService(deps: OrcaLifecycleDeps): OrcaLifecyc
workerSessionId: created.workerSessionId,
message: initialTask,
context: `create_worker/${created.workerSessionId}/initial_task`,
- }, assertCurrent);
+ }, assertCreatedCurrent);
} else {
await deps.sendWorkerReadyPlaceholder({
workerSessionId: created.workerSessionId,
agentKind: created.resolved.agent,
entrypoint: 'create_worker',
context: `create_worker/${created.workerSessionId}/worker-ready-placeholder`,
- }, assertCurrent);
+ }, assertCreatedCurrent);
}
} catch (err) {
await deps.rollbackCreatedWorker(created).catch(() => undefined);
@@ -378,6 +380,7 @@ export function createOrcaLifecycleService(deps: OrcaLifecycleDeps): OrcaLifecyc
async function enableTeam(params: OrcaEnableTeamParams): Promise<OrcaEnableTeamResult> {
const { workerPermissionMode, assertCurrent } = workerPermissionModeForCreate(params.workerPermissionMode, await deps.getWorkerPermissionModeOverride?.(params.leadSessionId));
+ let assertCreatedCurrent = assertCurrent;
const normalized = normalizeEnableParams(params);
const validationFailure = validateEnableParams(normalized);
if (validationFailure) return validationFailure;
@@ -414,7 +417,7 @@ export function createOrcaLifecycleService(deps: OrcaLifecycleDeps): OrcaLifecyc
...normalized,
teamId: team.id,
workerPermissionMode,
- }, assertCurrent);
+ }, assertCurrent, guard => { assertCreatedCurrent = guard; });
} catch (err) {
return failCreatedTeam({ teamId: team.id, leadSessionId: params.leadSessionId, err });
} finally {
@@ -431,7 +434,7 @@ export function createOrcaLifecycleService(deps: OrcaLifecycleDeps): OrcaLifecyc
let leadVendorOptionsSet = false;
try {
- await assertCurrent?.();
+ await assertCreatedCurrent?.();
await deps.setSessionOrcaRole(params.leadSessionId, 'lead');
deps.clearKnownNonOrcaSession(params.leadSessionId);
await deps.setLeadVendorOptions({
@@ -441,7 +444,7 @@ export function createOrcaLifecycleService(deps: OrcaLifecycleDeps): OrcaLifecyc
workerSessionId: created.workerSessionId,
});
leadVendorOptionsSet = true;
- await assertCurrent?.();
+ await assertCreatedCurrent?.();
} catch (err) {
return failCreatedTeam({
teamId: team.id,
@@ -463,14 +466,14 @@ export function createOrcaLifecycleService(deps: OrcaLifecycleDeps): OrcaLifecyc
initialTask: normalized.initialTask,
}),
context: `enable_collab_mode/${created.workerSessionId}/delegate_task`,
- }, assertCurrent);
+ }, assertCreatedCurrent);
} else {
await deps.sendWorkerReadyPlaceholder({
workerSessionId: created.workerSessionId,
agentKind: created.resolved.agent,
entrypoint: 'enable_collab_mode',
context: `enable_collab_mode/${created.workerSessionId}/worker-ready-placeholder`,
- }, assertCurrent);
+ }, assertCreatedCurrent);
}
} catch (err) {
return failCreatedTeam({
diff --git a/apps/desktop/src/main/maker-ipc/orcaTeamService.ts b/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
index 154388a1a0..ddd37304ba 100644
--- a/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
@@ -237,7 +237,7 @@ export interface OrcaTeamServiceDeps {
restoreWorkerDoneIfIdle(workerId: string): Promise<boolean>;
/** Stop Host-owned work (for example iOS builds) before archiving this worker task. */
cancelWorkerSessionOperations(sessionId: string): Promise<void>;
- closeWorkerSession(sessionId: string): Promise<void>;
+ closeWorkerSession(sessionId: string, beforeClose?: () => Promise<void>): Promise<void>;
/** 与 Session.send reservation 原子互斥;false 表示 direct send/turn 已先取得会话。 */
closeWorkerSessionIfIdle(sessionId: string, sendLockHeld?: boolean): Promise<boolean>;
/** pending / dispatch-boundary / recovery 输入任一存在时返回 true。 */
@@ -245,7 +245,7 @@ export interface OrcaTeamServiceDeps {
/** send_to_session 的恢复/直发锁覆盖 bootstrap 到 Session.send reservation 的窗口。 */
hasSendToSessionLock(sessionId: string): boolean;
withSessionSendLock<T>(sessionId: string, operation: () => Promise<T>): Promise<T>;
- archiveWorkerSession(sessionId: string): Promise<void>;
+ archiveWorkerSession(sessionId: string, beforeMutation?: () => Promise<void>): Promise<void>;
getManualInterrupt(sessionId: string): OrcaManualInterruptSnapshot | null;
clearManualInterrupt(sessionId: string): void;
restoreManualInterrupt(sessionId: string, snapshot: OrcaManualInterruptSnapshot): void;
@@ -341,7 +341,7 @@ export interface OrcaTeamService {
callerLeadSessionId: string;
workerId: string;
expectedStatus?: 'done';
- }): Promise<OrcaOkResult>;
+ }, opts?: { deferredRetry?: boolean; assertCurrent?: () => Promise<void> }): Promise<OrcaOkResult>;
/** 外部调用边界:按 caller lead 校验 worker 可见性。 */
archiveWorker(params: { callerLeadSessionId: string; workerId: string; onlyIfIdle?: boolean; beforeArchive?: () => Promise<void> }): Promise<OrcaOkResult>;
/** 外部调用边界:列出目标 worker 输入队列中的排队消息(lead 自己的条目含正文)。 */
@@ -449,7 +449,13 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
* 下一次 done 广播仍会走 renderer 的可见性 ack 路径。done 的产品语义是
* 「保持到用户看到为止」,所以只在 renderer 已尝试过确认时补收口,不做无条件自动 ack。
*/
- const deferredDoneAcknowledgements = new Set<string>();
+ const deferredDoneAcknowledgements = new Map<string, { assertCurrent?: () => Promise<void> }>();
+ const deferDoneAcknowledgement = (workerId: string, assertCurrent?: () => Promise<void>) => {
+ // An independent UI acknowledgement must not acquire a model caller's guard.
+ if (!deferredDoneAcknowledgements.has(workerId) || deferredDoneAcknowledgements.get(workerId)?.assertCurrent) {
+ deferredDoneAcknowledgements.set(workerId, { assertCurrent });
+ }
+ };
async function withWorkerTransition<T>(
workerId: string,
@@ -1120,7 +1126,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
* 否则 fire-once 契约被打破,且该 terminal 边界之后未必还有下一个 terminal
* 事件来消费,worker 会带着悬置登记卡回 done(正是本机制要修的状态)。
*/
- opts?: { deferredRetry?: boolean },
+ opts?: { deferredRetry?: boolean; assertCurrent?: () => Promise<void> },
): Promise<OrcaOkResult> {
const found = await resolveWorkerRef(params.callerLeadSessionId, params.workerId);
if (!found.ok) return workerRefFailureForControl(params.workerId, found);
@@ -1129,6 +1135,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
current: Extract<Awaited<ReturnType<typeof resolveWorkerRef>>, { ok: true }>,
): Promise<OrcaOkResult> => {
const { link, worker } = current;
+ await opts?.assertCurrent?.();
if (params.expectedStatus && worker.status !== params.expectedStatus) {
return {
ok: false,
@@ -1147,7 +1154,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
// 回报 settle 先落库、worker 自己的 turn 还在收尾:登记后由 terminal 边界重试(#3153)。
// terminal 重试自身被拒时不登记(见 idleWorker 的 opts 注释)。
if (params.expectedStatus === 'done' && !opts?.deferredRetry) {
- deferredDoneAcknowledgements.add(worker.id);
+ deferDoneAcknowledgement(worker.id, opts?.assertCurrent);
}
return {
ok: false,
@@ -1157,7 +1164,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
}
if (params.expectedStatus && deps.hasSendToSessionLock(worker.sessionId)) {
if (params.expectedStatus === 'done' && !opts?.deferredRetry) {
- deferredDoneAcknowledgements.add(worker.id);
+ deferDoneAcknowledgement(worker.id, opts?.assertCurrent);
}
return {
ok: false,
@@ -1173,6 +1180,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
};
}
+ await opts?.assertCurrent?.();
const didIdle = params.expectedStatus
? await deps.markWorkerIdleIfStatus(worker.id, params.expectedStatus)
: (await deps.markWorkerIdle(worker.id), true);
@@ -1187,6 +1195,13 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
await deps.restoreWorkerDoneIfIdle(worker.id);
deps.broadcastOrcaWorkerChanged(link.leadSessionId);
};
+ const assertAfterIdle = async () => {
+ try { await opts?.assertCurrent?.(); }
+ catch (err) {
+ if (params.expectedStatus) await rollbackDoneAcknowledgement();
+ throw err;
+ }
+ };
// Queue state can change while the DB CAS awaits I/O. Preserve newly queued
// follow-ups before close, then use Session.closeIfIdle for atomic send/close ordering.
if (params.expectedStatus && (await deps.hasPendingWorkerInput(worker.sessionId))) {
@@ -1198,6 +1213,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
};
}
if (params.expectedStatus) {
+ await assertAfterIdle();
const didClose = await closeWorkerSessionIfIdleBestEffort(worker.sessionId, 'idleWorker');
if (!didClose) {
await rollbackDoneAcknowledgement();
@@ -1208,9 +1224,10 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
};
}
}
+ 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);
@@ -1250,17 +1267,20 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
if ((activeWorkerDispatches.get(worker.id) ?? 0)>0 || await deps.hasPendingWorkerInput(worker.sessionId) || !await closeWorkerSessionIfIdleBestEffort(worker.sessionId,'releaseWorker',true)) return {ok:false,errorCode:'WORKER_STATE_CHANGED',message:'Worker has active or queued input'};
if (await deps.hasPendingWorkerInput(worker.sessionId)) return {ok:false,errorCode:'WORKER_STATE_CHANGED',message:'Worker has queued input'};
}
+ await params.beforeArchive?.();
clearRuntimeState(worker.sessionId);
deps.forgetWorkerSession?.(worker.sessionId);
deferredDoneAcknowledgements.delete(worker.id);
await deps.cancelWorkerSessionOperations(worker.sessionId);
- await closeWorkerSessionBestEffort(worker.sessionId, 'archiveWorker');
await params.beforeArchive?.();
- await deps.archiveWorkerSession(worker.sessionId);
+ 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.
await deps.cancelWorkerSessionOperations(worker.sessionId);
+ await params.beforeArchive?.();
await deps.updateWorkerStatus(worker.id, 'done');
deps.broadcastOrcaWorkerChanged(link.leadSessionId);
return { ok: true, workerId: worker.id };
@@ -1498,10 +1518,17 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
};
}
- async function closeWorkerSessionBestEffort(sessionId: string, owner: string): Promise<void> {
+ async function closeWorkerSessionBestEffort(sessionId: string, owner: string, assertCurrent?: () => Promise<void>): Promise<void> {
+ let authorityRejected = false;
+ const beforeClose = assertCurrent ? async () => {
+ try { await assertCurrent(); }
+ catch (err) { authorityRejected = true; throw err; }
+ } : undefined;
try {
- await deps.closeWorkerSession(sessionId);
+ if (beforeClose) await deps.closeWorkerSession(sessionId, beforeClose);
+ else await deps.closeWorkerSession(sessionId);
} catch (err) {
+ if (authorityRejected) throw err;
deps.log.warn(`${owner}: close worker session failed`, {
sessionId,
err: err instanceof Error ? err.message : String(err),
@@ -1591,6 +1618,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
if (!link) return;
let retryAcknowledgeDone = false;
+ let retryAuthority: (() => Promise<void>) | undefined;
let manualInterruptSuppressed = false;
for (;;) {
const workers = await deps.listWorkersByLead(link.leadSessionId);
@@ -1658,6 +1686,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
// 即 ack」在 active-turn 守卫处被拒后没有重试闭环,worker 会永久停在 done
// (runtime/attention 悬置)。这里在该 turn 的 terminal 边界补一次收口;
// 没登记过被拒确认的 done 保持原样(维持「done 保持到用户看到为止」语义)。
+ retryAuthority = deferredDoneAcknowledgements.get(link.workerId)?.assertCurrent;
retryAcknowledgeDone =
worker.status === 'done' && deferredDoneAcknowledgements.delete(link.workerId);
clearRuntimeState(params.sessionId);
@@ -1721,8 +1750,8 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
expectedStatus: 'done',
},
// 补收口重试被拒时不得重新登记,保证 fire-once(见 idleWorker 的 opts 注释)。
- { deferredRetry: true },
- );
+ { deferredRetry: true, assertCurrent: retryAuthority },
+ ).catch((err): OrcaOkResult => ({ ok: false, errorCode: 'INTERNAL', message: err instanceof Error ? err.message : String(err) }));
if (!acknowledged.ok) {
deps.log.info('orca deferred done acknowledgement skipped', {
workerId: link.workerId,
diff --git a/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts b/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
index 6b72cf6d1b..a35a791a55 100644
--- a/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
@@ -209,7 +209,8 @@ export interface OrcaWorkerCreationDeps {
listWorkersByLead(leadSessionId: string): Promise<OrcaWorkerListSnapshot[]>;
isActiveWorkerStatus(status: OrcaWorkerStatus): boolean;
validateCreationPlan?(params: OrcaWorkerCreateInTeamParams, resolvedWorkingDir?: string,
- resolvedRoute?: { model: string; providerId: string | null; effort: string | null; fastMode: boolean }): Promise<number | null | undefined>;
+ resolvedRoute?: { model: string; providerId: string | null; effort: string | null; fastMode: boolean },
+ assertCurrent?: () => Promise<void>): Promise<number | null | undefined>;
readCollaborationSettings(): { workerSoftLimit: number; workerHardLimit: number };
getLeadSessionRow(leadSessionId: string): Promise<OrcaLeadSessionSnapshot | null>;
getWorkerDefaults(agent: AgentKind): OrcaWorkerDefaultsSnapshot;
@@ -274,7 +275,8 @@ export interface OrcaWorkerCreationDeps {
/** Orca worker 创建服务,只负责创建既有 team 下的新 worker,不负责 team lifecycle。 */
export interface OrcaWorkerCreationService {
createWorker(params: OrcaWorkerCreateParams, assertCurrent?: () => Promise<void>): Promise<OrcaWorkerCreationResult>;
- createWorkerInTeam(params: OrcaWorkerCreateInTeamParams, assertCurrent?: () => Promise<void>): Promise<OrcaWorkerCreationResult>;
+ createWorkerInTeam(params: OrcaWorkerCreateInTeamParams, assertCurrent?: () => Promise<void>,
+ onCreated?: (assertCreatedCurrent: () => Promise<void>) => void): Promise<OrcaWorkerCreationResult>;
}
function toInternalFailure(err: unknown): Extract<OrcaWorkerCreationResult, { ok: false }> {
@@ -612,7 +614,8 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
}, assertCurrent);
}
- async function createWorkerInTeam(params: OrcaWorkerCreateInTeamParams, assertCurrent?: () => Promise<void>): Promise<OrcaWorkerCreationResult> {
+ async function createWorkerInTeam(params: OrcaWorkerCreateInTeamParams, assertCurrent?: () => Promise<void>,
+ onCreated?: (assertCreatedCurrent: () => Promise<void>) => void): Promise<OrcaWorkerCreationResult> {
const role = normalizeRequiredText(params.role, 'role');
if (!role.ok) return { ok: false, errorCode: 'INVALID_PARAMS', message: role.message };
if (role.value.length > 32) {
@@ -623,9 +626,9 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
params = { ...params, label: label.value };
const validatePlan = async (workingDir?: string, route?: Parameters<NonNullable<OrcaWorkerCreationDeps['validateCreationPlan']>>[2]) => {
await assertCurrent?.();
- const limit = await deps.validateCreationPlan?.(params, workingDir, route);
- await assertCurrent?.();
- return limit;
+ // Host validation runs the captured source check before its final synchronous
+ // directory grant check. No trailing await may stale that grant observation.
+ return deps.validateCreationPlan?.(params, workingDir, route, assertCurrent);
};
const existing = await deps.listWorkersByLead(params.leadSessionId);
@@ -1117,12 +1120,16 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
try {
await deps.markOrcaRoleIfNeeded(workerSession.id, 'worker');
+ await validatePlan(workingDir, resolved);
} catch (err) {
await cleanupBootstrappedWorkerSession(workerSession.id);
await deps.removeWorker(workerId).catch(() => undefined);
return toInternalFailure(err);
}
+ // Carry the resolved spawn facts through lifecycle/accepted callbacks only;
+ // neither the function nor its closure is part of the public result.
+ onCreated?.(async () => { await validatePlan(workingDir, resolved); });
return {
ok: true,
teamId: params.teamId,
diff --git a/apps/desktop/src/main/maker-ipc/pluginWorkerDirectory.ts b/apps/desktop/src/main/maker-ipc/pluginWorkerDirectory.ts
index 47184241de..077e6d04c9 100644
--- a/apps/desktop/src/main/maker-ipc/pluginWorkerDirectory.ts
+++ b/apps/desktop/src/main/maker-ipc/pluginWorkerDirectory.ts
@@ -44,12 +44,27 @@ async function localRealpath(directory: string): Promise<string> {
throw new PluginTaskError('PERMISSION_DENIED', 'Plugin task directory contains too many links');
}
-/** Plans describe work; only host directory facts authorize it. */
-export async function resolvePluginWorkerDirectory(input: {
+type DirectoryScope = {
requested: string;
leadDirectory?: string;
configuredDirectory?: string;
isPickedDirectory: (directory: string) => boolean;
+};
+
+/** Synchronous Host grant check, also used after the last asynchronous admission read. */
+export function assertPluginWorkerDirectoryScope(input: DirectoryScope): void {
+ const candidate = localDirectory(input.requested);
+ const lead = input.leadDirectory ? localDirectory(input.leadDirectory) : undefined;
+ const configured = input.configuredDirectory ? localDirectory(input.configuredDirectory) : undefined;
+ if (!(lead && isPathInsideDir(lead, candidate))
+ && !(configured && isPathInsideDir(configured, candidate) && isPathInsideDir(candidate, configured))
+ && !input.isPickedDirectory(candidate)) {
+ throw new PluginTaskError('PERMISSION_DENIED', 'Worker directory is outside the plugin task scope');
+ }
+}
+
+/** Plans describe work; only host directory facts authorize it. */
+export async function resolvePluginWorkerDirectory(input: DirectoryScope & {
assertCurrent: () => void;
}): Promise<string> {
const deny = () => new PluginTaskError('PERMISSION_DENIED', 'Worker directory is outside the plugin task scope');
@@ -61,9 +76,7 @@ export async function resolvePluginWorkerDirectory(input: {
};
const leadRoot = localRoot(input.leadDirectory);
const configuredRoot = localRoot(input.configuredDirectory);
- if (!(leadRoot && isPathInsideDir(leadRoot, candidate))
- && !(configuredRoot && sameDirectory(configuredRoot, candidate))
- && !input.isPickedDirectory(candidate)) throw deny();
+ assertPluginWorkerDirectoryScope(input);
const resolved = await localRealpath(candidate);
if (!(await stat(resolved)).isDirectory()) throw deny();
// Stored Host roots are canonical identities, not aliases to resolve into new grants.
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 5f52e42657..e7770467bd 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -1,5 +1,5 @@
import { isPluginTaskPermissionAllowed, assertPluginTaskResult, createPluginTaskService, PluginTaskError, type PluginTaskService } from './pluginTaskService.js';
-import { resolvePluginWorkerDirectory } from './pluginWorkerDirectory.js';
+import { assertPluginWorkerDirectoryScope, resolvePluginWorkerDirectory } from './pluginWorkerDirectory.js';
import { PluginWriteAccessGate } from './pluginWriteAccessGate.js';
import { pluginWorkerCompletedAt } from './pluginWorkerCompletion.js';
import { createPluginTaskStore } from './pluginTaskStore.js';
@@ -7487,7 +7487,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
teamId: string;
leadSessionId: string;
sessionId: string;
- }): Promise<boolean> {
+ }, assertCurrent?: () => Promise<void>): Promise<boolean> {
const live = maker.getSession(target.sessionId);
if (live) return false;
@@ -7527,8 +7527,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
...directoryGrantsForRuntime(storedExtraDirs),
...(writableDirs.length > 0 ? { writableDirs } : {}),
});
+ await assertCurrent?.();
await ensureRemoteReadyForSessionStart({ createOpts: opts });
+ await assertCurrent?.();
const { session: resumedSession } = await bootstrapSession(opts);
+ await assertCurrent?.();
await markOrcaRoleIfNeeded(resumedSession.id, 'worker');
return true;
}
@@ -11481,12 +11484,14 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
* 清 knownNonOrca cache、在线时清空 vendorOptions。抽出来给 disableOrcaInternal 的「正常关闭」
* 和「悬空 lead 兜底」两条路径共用,避免两份漂移。
*/
- async function clearLeadOrcaRoleState(leadSessionId: string): Promise<void> {
+ async function clearLeadOrcaRoleState(leadSessionId: string, assertCurrent?: () => Promise<void>): Promise<void> {
+ await assertCurrent?.();
await setSessionOrcaRole(leadSessionId, null);
knownNonOrcaSessionIds.delete(leadSessionId);
const leadSess = maker.getSession(leadSessionId);
if (leadSess) {
+ await assertCurrent?.();
try {
await leadSess.setVendorOptions({
orcaRole: null,
@@ -11519,8 +11524,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
* - SESSION_DISABLE_ORCA IPC handler (renderer 手动 toggle)
* - cindy_helper end_team MCP tool (Lead agent 自动调)
*/
- async function disableOrcaInternal(leadSessionId: string): Promise<{ ok: true }> {
+ async function disableOrcaInternal(leadSessionId: string, assertCurrent?: () => Promise<void>): Promise<{ ok: true }> {
const team = await getActiveTeamByLead(leadSessionId);
+ await assertCurrent?.();
if (!team) {
// 没有 active team —— 但 Lead 的 orca_role 可能因为上一次关闭被中途打断而悬空成 'lead'
// (markTeamEnded / markWorkersStatusByTeam / archiveWorkersByTeam 已落库,setSessionOrcaRole(null)
@@ -11529,6 +11535,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// active team」之后,坏态自锁。所以这里做幂等兜底:仍是 stranded lead 就把角色清掉,
// 让「关闭协同」成为可靠的逃生口。
const role = await getSessionOrcaRole(leadSessionId);
+ await assertCurrent?.();
if (role === 'lead') {
log.warn('disableOrca: no active team but lead orca_role stranded; reconciling', {
leadSessionId,
@@ -11536,9 +11543,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// 上一次关闭若在 archiveWorkersByTeam 之前被打断,team 已非 active 但 worker session 还停在
// active + hidden + unreachable —— 一并补齐归档,否则它们会成为永远触达不到的孤儿 worker。
const workerRecycleScope = captureSessionRecycleScope();
- const orphanedWorkerSessionIds = await reconcileInactiveTeamWorkersForLead(leadSessionId);
+ const orphanedWorkerSessionIds = await reconcileInactiveTeamWorkersForLead(leadSessionId, assertCurrent);
for (const sid of orphanedWorkerSessionIds) {
+ await assertCurrent?.();
await recycleSessionWorktreeForStatusChange(sid, 'archived', workerRecycleScope);
+ await assertCurrent?.();
cleanupPendingInteractionsForSession(sid, 'orca_disable');
forgetKnownOrcaWorkerSession(sid);
}
@@ -11548,7 +11557,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
count: orphanedWorkerSessionIds.length,
});
}
- await clearLeadOrcaRoleState(leadSessionId);
+ await clearLeadOrcaRoleState(leadSessionId, assertCurrent);
} else {
log.info('disableOrca: no active team, no-op', { leadSessionId });
}
@@ -11558,8 +11567,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
const workers = await listWorkersByLead(leadSessionId);
const activeWorkers = workers.filter((w) => w.teamId === team.id);
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 {
@@ -11572,6 +11583,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
err: err instanceof Error ? err.message : String(err),
});
}
+ await assertCurrent?.();
try {
await maker.closeSession(w.sessionId);
} catch (err) {
@@ -11581,21 +11593,26 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
});
}
}
+ await assertCurrent?.();
cleanupPendingInteractionsForSession(w.sessionId, 'orca_disable');
forgetKnownOrcaWorkerSession(w.sessionId);
}
+ await assertCurrent?.();
await markTeamEnded(team.id, 'completed');
+ await assertCurrent?.();
await markWorkersStatusByTeam(team.id, 'done');
+ await assertCurrent?.();
const workerRecycleScope = captureSessionRecycleScope();
- const archivedWorkerSessionIds = await archiveWorkersByTeam(team.id);
+ const archivedWorkerSessionIds = await archiveWorkersByTeam(team.id, assertCurrent);
await Promise.all(
- archivedWorkerSessionIds.map((sessionId) =>
- recycleSessionWorktreeForStatusChange(sessionId, 'archived', workerRecycleScope),
- ),
+ archivedWorkerSessionIds.map(async (sessionId) => {
+ await assertCurrent?.();
+ await recycleSessionWorktreeForStatusChange(sessionId, 'archived', workerRecycleScope);
+ }),
);
- await clearLeadOrcaRoleState(leadSessionId);
+ await clearLeadOrcaRoleState(leadSessionId, assertCurrent);
log.info('disableOrca done', {
leadSessionId,
@@ -11758,11 +11775,13 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
markWorkerIdleIfStatus,
restoreWorkerDoneIfIdle,
cancelWorkerSessionOperations: cancelIOSSimulatorSessionOperations,
- closeWorkerSession: async (sessionId) => {
+ closeWorkerSession: async (sessionId, beforeClose) => {
const sess = maker.getSession(sessionId);
+ await beforeClose?.();
if (sess) {
await sess.abort();
}
+ await beforeClose?.();
await maker.closeSession(sessionId);
},
closeWorkerSessionIfIdle: async (sessionId, sendLockHeld = false) => {
@@ -11781,9 +11800,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
);
},
hasSendToSessionLock: (sessionId) => sendToSessionLocks.has(sessionId),
- archiveWorkerSession: async (sessionId) => {
+ archiveWorkerSession: async (sessionId, beforeMutation) => {
const workerRecycleScope = captureSessionRecycleScope();
- await archiveSingleWorkerSession(sessionId);
+ await archiveSingleWorkerSession(sessionId, beforeMutation);
+ await beforeMutation?.();
await recycleSessionWorktreeForStatusChange(sessionId, 'archived', workerRecycleScope);
},
getManualInterrupt,
@@ -12010,10 +12030,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
listWorkersByLead,
isActiveWorkerStatus,
readCollaborationSettings,
- validateCreationPlan: async (params, resolvedWorkingDir, resolvedRoute) => {
+ validateCreationPlan: async (params, resolvedWorkingDir, resolvedRoute, assertCurrent) => {
const epoch = getCurrentDbClientSnapshot();
if (!epoch) throw new PluginTaskError('HOST_NOT_READY','Task storage unavailable');
const receipt = await createPluginTaskStore(epoch.client).get(params.leadSessionId);
+ await assertCurrent?.();
if (!receipt || receipt.operation !== 'create' || hasRevokedPluginTaskOwnership(receipt)) return undefined;
const task = await pluginTaskServiceForCurrentOwner!().get(receipt.pluginId,params.leadSessionId);
if (epoch !== getCurrentDbClientSnapshot()) throw new PluginTaskError('PERMISSION_DENIED','Account changed');
@@ -12040,11 +12061,14 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
const plannedDirectory = item && resolvedRoute
? await resolveAuthorizedDirectory(item.workingDir) : undefined;
const currentTask = await pluginTaskServiceForCurrentOwner!().get(receipt.pluginId,params.leadSessionId);
+ await assertCurrent?.();
if (epoch !== getCurrentDbClientSnapshot() || currentTask.revision !== task.revision) throw new PluginTaskError('STALE_REVISION','Task changed during directory validation');
// Last admission check also covers no-plan plugin tasks and revocation
// while directory/receipt reads or the existing reservation were pending.
assertPluginWorkerAutoAuthorized(receipt.pluginId, currentTask);
if (cfg.workingDir !== readGhostErrandConfig(receipt.pluginId).workingDir) throw new PluginTaskError('PERMISSION_DENIED','Plugin directory authorization changed');
+ assertPluginWorkerDirectoryScope({ requested: directory, leadDirectory: currentTask.workingDir,
+ configuredDirectory: cfg.workingDir, isPickedDirectory: dir => isGhostPickedDir(receipt.pluginId, dir) });
if (!data.teamPlan) return undefined; // Existing plugins retain their original behavior.
if (!item || data.settledLabels?.includes(params.label)) throw new PluginTaskError('INVALID_REQUEST','Worker is not pending in the registered plan');
const route = item.route;
@@ -12156,7 +12180,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
return captureOrcaPluginAuthority(leadSessionId);
},
setWorkerPermissionMode: applyWorkerPermissionModePreference,
- createWorkerInTeam: (params, assertCurrent) => orcaWorkerCreationService.createWorkerInTeam(params, assertCurrent),
+ createWorkerInTeam: (params, assertCurrent, onCreated) => orcaWorkerCreationService.createWorkerInTeam(params, assertCurrent, onCreated),
dispatchWorkerTask: (params, assertCurrent) => orcaTeamService.dispatchWorkerTask(params, assertCurrent),
markTeamEnded,
setSessionOrcaRole,
@@ -13436,6 +13460,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
},
switchFocus: async ({ leadSessionId, workerIdOrLabel }) => {
try {
+ const { assertCurrent } = await captureOrcaPluginAuthority(leadSessionId);
const workers = await listWorkersByLead(leadSessionId);
const target = findFocusTargetWorker(workers, workerIdOrLabel);
if (!target)
@@ -13445,6 +13470,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
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
@@ -13452,7 +13478,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// dispatched (sendToWorker). Setting 'running' here without a task causes
// the icon to flash indefinitely (no turn → turn-done never fires).
if (target.status === 'idle') {
- await resumeOrcaWorkerSessionIfMissing(target);
+ await assertCurrent();
+ await resumeOrcaWorkerSessionIfMissing(target, assertCurrent);
}
broadcastToAllWindows(MAKER_PUSH.ORCA_WORKER_CHANGED, { leadSessionId });
return { ok: true, workerId: target.id };
@@ -13466,7 +13493,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
},
idleWorker: async ({ callerLeadSessionId, workerId, expectedStatus }) => {
try {
- return await orcaTeamService.idleWorker({ callerLeadSessionId, workerId, expectedStatus });
+ const { assertCurrent } = await captureOrcaPluginAuthority(callerLeadSessionId);
+ return await orcaTeamService.idleWorker({ callerLeadSessionId, workerId, expectedStatus }, { assertCurrent });
} catch (err) {
return {
ok: false,
@@ -13477,7 +13505,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
},
endTeam: async ({ leadSessionId }) => {
try {
- await disableOrcaInternal(leadSessionId);
+ const { assertCurrent } = await captureOrcaPluginAuthority(leadSessionId);
+ await disableOrcaInternal(leadSessionId, assertCurrent);
broadcastToAllWindows(MAKER_PUSH.ORCA_WORKER_CHANGED, { leadSessionId });
return { ok: true };
} catch (err) {
@@ -13490,7 +13519,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
},
archiveWorker: async ({ callerLeadSessionId, workerId }) => {
try {
- return await orcaTeamService.archiveWorker({ callerLeadSessionId, workerId });
+ const { assertCurrent } = await captureOrcaPluginAuthority(callerLeadSessionId);
+ return await orcaTeamService.archiveWorker({ callerLeadSessionId, workerId, beforeArchive: assertCurrent });
} catch (err) {
return {
ok: false,
diff --git a/docs/dev-rules/plugin-task-api-implementation.md b/docs/dev-rules/plugin-task-api-implementation.md
index b5432703ee..8904393455 100644
--- a/docs/dev-rules/plugin-task-api-implementation.md
+++ b/docs/dev-rules/plugin-task-api-implementation.md
@@ -50,6 +50,10 @@
### 主任务协调评测
+Worker 创建后至首条输入真正接受,继续核对实际解析的目录与模型路由;落盘、创建预留释放、Lead 激活和排队接收不会结束这次校验。异步来源/计划读取后同步复核当前目录授权,配置目录被取消或 picker 记录淘汰不能借旧检查放行。复用原创建失败补偿;排队后迟到拒绝只取消该输入,不删除已创建的 Worker。回调仅在 Host 内传递,不进入任务回执或 IPC 返回值。
+
+模型调用的暂停 Worker、归档、结束团队与切换焦点,也复用当前输入来源和插件权限检查;关闭、归档及既有目录锁等待后的写入前复核。原有延后完成确认保存同次调用的核验回调,消费一次后不重登记;独立用户确认不继承模型限制。用户 UI/远程控制的停止清理及内部失败补偿保持原入口。多步清理途中拒绝可能已有局部效果,不构成跨工具授权事务,也不保证停止已接受的原生执行。
+
已运行的插件 Lead 继续派发或替换 Worker 输入时,复用创建入口的当前归属/批准、Auto/Plan 与账号核验;更新、取消、合并排队输入同样复核。来源取当前输入及既有 send 回执,原生发送回执尚未返回、人工 steering 尚未接受时也不丢失插件来源。撤权后的运行中任务遇到自动回报(含绕过输入队列的原生直发)时,复用现有可见消息中最近的插件输入或 Host 保护的真人输入证据;自动消息本身不构成接管,缺少证据拒绝;来源不明的普通输入阻断回溯,不能跳过它借用更早的真人授权。重试沿既有 retrySource 继续原输入,不恢复已撤销的插件控制权;用户在保留任务中新发送且已接受的消息仍可发起普通 Orca。调用内核验覆盖查询/恢复与真正接收,interrupt 在队列恢复后、插队和停止前复核;队列修改同步核对所读条目仍是同一对象,不以相同 ID 覆盖后来的用户消息。以上不停止已经接收的原生执行,也不改变用户独立停止/清理入口。
任务写权限请求在当前宿主进程中按账号代际、安装修订和任务记忆拒绝或失败,插件 reload 和更换请求模式不能恢复自动弹窗。用户可在本机任务权限菜单点击“重新确认插件写权限”,复用原请求模式和原生确认;在途请求不能并发。此专用 IPC 拒绝 device-link,并校验真实顶层窗口、账号与安装修订。已有效授予的权限直接复用,未改变普通权限切换行为或旧 errand。重启宿主后可再次首次询问。