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 身份识别与回报结算 (#6659)

DavidShenXDa0ef681f5017
diff --git a/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts b/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
index 4164573d97..07dad66855 100644
--- a/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
+++ b/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
@@ -117,6 +117,31 @@ describe('orcaTeamStore', () => {
lastBridgedMessageId: 'reply-1', remoteStopConfirmedAt: 1234 });
});
+ // PR #6659 discussion_r4335615412: status and retirement used separate writes.
+ // Real store API + SQLite abort proves they roll back together; a reread after
+ // retry must contain done with no pending to prevent replay after restart. Unit
+ // tier, existing in-memory DB fixture; old cursor tests did not cover status.
+ it('commits remote report retirement and done status atomically', async () => {
+ const store = await import('../orcaTeamStore.js');
+ const client = createTestDbClient();
+ setCurrentDbClient(client, 'test-user');
+ await seedOrcaWorkers(client);
+ await store.setWorkerRemoteExecution('worker-1', { deviceId: 'device-b', remoteSessionId: 'remote-1' });
+ const pending = { clientIds: ['c-1'], baselineMessageId: 'old-reply' };
+ await store.updateWorkerStatus('worker-1', 'running');
+ await store.saveWorkerRemoteReport('worker-1', pending);
+ await client.exec(`CREATE TRIGGER reject_retirement BEFORE UPDATE OF pending_remote_report ON orca_workers
+ WHEN NEW.pending_remote_report IS NULL BEGIN SELECT RAISE(ABORT, 'retirement failed'); END`);
+ await expect(store.saveWorkerRemoteReport('worker-1', null, undefined, true)).rejects.toThrow('retirement failed');
+ expect(await client.queryOne('SELECT status, pending_remote_report FROM orca_workers WHERE id = ?', ['worker-1']))
+ .toEqual({ status: 'running', pending_remote_report: JSON.stringify(pending) });
+ await client.exec('DROP TRIGGER reject_retirement');
+ await store.saveWorkerRemoteReport('worker-1', null, undefined, true);
+ expect(await client.queryOne('SELECT status, pending_remote_report FROM orca_workers WHERE id = ?', ['worker-1']))
+ .toEqual({ status: 'done', pending_remote_report: null });
+ expect(await store.getRemoteWorkerByProxySession('worker-session-1')).toMatchObject({ pendingReport: null });
+ });
+
it('does not classify an associated remote open as orphaned even if removing its intent was interrupted', async () => {
const store = await import('../orcaTeamStore.js');
const client = createTestDbClient();
diff --git a/apps/desktop/src/main/localDb/chatHistoryReader.ts b/apps/desktop/src/main/localDb/chatHistoryReader.ts
index de5ea9a5d7..bb998db26f 100644
--- a/apps/desktop/src/main/localDb/chatHistoryReader.ts
+++ b/apps/desktop/src/main/localDb/chatHistoryReader.ts
@@ -18,6 +18,7 @@ import { and, asc, desc, eq, gt, gte, lt, inArray, isNotNull, isNull, ne, or, sq
import { getDbClient } from './client/current';
import { sessions, messages } from './schema';
import { messageToCamel } from './mapper';
+import { parseOrcaRemoteLead, type OrcaRemoteLead } from '../../shared/orcaRemoteWorker.js';
import { remoteVisibleSessionSql } from './ipc/botRemoteVisibility.js';
import {
managedDialogueRootLikePatterns,
@@ -27,6 +28,11 @@ import {
const messageRowid = sql<number>`"messages"."rowid"`;
+function remoteOrcaHistoryIdentity(raw: unknown): { orcaRemoteLead?: OrcaRemoteLead } {
+ const lead = parseOrcaRemoteLead(raw);
+ return lead ? { orcaRemoteLead: lead } : {};
+}
+
// ── Types ───────────────────────────────────────────────────────────────────
export type HistoryOrder = 'asc' | 'desc';
@@ -187,6 +193,7 @@ export interface SessionSummary {
status: string;
source: string;
orcaRole: string | null;
+ orcaRemoteLead?: OrcaRemoteLead;
parentSessionId: string | null;
createdAt: number; // unix ms
updatedAt: number;
@@ -251,6 +258,7 @@ export async function listSessionsForHistory(
status: sessions.status,
source: sessions.source,
orcaRole: sessions.orcaRole,
+ orcaRemoteLead: sessions.orcaRemoteLead,
parentSessionId: sessions.parentSessionId,
createdAt: sessions.createdAt,
updatedAt: sessions.updatedAt,
@@ -289,6 +297,7 @@ export async function listSessionsForHistory(
status: r.status,
source: r.source,
orcaRole: r.orcaRole,
+ ...remoteOrcaHistoryIdentity(r.orcaRemoteLead),
parentSessionId: r.parentSessionId,
createdAt: r.createdAt,
updatedAt: r.updatedAt,
diff --git a/apps/desktop/src/main/localDb/orcaTeamStore.ts b/apps/desktop/src/main/localDb/orcaTeamStore.ts
index 53293ee5bd..f1be88de37 100644
--- a/apps/desktop/src/main/localDb/orcaTeamStore.ts
+++ b/apps/desktop/src/main/localDb/orcaTeamStore.ts
@@ -2,6 +2,7 @@ import { BrowserWindow } from 'electron';
import { and, desc, eq, gt, inArray, isNotNull, isNull, ne } from 'drizzle-orm';
import { createId } from '@paralleldrive/cuid2';
import type { OrcaRemotePendingReport } from '../../shared/orcaRemoteWorker.js';
+import { parseOrcaRemoteLead } from '../../shared/orcaRemoteWorker.js';
import { getDbClient } from './client/current.js';
import type { OrcaRemoteWorkerProxySessionSeed } from './client/tx/types.js';
@@ -529,6 +530,14 @@ export async function getSessionOrcaRole(sessionId: string): Promise<OrcaRole |
return row?.orcaRole === 'lead' || row?.orcaRole === 'worker' ? row.orcaRole : null;
}
+/** Persisted execution-device identity; never inferred from model-supplied vendor options. */
+export async function getRemoteOrcaSession(sessionId: string) {
+ const [row] = await getDbClient().drizzle
+ .select({ status: sessions.status, orcaRemoteLead: sessions.orcaRemoteLead })
+ .from(sessions).where(eq(sessions.id, sessionId)).limit(1);
+ return row ? { status: row.status, orcaRemoteLead: parseOrcaRemoteLead(row.orcaRemoteLead) } : null;
+}
+
/**
* 设置 worker 的 task status。**`status === 'running'` 时会同时清掉 `idleSince`**
* (idle→running 唤醒收敛点, 见 review F3)。其他状态切换不动 `idleSince`,
@@ -769,12 +778,15 @@ export async function saveWorkerRemoteReport(
workerId: string,
pending: OrcaRemotePendingReport | null,
lastBridgedMessageId?: string,
+ markWorkerDone = false,
): Promise<void> {
const db = getDbClient();
await db
.drizzle.update(orcaWorkers)
.set({ pendingRemoteReport: pending ? JSON.stringify(pending) : null,
- ...(lastBridgedMessageId ? { lastBridgedMessageId } : {}) })
+ ...(lastBridgedMessageId ? { lastBridgedMessageId } : {}),
+ // One SQL update commits retirement and status together; neither can succeed alone.
+ ...(markWorkerDone ? { status: 'done' as const, updatedAt: Date.now() } : {}) })
.where(eq(orcaWorkers.id, workerId));
}
diff --git a/apps/desktop/src/main/maker-host/index.ts b/apps/desktop/src/main/maker-host/index.ts
index b4125dbfcb..26f0a90a47 100644
--- a/apps/desktop/src/main/maker-host/index.ts
+++ b/apps/desktop/src/main/maker-host/index.ts
@@ -83,7 +83,9 @@ import { isCindyMakeWorktreePath } from '../cindy-make/taskWorkspace.js';
import { runSourceGit } from '../cindy-make/sourceGit.js';
import { createMakeToolchainEnvironment } from '../cindy-make/toolchainEnvironment.js';
import { getMessagesForHistory } from '../localDb/chatHistoryReader.js';
-import { getWorkerLink, updateWorkerStatus } from '../localDb/orcaTeamStore.js';
+import { getWorkerLink, updateWorkerStatus, getRemoteOrcaSession, listWorkersByLead, getActiveTeamByLead } from '../localDb/orcaTeamStore.js';
+import { createOrcaRemoteWorkerBridge } from '../maker-ipc/orcaRemoteWorkerBridge.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
import { cleanupSessionTempAttachments } from '../maker-ipc/normalizeAttachments.js';
import { resolveGhostFsSessionSnapshot } from '../maker-ipc/ghostFsSessionSnapshot.js';
import { HOST_CONFIRM_TIMEOUT_MS } from '../maker-ipc/hostConfirmTiming.js';
@@ -116,6 +118,9 @@ import { prepareBotWorkspaceRuntime } from '../maker-ipc/botWorkspaceRuntime.js'
import type { MakerSessionCreateOpts } from '../maker-ipc/sessionRequest.js';
import {
dispatchInterAgentMessage,
+ captureRemoteWorkerReportSettlement,
+ getSessionActiveInputClientIds,
+ getSessionInputProvenance,
isActiveInputOwnerAuthored,
isSessionInTurn,
wireSessionToIpc,
@@ -403,6 +408,15 @@ type RemoteCcQuery = Awaited<
>;
let _maker: Maker | null = null;
+let remoteWorkerBridge: ReturnType<typeof createOrcaRemoteWorkerBridge> | null = null;
+
+export function handleRemoteWorkerBridge(
+ raw: unknown,
+ caller: { controllerDeviceId: string; sharedTask?: unknown } | null,
+) {
+ if (!remoteWorkerBridge) throwIpcError('PRECONDITION_FAILED', 'worker bridge unavailable');
+ return remoteWorkerBridge.handle(raw, caller);
+}
/** Upper bound for letting the confirming turn finish its reply before an Agent-approved restart. */
const AGENT_APP_UPDATE_TURN_DRAIN_MS = 2 * 60 * 1000;
/** Prepared Bot runtime records waiting for the matching Maker startup result. */
@@ -1236,6 +1250,7 @@ export function getMaker(): Maker {
return { makerMemoryEnabled: createOpts.makerMemoryEnabled === true };
},
orcaTeamStore: orcaTeamStoreAdapter,
+ forwardRemoteWorkerTool: (ctx, tool, args) => remoteWorkerBridge?.forwardTool(ctx, tool, args) ?? Promise.resolve(null),
readLeadHistory: async ({ leadSessionId, fromMs, limit, cursor }) => {
const page = await getMessagesForHistory({
sessionIds: [leadSessionId],
@@ -1264,6 +1279,18 @@ export function getMaker(): Maker {
dispatchInterAgentMessage,
} satisfies OrcaBridgeMcpDeps;
const orcaWorkerBridgeProvider = createOrcaWorkerBridgeMcpProvider(orcaBridgeDeps);
+ remoteWorkerBridge = createOrcaRemoteWorkerBridge({
+ getOwnerToken: getCurrentDbClientSnapshot,
+ readSession: getRemoteOrcaSession,
+ listWorkers: listWorkersByLead,
+ activeTeamId: async id => (await getActiveTeamByLead(id))?.id ?? null,
+ remoteInvoke,
+ // Remote runtime settles only the reported inputs; queued assignments keep running.
+ invokeTool: (ctx, tool, args) => orcaWorkerBridgeProvider.invokeTool(ctx, tool, args, { manageWorkerStatus: false }),
+ getActiveInputClientIds: getSessionActiveInputClientIds,
+ getAcceptedInputProvenance: sessionId => getSessionInputProvenance(sessionId).input,
+ captureReportSettlement: captureRemoteWorkerReportSettlement,
+ });
// Cindy Make 个人版任务专属工具:只有 sessions.source='cindy-make' 的任务在
// bootstrapSession 时拿到 vendorOptions 标记;Claude 据标记决定注册,Pi 按会话
// 剔出 server 列表,Codex 按线程下发 enabled=false,工具调用再按标记 fail-closed。
@@ -3248,6 +3275,7 @@ export async function preflightBotRuntimeResources(
* 重置 Maker 单例(切账号 / 测试用)。
*/
export function resetMaker(): void {
+ remoteWorkerBridge = null;
disposeRemoteAgentHost();
_sessionArchiveSync?.stop();
_sessionArchiveSync = null;
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaMcpHydrationCache.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaMcpHydrationCache.test.ts
index bbf9552ae9..bee8890009 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaMcpHydrationCache.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaMcpHydrationCache.test.ts
@@ -49,4 +49,14 @@ describe('orca MCP hydration cache', () => {
markOrcaMcpHydratedIfNeeded('session-1', {});
expect(isOrcaMcpHydrated('session-1')).toBe(false);
});
+
+ it('keeps execution-device handles hydrated without caching them as non-Orca', () => {
+ const opts = { vendorOptions: { orcaRemoteWorker: true } };
+ markKnownNonOrcaIfApplicable('session-1', opts);
+ expect(knownNonOrcaSessionIds.has('session-1')).toBe(false);
+ knownNonOrcaSessionIds.add('session-1');
+ markOrcaMcpHydratedIfNeeded('session-1', opts);
+ expect(isOrcaMcpHydrated('session-1')).toBe(true);
+ expect(knownNonOrcaSessionIds.has('session-1')).toBe(false);
+ });
});
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerBridge.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerBridge.test.ts
new file mode 100644
index 0000000000..dfdee37c04
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerBridge.test.ts
@@ -0,0 +1,333 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Logger, Maker, McpProviderContext } from '@cindy/maker-core';
+import {
+ createOrcaWorkerBridgeMcpProvider,
+ type OrcaWorkerLink,
+ type OrcaBridgeMcpDeps,
+} from '@cindy/orca-workflow';
+import type { OrcaRemoteLead } from '../../../shared/orcaRemoteWorker.js';
+import { createOrcaRemoteWorkerBridge } from '../orcaRemoteWorkerBridge.js';
+import type { OrcaWorkerRecord } from '../../localDb/orcaTeamStore.js';
+
+// Value: production MCP handlers → execution-device route → attested Lead handler. The live
+// 2026-10-21 probe failed for a valid remote session with no local orcaRole. Existing tests
+// covered local links only. Minimal input: one remote Worker, one queued report. Unit tier;
+// no sockets, Electron app or real account is needed. Also protects device/team/child isolation.
+function setup() {
+ let owner = 1;
+ let activeTeam: string | null = 'team-1';
+ const remoteLead: OrcaRemoteLead = {
+ leadDeviceId: 'pc',
+ leadDeviceName: 'PC',
+ leadSessionId: 'lead-1',
+ leadTitle: 'Lead',
+ workerLabel: 'tester',
+ };
+ const worker = {
+ id: 'worker-1',
+ teamId: 'team-1',
+ sessionId: 'proxy-1',
+ leadSessionId: 'lead-1',
+ status: 'running',
+ executionDevice: { deviceId: 'mac', remoteSessionId: 'remote-1' },
+ session: { id: 'proxy-1', agentKind: 'codex' },
+ } as OrcaWorkerRecord;
+ const link: OrcaWorkerLink = {
+ workerId: worker.id,
+ workflowId: worker.teamId,
+ workerSessionId: worker.sessionId,
+ leadSessionId: 'lead-1',
+ leadSession: { sessionId: 'lead-1', agentKind: 'codex', workingDir: '/lead', model: 'model' },
+ };
+ const log = {
+ child: () => log,
+ warn: vi.fn(),
+ debug: vi.fn(),
+ info: vi.fn(),
+ } as unknown as Logger;
+ const leadSession = {
+ id: 'lead-1',
+ agentKind: 'codex',
+ getStatus: () => 'ready',
+ onEvent: () => () => {},
+ };
+ const dispatch = vi.fn<NonNullable<OrcaBridgeMcpDeps['dispatchInterAgentMessage']>>(async () => ({
+ ok: true as const,
+ mode: 'queued' as const,
+ clientId: 'report-1',
+ }));
+ const settled = vi.fn(async () => { worker.status = 'done'; });
+ const captureSettlement = vi.fn((_proxy: string, _inputs: readonly string[]) => settled);
+ const activeInputIds = ['input-a'];
+ const getActiveInputClientIds = vi.fn(() => activeInputIds);
+ const getAcceptedInputProvenance = vi.fn<() => { originKind?: string } | null>(() => ({ originKind: 'orca' }));
+ const provider = createOrcaWorkerBridgeMcpProvider({
+ getMaker: () => ({ getSession: () => leadSession }) as unknown as Maker,
+ logger: log,
+ persistUserMessage: vi.fn(),
+ wireSession: vi.fn(),
+ orcaTeamStore: {
+ getWorkerLink: async () => link,
+ updateWorkerStatus: async (_id, status) => {
+ worker.status = status;
+ },
+ },
+ dispatchInterAgentMessage: dispatch,
+ readLeadHistory: async () => ({
+ items: [{ id: 'm1', role: 'user', content: 'Lead context', agentMeta: null, createdAt: 1 }],
+ nextCursor: null,
+ hasMore: false,
+ }),
+ });
+ const host = createOrcaRemoteWorkerBridge({
+ getOwnerToken: () => owner,
+ activeTeamId: async () => activeTeam,
+ readSession: vi.fn(),
+ listWorkers: async () => [worker],
+ remoteInvoke: vi.fn(),
+ invokeTool: (ctx, tool, args) => provider.invokeTool(ctx, tool, args, { manageWorkerStatus: false }),
+ captureReportSettlement: captureSettlement,
+ });
+ const remoteInvoke = vi.fn(async (_device: string, _channel: string, args: unknown[]) => ({
+ ok: true as const,
+ result: await host.handle(args[0], { controllerDeviceId: 'mac' }),
+ }));
+ const readSession = vi.fn(async () => ({ status: 'active', orcaRemoteLead: remoteLead }));
+ const execution = createOrcaRemoteWorkerBridge({
+ getOwnerToken: () => owner,
+ readSession,
+ remoteInvoke,
+ getActiveInputClientIds,
+ getAcceptedInputProvenance,
+ listWorkers: vi.fn(),
+ activeTeamId: vi.fn(),
+ invokeTool: vi.fn(),
+ });
+ const executionProvider = createOrcaWorkerBridgeMcpProvider({
+ getMaker: () => {
+ throw new Error('must never recreate Lead on execution device');
+ },
+ logger: log,
+ persistUserMessage: vi.fn(),
+ wireSession: vi.fn(),
+ forwardRemoteWorkerTool: execution.forwardTool,
+ });
+ const ctx: McpProviderContext = {
+ sessionId: 'remote-1',
+ workingDir: '/worker',
+ agentKind: 'codex',
+ mcpCallerAttested: true,
+ mcpCallerKind: 'root',
+ };
+ const request = {
+ sessionId: 'remote-1',
+ leadSessionId: 'lead-1',
+ tool: 'send_to_lead',
+ args: { worker_id: 'worker-1', message: 'verified result' },
+ };
+ return {
+ executionProvider,
+ execution,
+ host,
+ ctx,
+ request,
+ worker,
+ settled,
+ captureSettlement,
+ activeInputIds,
+ getActiveInputClientIds,
+ getAcceptedInputProvenance,
+ remoteInvoke,
+ dispatch,
+ readSession,
+ remoteLead,
+ changeOwner: () => owner++,
+ endTeam: () => {
+ activeTeam = null;
+ },
+ };
+}
+
+const json = (result: { content: Array<{ text: string }> }) => JSON.parse(result.content[0].text);
+
+describe('cross-device Worker bridge', () => {
+ // PR #6659 discussion_r4336139384: a persisted remote link does not authorize
+ // execution-device user turns. Existing tests checked root Agent identity only.
+ // Unit: real MCP/bridge handlers must reject before dispatch or settlement, even
+ // when cumulative reply IDs still include the Lead's input after human steering.
+ it.each([
+ { name: 'direct user turn', origin: {}, ids: ['user-1'] },
+ { name: 'accepted human steering', origin: { originKind: 'desktop' }, ids: ['input-a', 'user-1'] },
+ { name: 'no active input', origin: null, ids: [] },
+ ])('rejects a report from $name', async ({ origin, ids }) => {
+ const s = setup();
+ s.getAcceptedInputProvenance.mockReturnValue(origin);
+ s.activeInputIds.splice(0, s.activeInputIds.length, ...ids);
+ const result = await s.executionProvider.invokeTool(s.ctx, 'send_to_lead', s.request.args);
+ expect(result.isError).toBe(true);
+ expect(json(result)).toMatchObject({ code: 'NOT_LEAD_ASSIGNED_TURN' });
+ expect(s.remoteInvoke).not.toHaveBeenCalled();
+ expect(s.dispatch).not.toHaveBeenCalled();
+ expect(s.captureSettlement).not.toHaveBeenCalled();
+ expect(s.worker.status).toBe('running');
+ });
+
+ it('delivers a real remote Worker report to a busy Lead and settles it once', async () => {
+ const s = setup();
+ const result = await s.executionProvider.invokeTool(s.ctx, 'send_to_lead', s.request.args);
+ expect(json(result)).toMatchObject({
+ ok: true,
+ queued: true,
+ worker_id: 'worker-1',
+ lead_session_id: 'lead-1',
+ });
+ expect(s.dispatch).toHaveBeenCalledTimes(1);
+ expect(s.dispatch.mock.calls[0][0]).toMatchObject({
+ targetSessionId: 'lead-1',
+ source: 'worker',
+ workerId: 'worker-1',
+ rawContent: 'verified result',
+ });
+ expect(s.worker.status).toBe('done');
+ expect(s.settled).toHaveBeenCalledTimes(1);
+ expect(s.captureSettlement).toHaveBeenCalledWith('proxy-1', ['input-a']);
+ });
+
+ // Review regression: A reports while B is pending. Runtime keeps B, so shared MCP
+ // must leave the Worker running. The old local-status side effect bypassed that decision.
+ // Unit tier, real production tool/bridge handlers, one successful queued Lead delivery.
+ it('leaves Worker status to input-specific remote settlement when B is still pending', async () => {
+ const s = setup();
+ s.settled.mockImplementationOnce(async () => {});
+ s.readSession.mockImplementationOnce(async () => {
+ s.activeInputIds.splice(0, 1, 'input-b');
+ s.getAcceptedInputProvenance.mockReturnValue({});
+ return { status: 'active', orcaRemoteLead: s.remoteLead };
+ });
+ const result = await s.executionProvider.invokeTool(s.ctx, 'send_to_lead', s.request.args);
+ expect(json(result)).toMatchObject({ ok: true, queued: true });
+ expect(s.captureSettlement).toHaveBeenCalledWith('proxy-1', ['input-a']);
+ expect(s.worker.status).toBe('running');
+ });
+
+ it.each(['lead_status', 'read_lead', 'read_lead_history'])(
+ 'routes %s to the same owning Lead',
+ async (tool) => {
+ const s = setup();
+ s.getAcceptedInputProvenance.mockReturnValue({});
+ const result = await s.executionProvider.invokeTool(s.ctx, tool, { worker_id: 'worker-1' });
+ expect(json(result)).toMatchObject({ worker_id: 'worker-1', lead_session_id: 'lead-1' });
+ if (tool === 'read_lead_history')
+ expect(json(result).messages[0].content).toBe('Lead context');
+ expect(s.dispatch).not.toHaveBeenCalled();
+ expect(s.settled).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each([null, { controllerDeviceId: 'other' }, { controllerDeviceId: 'mac', sharedTask: {} }])(
+ 'rejects unattested, wrong-device and shared-task callers',
+ async (caller) => {
+ const s = setup();
+ await expect(s.host.handle(s.request, caller)).rejects.toThrow(/PERMISSION_DENIED/);
+ expect(s.dispatch).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each([
+ { sessionId: 'another-session' },
+ { leadSessionId: 'another-lead' },
+ { args: { worker_id: 'another-worker', message: 'spoof' } },
+ ])('rejects a forged link %j', async (patch) => {
+ const s = setup();
+ await expect(
+ s.host.handle({ ...s.request, ...patch }, { controllerDeviceId: 'mac' }),
+ ).rejects.toThrow(/PERMISSION_DENIED/);
+ expect(s.dispatch).not.toHaveBeenCalled();
+ });
+
+ it('rejects descendant reporters before forwarding to another computer', async () => {
+ const s = setup();
+ const result = await s.executionProvider.invokeTool(
+ { ...s.ctx, mcpCallerKind: 'descendant' },
+ 'send_to_lead',
+ s.request.args,
+ );
+ expect(json(result)).toMatchObject({ code: 'NESTED_AGENT_NOT_ALLOWED' });
+ expect(s.remoteInvoke).not.toHaveBeenCalled();
+ });
+
+ it('refuses tools outside the four Worker bridge operations', async () => {
+ const s = setup();
+ await expect(
+ s.host.handle({ ...s.request, tool: 'send_to_worker' }, { controllerDeviceId: 'mac' }),
+ ).rejects.toThrow(/INVALID_PARAMS/);
+ expect(s.dispatch).not.toHaveBeenCalled();
+ });
+
+ it('rejects ended teams and released Workers without dispatch', async () => {
+ const s = setup();
+ s.endTeam();
+ await expect(s.host.handle(s.request, { controllerDeviceId: 'mac' })).rejects.toThrow(
+ /PERMISSION_DENIED/,
+ );
+ s.readSession.mockResolvedValue({
+ status: 'active',
+ orcaRemoteLead: { ...s.remoteLead, releasedAt: 1 },
+ });
+ expect(
+ json((await s.execution.forwardTool(s.ctx, 'send_to_lead', s.request.args))!),
+ ).toMatchObject({ code: 'NOT_FOUND' });
+ expect(s.remoteInvoke).not.toHaveBeenCalled();
+ });
+
+ it.each(['CHANNEL_NOT_ALLOWED', 'REMOTE_DISABLED', 'DEVICE_OFFLINE'] as const)(
+ 'handles %s without replaying a report or settling pending state',
+ async (code) => {
+ const s = setup();
+ s.remoteInvoke.mockResolvedValue({
+ ok: false,
+ error: { code, message: 'unavailable' },
+ } as never);
+ const result = await s.executionProvider.invokeTool(s.ctx, 'send_to_lead', s.request.args);
+ expect(result.isError).toBe(true);
+ expect(json(result)).toMatchObject({ code });
+ expect(s.remoteInvoke).toHaveBeenCalledTimes(1);
+ expect(s.settled).not.toHaveBeenCalled();
+ },
+ );
+
+ it('does not deliver a stale-account result', async () => {
+ const s = setup();
+ s.remoteInvoke.mockImplementation(async () => {
+ s.changeOwner();
+ return { ok: true, result: { content: [], isError: false } };
+ });
+ await expect(
+ s.executionProvider.invokeTool(s.ctx, 'send_to_lead', s.request.args),
+ ).rejects.toThrow(/PERMISSION_DENIED/);
+ });
+
+ it('does not retry a timed-out report whose execution result is unknown', async () => {
+ const s = setup();
+ s.remoteInvoke.mockRejectedValueOnce(new Error('INVOKE_TIMEOUT'));
+ const result = await s.executionProvider.invokeTool(s.ctx, 'send_to_lead', s.request.args);
+ expect(json(result)).toMatchObject({ code: 'REMOTE_BRIDGE_UNAVAILABLE' });
+ expect(s.remoteInvoke).toHaveBeenCalledTimes(1);
+ expect(s.settled).not.toHaveBeenCalled();
+ });
+
+ it('leaves local Worker calls on their original path without extra DB or device reads', async () => {
+ const s = setup();
+ expect(
+ await s.execution.forwardTool(
+ { ...s.ctx, vendorOptions: { orcaRole: 'worker' } },
+ 'lead_status',
+ { worker_id: 'local' },
+ ),
+ ).toBeNull();
+ expect(s.readSession).not.toHaveBeenCalled();
+ expect(s.remoteInvoke).not.toHaveBeenCalled();
+ expect(s.getActiveInputClientIds).not.toHaveBeenCalled();
+ expect(s.getAcceptedInputProvenance).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerHost.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerHost.test.ts
index bcc7dc9e22..ad8d8e7525 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerHost.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerHost.test.ts
@@ -77,7 +77,7 @@ describe('orca remote worker host', () => {
});
it('reports its protocol version', () => {
- expect(setup().host.caps()).toEqual({ version: ORCA_REMOTE_WORKER_VERSION });
+ expect(setup().host.caps()).toEqual({ version: ORCA_REMOTE_WORKER_VERSION, workerBridge: true });
});
it('opens a worker task stamped with the server-verified caller, ignoring payload claims', async () => {
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerRuntime.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerRuntime.test.ts
index b187dea297..ab16bd9114 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerRuntime.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerRuntime.test.ts
@@ -159,7 +159,7 @@ describe('orca remote worker runtime', () => {
expect(state.enqueued[0]).toMatchObject({
clientId: 'c-1',
durableDelivery: true,
- text: '[From Orca Lead]\n转写这段访谈',
+ text: expect.stringContaining('[From Orca Lead]\n转写这段访谈'),
origin: { kind: 'orca', senderLabel: 'Lead', displayText: '转写这段访谈' },
createOpts: {
agentKind: 'claude-code',
@@ -168,7 +168,7 @@ describe('orca remote worker runtime', () => {
resumeSessionId: 'sdk-1',
},
});
- expect((state.enqueued[0] as { text: string }).text).not.toContain('worker_id');
+ expect((state.enqueued[0] as { text: string }).text).toContain('worker_id for tool calls is worker-1');
expect(runtime.hasPendingReport('proxy-1')).toBe(true);
});
@@ -197,6 +197,164 @@ describe('orca remote worker runtime', () => {
expect(deps.onTurnEnded).toHaveBeenCalledTimes(1);
});
+ // A manual bridge report must retire the same persisted poll identity, even before
+ // the first running poll; otherwise the next poll reopens running and reports twice.
+ it('retires a manual report before the first running poll without auto-reporting it again', async () => {
+ const { runtime, deps, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'report', clientId: 'c-1' });
+ await expect(runtime.captureReportSettlement('proxy-1', ['c-1'])()).resolves.toBe(true);
+ expect(deps.saveReport).toHaveBeenLastCalledWith('worker-1', null);
+ state.running = true;
+ await runtime.pollNow();
+ state.running = false;
+ state.receipts['c-1'] = 'accepted';
+ state.assistant = { id: 'msg-1', content: 'already reported' };
+ await runtime.pollNow();
+ expect(deps.onTurnStarted).not.toHaveBeenCalled();
+ expect(deps.onTurnEnded).not.toHaveBeenCalled();
+ expect(runtime.hasPendingReport('proxy-1')).toBe(false);
+ });
+
+ it('does not let an older manual report settle a newly dispatched task', async () => {
+ const { runtime } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'old', clientId: 'c-1' });
+ const settleOld = runtime.captureReportSettlement('proxy-1', ['c-1']);
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'new', clientId: 'c-2' });
+ await expect(settleOld()).resolves.toBe(false);
+ expect(runtime.hasPendingReport('proxy-1')).toBe(true);
+ });
+
+ // Unit regression for the 2026-10-21 review: capture used to retire the whole A+B
+ // group when A reported after B was already queued. The older test captured before B.
+ // Public dispatch/settlement/poll must keep B's durable identity and deliver its result,
+ // including after track restores the saved pending record; no timers or real device IO.
+ it.each([false, true])('reports queued B after A reports, restored=%s', async (restore) => {
+ const { runtime, deps, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'A', clientId: 'a' });
+ state.receipts.a = 'accepted';
+ state.running = true;
+ await runtime.pollNow();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'B', clientId: 'b' });
+
+ await expect(runtime.captureReportSettlement('proxy-1', ['a'])()).resolves.toBe(false);
+ expect(state.receipts.b).toBe('pending');
+ expect(runtime.hasPendingReport('proxy-1')).toBe(true);
+ expect(deps.saveReport).toHaveBeenLastCalledWith('worker-1', {
+ clientIds: ['b'], baselineMessageId: 'msg-0',
+ });
+ if (restore) {
+ runtime.untrack('proxy-1');
+ runtime.track({ ...ref, pendingReport: { clientIds: ['b'], baselineMessageId: 'msg-0' } });
+ }
+ state.receipts.b = 'accepted';
+ state.running = false;
+ state.assistant = { id: 'result-b', content: 'B completed' };
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledExactlyOnceWith('proxy-1', {
+ status: 'done', finalText: 'B completed',
+ });
+ });
+
+ it('waits for an in-flight running notification before settling a manual report', async () => {
+ const { runtime, deps, state } = setup();
+ let release!: () => void;
+ vi.mocked(deps.onTurnStarted).mockImplementationOnce(() => new Promise<void>(resolve => { release = resolve; }));
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'report', clientId: 'c-1' });
+ state.running = true;
+ const poll = runtime.pollNow();
+ await vi.waitFor(() => expect(deps.onTurnStarted).toHaveBeenCalledTimes(1));
+ const settled = runtime.captureReportSettlement('proxy-1', ['c-1'])();
+ expect(runtime.hasPendingReport('proxy-1')).toBe(true);
+ release();
+ await poll;
+ await expect(settled).resolves.toBe(true);
+ expect(runtime.hasPendingReport('proxy-1')).toBe(false);
+ });
+
+ it('keeps automatic reporting when an older peer supplies no input identity', async () => {
+ const { runtime, deps, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'A', clientId: 'a' });
+ await expect(runtime.captureReportSettlement('proxy-1')()).resolves.toBe(false);
+ state.receipts.a = 'accepted';
+ state.assistant = { id: 'result-a', content: 'A completed' };
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledExactlyOnceWith('proxy-1', {
+ status: 'done', finalText: 'A completed',
+ });
+ });
+
+ // The settlement save can overlap a new dispatch; its failed enqueue must not roll
+ // back to already reported A. Public dispatch/poll and persisted state are the contract.
+ it('does not resurrect reported A when B is prepared during settlement then rejected', async () => {
+ const { runtime, deps, state, invoke } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'A', clientId: 'a' });
+ let release!: () => void;
+ vi.mocked(deps.saveReport).mockImplementationOnce(() => new Promise<void>(resolve => { release = resolve; }));
+ const settle = runtime.captureReportSettlement('proxy-1', ['a'])();
+ await vi.waitFor(() => expect(release).toBeTypeOf('function'));
+ invoke.mockClear();
+ const dispatch = runtime.dispatch({
+ proxySessionId: 'proxy-1', rawContent: 'B', clientId: 'b',
+ beforeEnqueue: () => { throw new Error('B rejected'); },
+ }).catch((error: unknown) => error);
+ await vi.waitFor(() => expect(invoke).toHaveBeenCalledWith(ref.deviceId, 'local-db:sessions:get', ['remote-1']));
+ release();
+ await settle;
+ expect(await dispatch).toMatchObject({ message: 'B rejected' });
+ expect(runtime.hasPendingReport('proxy-1')).toBe(false);
+ expect(deps.saveReport).toHaveBeenLastCalledWith('worker-1', null, undefined);
+ state.receipts.a = 'accepted';
+ state.assistant = { id: 'result-a', content: 'already reported' };
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).not.toHaveBeenCalled();
+ });
+
+ it('preserves automatic reporting when persisting manual settlement fails', async () => {
+ const { runtime, deps, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'report', clientId: 'c-1' });
+ vi.mocked(deps.saveReport).mockRejectedValueOnce(new Error('storage unavailable'));
+ await expect(runtime.captureReportSettlement('proxy-1', ['c-1'])()).rejects.toThrow('storage unavailable');
+ expect(runtime.hasPendingReport('proxy-1')).toBe(true);
+ state.receipts['c-1'] = 'accepted';
+ state.assistant = { id: 'msg-1', content: 'result' };
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledTimes(1);
+ });
+
+ // The Team commit callback adds an asynchronous boundary to report retirement.
+ // Public dispatch/settlement/poll must preserve B prepared while that callback waits;
+ // the old save-only races did not exercise this boundary. Unit, no real IO/timers.
+ it('preserves B prepared while the Team settlement is waiting', async () => {
+ const { runtime, deps, invoke, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'A', clientId: 'a' });
+ let release!: () => void;
+ let entered!: () => void;
+ const gate = new Promise<void>(resolve => { release = resolve; });
+ const started = new Promise<void>(resolve => { entered = resolve; });
+ const settle = runtime.captureReportSettlement('proxy-1', ['a'], async commit => {
+ entered(); await gate; await commit(true);
+ })();
+ try {
+ await started;
+ invoke.mockClear();
+ const dispatch = runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'B', clientId: 'b' });
+ await vi.waitFor(() => expect(invoke).toHaveBeenCalledWith(ref.deviceId, 'local-db:sessions:get', ['remote-1']));
+ release();
+ await expect(settle).resolves.toBe(false);
+ await dispatch;
+ expect(runtime.hasPendingReport('proxy-1')).toBe(true);
+ expect(deps.saveReport).toHaveBeenLastCalledWith('worker-1', {
+ clientIds: ['b'], baselineMessageId: 'msg-0',
+ }, undefined);
+ state.receipts.b = 'accepted';
+ state.assistant = { id: 'result-b', content: 'B completed' };
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledExactlyOnceWith('proxy-1', {
+ status: 'done', finalText: 'B completed',
+ });
+ } finally { release(); await settle; }
+ });
+
it('keeps waiting while the message is still queued behind other input on the device', async () => {
const { runtime, deps, state } = setup();
await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: '转写', clientId: 'c-1' });
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkers.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkers.test.ts
index e6f610aa54..9a49037095 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkers.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkers.test.ts
@@ -2,7 +2,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
import { DeviceLinkError, type InvokeResultPayload } from '@cindy/device-link';
import type { DeviceLinkDeviceView } from '../../../shared/deviceLinkIpc.js';
-import type { OrcaTeamService, OrcaTeamServiceDeps, WorkerTerminalTurnCapture } from '../orcaTeamService.js';
+import type { OrcaRemotePendingReport } from '../../../shared/orcaRemoteWorker.js';
+import { createOrcaTeamService, type OrcaTeamService, type OrcaTeamServiceDeps, type OrcaWorkerRecordSnapshot, type WorkerTerminalTurnCapture } from '../orcaTeamService.js';
import { withSendToSessionLock } from '../sendToSessionLock.js';
import { createOrcaRemoteWorkerHost, type OrcaRemoteWorkerExistingSession } from '../orcaRemoteWorkerHost.js';
@@ -12,7 +13,8 @@ const store = vi.hoisted(() => ({
listActiveRemoteWorkers: vi.fn(async () => []),
listUnreleasedEndedRemoteWorkers: vi.fn(async () => []),
markWorkerRemoteReleased: vi.fn(async () => undefined),
- saveWorkerRemoteReport: vi.fn(async () => undefined),
+ saveWorkerRemoteReport: vi.fn(async (_id: string, _pending: OrcaRemotePendingReport | null,
+ _messageId?: string, _markWorkerDone?: boolean) => undefined),
markWorkerRemoteStopConfirmed: vi.fn(async () => undefined),
getWorkerRemoteReleaseState: vi.fn(async () => ({ remoteStopConfirmedAt: null as number | null, remoteReleasedAt: null as number | null })),
saveRemoteWorkerOpen: vi.fn(async () => undefined),
@@ -130,6 +132,7 @@ function baseDeps() {
beforeEach(() => {
vi.clearAllMocks();
+ store.saveWorkerRemoteReport.mockReset().mockResolvedValue(undefined);
});
describe('invokeDeviceValue', () => {
@@ -495,6 +498,10 @@ describe('wrapTeamDeps', () => {
captureWorkerText: vi.fn(),
handleWorkerTerminalTurn: vi.fn(async () => { capture = { ...capture, autoBridgeIdentity: null }; }),
handleWorkerTurnStarted: vi.fn(async () => undefined),
+ settleReportedWorker: vi.fn(async (reported: WorkerTerminalTurnCapture) => {
+ if (capture.autoBridgeIdentity === reported.autoBridgeIdentity)
+ capture = { ...capture, autoBridgeIdentity: null };
+ }),
};
const history: Array<{ id: string; clientId?: string; role: string; content: string }> = [];
const handle = (_deviceId: string, channel: string, args: unknown[]) => {
@@ -520,6 +527,66 @@ describe('wrapTeamDeps', () => {
return { service, history, handle, onAccepted, capture: () => capture };
}
+ async function trackedTeam(setupOpts: Parameters<typeof setup>[0] = {}) {
+ let service!: OrcaTeamService;
+ const ctx = await trackedWorker({ ...setupOpts, getTeamService: () => service });
+ let worker = { id: 'w-1', teamId: 'team-1', leadSessionId: 'lead-1', sessionId: 'proxy-1',
+ status: 'idle', session: { ...proxySeed, agentKind: 'claude-code' } } as OrcaWorkerRecordSnapshot;
+ store.saveWorkerRemoteReport.mockImplementation(async (_id, _pending, _messageId, markWorkerDone) => {
+ if (markWorkerDone) worker = { ...worker, status: 'done' };
+ return undefined;
+ });
+ const deps = {
+ ...baseDeps(),
+ getWorkerLinkBySessionId: vi.fn(async () => ({ workerId: 'w-1', teamId: 'team-1',
+ workerSessionId: 'proxy-1', leadSessionId: 'lead-1' })),
+ listWorkersByLead: async () => [worker],
+ getManualInterrupt: () => null,
+ clearManualInterrupt: vi.fn(),
+ updateWorkerStatus: vi.fn(async (_id: string, status: OrcaWorkerRecordSnapshot['status']) => {
+ worker = { ...worker, status };
+ }),
+ broadcastOrcaWorkerChanged: vi.fn(),
+ onLeadWorkerReportsSettled: vi.fn(),
+ sendAutoBridgeToLead: vi.fn(async () => ({ accepted: true })),
+ log: { info: vi.fn(), warn: vi.fn() },
+ };
+ service = createOrcaTeamService(ctx.workers.wrapTeamDeps(deps));
+ return { ...ctx, service, deps, getWorker: () => worker };
+ }
+
+ // PR #6659 / discussion_r4334849858: deleting runtime/durable pending before Team
+ // settlement loses the only retry after a DB lookup/write failure. The inverse
+ // order also lost Team pending on retirement failure (discussion_r4335615412).
+ // Unit: real host settlement + TeamService, one report and
+ // a one-shot storage failure; polling must later release the Lead without new input.
+ it.each(['lookup', 'retirement'] as const)('keeps a report retryable after Team %s fails', async (failure) => {
+ const report = reportService();
+ const { workers, remoteInvoke, service, deps, getWorker } = await trackedTeam({ handle: report.handle });
+ try {
+ await service.sendToWorker({ callerLeadSessionId: 'lead-1', targetSessionId: 'proxy-1', message: 'A' });
+ const enqueue = remoteInvoke.mock.calls.find(([, channel]) => channel === 'maker:input:enqueue')!;
+ const clientId = (enqueue[2][1] as { clientId: string }).clientId;
+ store.saveWorkerRemoteReport.mockClear();
+ if (failure === 'lookup') deps.getWorkerLinkBySessionId.mockRejectedValueOnce(new Error('storage unavailable'));
+ else store.saveWorkerRemoteReport.mockRejectedValueOnce(new Error('storage unavailable'));
+
+ await expect(workers.captureReportSettlement('proxy-1', [clientId])()).rejects.toThrow('storage unavailable');
+ expect(workers.runtime.hasPendingReport('proxy-1')).toBe(true);
+ expect(service.hasPendingWorkerReports('lead-1')).toBe(true);
+ expect(getWorker().status).toBe('running');
+ if (failure === 'retirement') expect(store.saveWorkerRemoteReport).toHaveBeenCalledOnce();
+ else expect(store.saveWorkerRemoteReport).not.toHaveBeenCalled();
+
+ report.history.push({ id: 'result-a', role: 'assistant', content: 'A completed' });
+ await workers.runtime.pollNow();
+ expect(workers.runtime.hasPendingReport('proxy-1')).toBe(false);
+ expect(service.hasPendingWorkerReports('lead-1')).toBe(false);
+ expect(getWorker().status).toBe('done');
+ expect(deps.onLeadWorkerReportsSettled).toHaveBeenCalledOnce();
+ } finally { workers.stop(); }
+ });
+
it('waits for the host accepted lifecycle before reporting an immediate remote reply', async () => {
const report = reportService();
const { workers } = await trackedWorker({ handle: report.handle, getTeamService: () => report.service as unknown as OrcaTeamService });
@@ -688,6 +755,45 @@ describe('wrapTeamDeps', () => {
} finally { workers.stop(); }
});
+ // Review regression: runtime-only rollback tests missed TeamService restoring A after
+ // A was reported while B's pre-enqueue save was waiting. Real service + remote adapter
+ // must leave neither layer pending after B fails. Unit tier, in-memory store/transport.
+ it('reconciles Team pending when B fails after A was reported during B preparation', async () => {
+ let rejectEnqueue = false;
+ const { workers, remoteInvoke, service, deps, getWorker } = await trackedTeam({
+ handle: (_device, channel) => channel === 'maker:input:enqueue' && rejectEnqueue
+ ? fail('PERMISSION_DENIED', 'remote enqueue rejected') : undefined,
+ });
+ let release: (() => void) | undefined;
+ try {
+ const params = { callerLeadSessionId: 'lead-1', targetSessionId: 'proxy-1', message: 'A' };
+ await expect(service.sendToWorker(params)).resolves.toMatchObject({ ok: true });
+ const firstInput = remoteInvoke.mock.calls.find(([, channel]) => channel === 'maker:input:enqueue')!;
+ const clientId = (firstInput[2][1] as { clientId: string }).clientId;
+ const lookup = deps.getWorkerLinkBySessionId.getMockImplementation()!;
+ deps.getWorkerLinkBySessionId.mockImplementationOnce(() => new Promise(resolve => {
+ release = () => { void lookup().then(resolve); };
+ }));
+ const settle = workers.captureReportSettlement('proxy-1', [clientId])();
+ await vi.waitFor(() => expect(release).toBeTypeOf('function'));
+ // The lookup wait precedes the transition lock, so B can prepare while
+ // A still owns Team pending. The atomic write has not committed yet.
+ expect(service.hasPendingWorkerReports('lead-1')).toBe(true);
+ expect(deps.onLeadWorkerReportsSettled).not.toHaveBeenCalled();
+ remoteInvoke.mockClear();
+ rejectEnqueue = true;
+ const dispatchB = service.sendToWorker({ ...params, message: 'B' });
+ await vi.waitFor(() => expect(remoteInvoke).toHaveBeenCalledWith('mac-mini', 'local-db:sessions:get', ['remote-1']));
+ release!();
+ await settle;
+ await expect(dispatchB).resolves.toMatchObject({ ok: false });
+ expect(workers.runtime.hasPendingReport('proxy-1')).toBe(false);
+ expect(service.hasPendingWorkerReports('lead-1')).toBe(false);
+ expect(getWorker().status).toBe('done');
+ expect(deps.onLeadWorkerReportsSettled).toHaveBeenCalledTimes(2);
+ } finally { release?.(); workers.stop(); }
+ });
+
it('preserves accepted rejection when its rollback also fails', async () => {
const { workers, remoteInvoke } = await trackedWorker();
const error = new Error('permission revoked');
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaSessionStartOptions.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaSessionStartOptions.test.ts
index 8d381522cb..2951f5f8d4 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaSessionStartOptions.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaSessionStartOptions.test.ts
@@ -18,6 +18,21 @@ describe('persisted Orca session start options', () => {
knownNonOrcaSessionIds.clear();
});
+ // The execution device has no local team/role row. Its persisted origin must enable
+ // the bridge across fresh/resumed starts without turning it into a nested local Worker.
+ it.each(['codex', 'claude-code', 'pi'] as const)('enables the remote bridge for %s without a local role', async agentKind => {
+ const lead = { leadDeviceId: 'pc', leadDeviceName: 'PC', leadSessionId: 'lead-1', leadTitle: 'Lead', workerLabel: 'tester' };
+ const opts = { ...baseOpts('remote-session'), agentKind };
+ await preparePersistedOrcaSessionStart('remote-session', opts, {
+ getSessionRole: async () => null, getWorkerLink: vi.fn(),
+ getRemoteLead: async () => lead, warn: vi.fn(),
+ });
+ expect(opts.vendorOptions).toMatchObject({ orcaRemoteWorker: true, orcaRemoteLead: lead });
+ expect(opts.orcaRole).toBeUndefined();
+ expect(opts.userPrompt).toBeUndefined();
+ expect(knownNonOrcaSessionIds.has('remote-session')).toBe(false);
+ });
+
it('reconstructs persisted Lead vendor options and instructions', async () => {
const opts = baseOpts('lead-session');
const getWorkerLink = vi.fn();
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 33a9d6c343..f660c5cd4a 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
@@ -558,7 +558,7 @@ describe('OrcaTeamService', () => {
finalText: '完成了',
});
- expect(leadMessages).toEqual(['[Auto-bridged: worker 完成但未调 send_to_lead]\n\n完成了']);
+ expect(leadMessages).toEqual(['[Auto-bridged: worker 已完成,系统自动回传结果]\n\n完成了']);
});
it('resumes a stale running worker before dispatching the next task', async () => {
@@ -1210,7 +1210,7 @@ describe('OrcaTeamService', () => {
finalText: '完成了',
});
- expect(leadMessages).toEqual(['[Auto-bridged: worker 完成但未调 send_to_lead]\n\n完成了']);
+ expect(leadMessages).toEqual(['[Auto-bridged: worker 已完成,系统自动回传结果]\n\n完成了']);
});
it('rolls back running status and pending auto-bridge when accepted dispatch returns failure', async () => {
@@ -1493,8 +1493,8 @@ describe('OrcaTeamService', () => {
expect(sendAutoBridgeToLead).toHaveBeenCalledTimes(2);
expect(leadMessages).toEqual([
- '[Auto-bridged: worker 完成但未调 send_to_lead]\n\n第一次结果',
- '[Auto-bridged: worker 完成但未调 send_to_lead]\n\n第二次结果',
+ '[Auto-bridged: worker 已完成,系统自动回传结果]\n\n第一次结果',
+ '[Auto-bridged: worker 已完成,系统自动回传结果]\n\n第二次结果',
]);
});
@@ -1537,6 +1537,23 @@ describe('OrcaTeamService', () => {
expect(onLeadWorkerReportsSettled).toHaveBeenCalledWith('lead-1');
});
+ // Cross-device manual reporting settles the same TeamService identity as auto-bridge.
+ // Existing local/manual status tests did not cover a report arriving before the first poll.
+ it('settles an attested remote report once and leaves a newer assignment pending', async () => {
+ const { service, deps, getWorker } = createDeps();
+ await service.sendToWorker({ callerLeadSessionId: 'lead-1', targetSessionId: 'worker-session-1', message: 'first' });
+ const first = service.captureWorkerTerminalTurn('worker-session-1');
+ await service.settleReportedWorker(first);
+ expect(getWorker().status).toBe('done');
+ expect(service.hasPendingWorkerReports('lead-1')).toBe(false);
+ await service.handleWorkerTerminalTurn({ sessionId: 'worker-session-1', status: 'done', finalText: 'reported', capture: first });
+ expect(deps.sendAutoBridgeToLead).not.toHaveBeenCalled();
+ await service.sendToWorker({ callerLeadSessionId: 'lead-1', targetSessionId: 'worker-session-1', message: 'second' });
+ await service.settleReportedWorker(first);
+ expect(service.hasPendingWorkerReports('lead-1')).toBe(true);
+ expect(getWorker().status).toBe('running');
+ });
+
it('keeps the lead report outstanding while delivery is rejected', async () => {
const onLeadWorkerReportsSettled = vi.fn();
const sendAutoBridgeToLead = vi.fn(async () => ({ accepted: false }));
@@ -1917,7 +1934,7 @@ describe('OrcaTeamService', () => {
capture: replacementCapture,
});
expect(leadMessages).toEqual([
- '[Auto-bridged: worker 完成但未调 send_to_lead]\n\nreplacement output',
+ '[Auto-bridged: worker 已完成,系统自动回传结果]\n\nreplacement output',
]);
});
@@ -2005,7 +2022,7 @@ describe('OrcaTeamService', () => {
capture: service.captureWorkerTerminalTurn('worker-session-1'),
});
expect(leadMessages).toEqual([
- '[Auto-bridged: worker 完成但未调 send_to_lead]\n\nfollow-up output',
+ '[Auto-bridged: worker 已完成,系统自动回传结果]\n\nfollow-up output',
]);
});
@@ -2040,7 +2057,7 @@ describe('OrcaTeamService', () => {
'broadcastOrcaWorkerChanged',
]);
expect(leadMessages).toEqual([
- `${status === 'error' ? '[Auto-bridged: worker 异常终止]' : '[Auto-bridged: worker 完成但未调 send_to_lead]'}\n\n完成了`,
+ `${status === 'error' ? '[Auto-bridged: worker 异常终止]' : '[Auto-bridged: worker 已完成,系统自动回传结果]'}\n\n完成了`,
]);
},
);
@@ -2097,8 +2114,8 @@ describe('OrcaTeamService', () => {
});
expect(leadMessages).toEqual([
- '[Auto-bridged: worker 完成但未调 send_to_lead]\n\n旧输出',
- '[Auto-bridged: worker 完成但未调 send_to_lead]\n\n(no output captured)',
+ '[Auto-bridged: worker 已完成,系统自动回传结果]\n\n旧输出',
+ '[Auto-bridged: worker 已完成,系统自动回传结果]\n\n(no output captured)',
]);
});
@@ -2124,7 +2141,7 @@ describe('OrcaTeamService', () => {
finalText: '',
});
- expect(leadMessages).toEqual(['[Auto-bridged: worker 完成但未调 send_to_lead]\n\n部分输出']);
+ expect(leadMessages).toEqual(['[Auto-bridged: worker 已完成,系统自动回传结果]\n\n部分输出']);
});
it('bridges the terminal diagnostic when an errored worker produced no output', async () => {
diff --git a/apps/desktop/src/main/maker-ipc/orcaMcpHydrationCache.ts b/apps/desktop/src/main/maker-ipc/orcaMcpHydrationCache.ts
index 56368b0389..a142e0dffb 100644
--- a/apps/desktop/src/main/maker-ipc/orcaMcpHydrationCache.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaMcpHydrationCache.ts
@@ -19,6 +19,7 @@ export function readOrcaRoleFromVendorOptions(
// orcaRole/vendorOptions.orcaRole; otherwise this cache will skip the later DB
// lookup. Current normal entrypoints do pass the role and are covered by tests.
export function markKnownNonOrcaIfApplicable(sessionId: string, o: OrcaRoleCreateOpts): void {
+ if (o.vendorOptions?.orcaRemoteWorker === true) return;
const role = readOrcaRoleFromVendorOptions(o.vendorOptions);
if (role === 'lead' || role === 'worker') return;
if (o.orcaRole === 'lead' || o.orcaRole === 'worker') return;
@@ -27,7 +28,7 @@ export function markKnownNonOrcaIfApplicable(sessionId: string, o: OrcaRoleCreat
export function markOrcaMcpHydratedIfNeeded(sessionId: string, o: OrcaRoleCreateOpts): void {
const role = readOrcaRoleFromVendorOptions(o.vendorOptions);
- if (role !== 'lead' && role !== 'worker') return;
+ if (role !== 'lead' && role !== 'worker' && o.vendorOptions?.orcaRemoteWorker !== true) return;
orcaMcpHydratedSessionIds.add(sessionId);
knownNonOrcaSessionIds.delete(sessionId);
}
diff --git a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerBridge.ts b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerBridge.ts
new file mode 100644
index 0000000000..2ccdda2018
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerBridge.ts
@@ -0,0 +1,184 @@
+/** Route only the four Worker bridge tools, using persisted links on both computers. */
+import {
+ ORCA_REMOTE_WORKER_BRIDGE_CHANNEL,
+ parseOrcaRemoteWorkerBridgeRequest,
+ isOrcaRemoteWorkerSessionId,
+ type InvokeResultPayload,
+} from '@cindy/device-link';
+import type { McpProviderContext } from '@cindy/maker-core';
+import { authorizeSendToLeadCaller } from '@cindy/orca-workflow/mcp';
+import type { OrcaToolResult } from '@cindy/orca-workflow';
+import type { OrcaRemoteLead } from '../../shared/orcaRemoteWorker.js';
+import type { OrcaWorkerRecord } from '../localDb/orcaTeamStore.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+
+export interface OrcaRemoteWorkerBridgeDeps {
+ getOwnerToken(): unknown;
+ readSession(
+ sessionId: string,
+ ): Promise<{ status: string; orcaRemoteLead: OrcaRemoteLead | null } | null>;
+ listWorkers(leadSessionId: string): Promise<OrcaWorkerRecord[]>;
+ activeTeamId(leadSessionId: string): Promise<string | null>;
+ invokeTool(
+ ctx: McpProviderContext,
+ tool: string,
+ args: Record<string, unknown>,
+ ): Promise<OrcaToolResult>;
+ remoteInvoke(deviceId: string, channel: string, args: unknown[]): Promise<InvokeResultPayload>;
+ getActiveInputClientIds?(sessionId: string): readonly string[];
+ /** Host-owned accepted input; cumulative reply IDs alone survive human steering. */
+ getAcceptedInputProvenance?(sessionId: string): { originKind?: string } | null;
+ captureReportSettlement?(proxySessionId: string, reportedInputClientIds: readonly string[]): () => Promise<void>;
+}
+
+const toolError = (error: string, code: string): OrcaToolResult => ({
+ content: [{ type: 'text', text: JSON.stringify({ error, code }) }],
+ isError: true,
+});
+
+export function createOrcaRemoteWorkerBridge(deps: OrcaRemoteWorkerBridgeDeps) {
+ const assertOwner = (owner: unknown) => {
+ if (owner !== deps.getOwnerToken())
+ throwIpcError('PERMISSION_DENIED', 'worker account changed');
+ };
+ return {
+ async forwardTool(
+ ctx: McpProviderContext,
+ tool: string,
+ args: Record<string, unknown>,
+ ): Promise<OrcaToolResult | null> {
+ if (!ctx.sessionId) return null;
+ // Local Workers keep their existing path, including its latency and DB reads.
+ if (ctx.vendorOptions?.orcaRole === 'worker' || ctx.vendorOptions?.orcaRole === 'lead')
+ return null;
+ // Freeze before any await: another input can be queued or start during the round trip.
+ // These IDs come from the execution host, never from model-supplied tool arguments.
+ const leadAssignedTurn = tool === 'send_to_lead'
+ && deps.getAcceptedInputProvenance?.(ctx.sessionId)?.originKind === 'orca';
+ const reportedInputClientIds = tool === 'send_to_lead'
+ ? [...(deps.getActiveInputClientIds?.(ctx.sessionId) ?? [])]
+ .filter(isOrcaRemoteWorkerSessionId).slice(-64)
+ : undefined;
+ const owner = deps.getOwnerToken();
+ const row = await deps.readSession(ctx.sessionId);
+ assertOwner(owner);
+ const lead = row?.orcaRemoteLead;
+ if (!lead) return null;
+ if (row.status !== 'active' || lead.releasedAt !== undefined) {
+ return toolError('remote worker collaboration has ended', 'NOT_FOUND');
+ }
+ // Provenance is checked on the execution device before crossing the device boundary.
+ if (tool === 'send_to_lead') {
+ const auth = authorizeSendToLeadCaller(ctx);
+ if (!auth.ok)
+ return { content: [{ type: 'text', text: JSON.stringify(auth.error) }], isError: true };
+ if (!leadAssignedTurn || !reportedInputClientIds?.length) {
+ return toolError(
+ 'This turn was not assigned by the Lead. Reply in the execution-device task instead.',
+ 'NOT_LEAD_ASSIGNED_TURN',
+ );
+ }
+ }
+ const request = parseOrcaRemoteWorkerBridgeRequest({
+ sessionId: ctx.sessionId,
+ leadSessionId: lead.leadSessionId,
+ tool,
+ args,
+ ...(reportedInputClientIds ? { reportedInputClientIds } : {}),
+ });
+ try {
+ const response = await deps.remoteInvoke(
+ lead.leadDeviceId,
+ ORCA_REMOTE_WORKER_BRIDGE_CHANNEL,
+ [request],
+ );
+ assertOwner(owner);
+ if (response.ok) {
+ const result = response.result as Partial<OrcaToolResult> | null;
+ if (
+ !result ||
+ !Array.isArray(result.content) ||
+ typeof result.isError !== 'boolean' ||
+ result.content.some((item) => item?.type !== 'text' || typeof item.text !== 'string')
+ ) {
+ return toolError('invalid Lead bridge response', 'REMOTE_BRIDGE_UNAVAILABLE');
+ }
+ return result as OrcaToolResult;
+ }
+ return toolError(
+ 'Lead bridge unavailable; finish with a final reply for automatic reporting.',
+ response.error.code,
+ );
+ } catch {
+ assertOwner(owner);
+ // A timed-out report may already be queued. Never automatically replay a write.
+ return toolError(
+ 'Lead bridge result unknown; do not resend. Finish with a final reply for automatic reporting.',
+ 'REMOTE_BRIDGE_UNAVAILABLE',
+ );
+ }
+ },
+
+ async handle(
+ raw: unknown,
+ caller: { controllerDeviceId: string; sharedTask?: unknown } | null,
+ ): Promise<OrcaToolResult> {
+ if (!caller?.controllerDeviceId || caller.sharedTask) {
+ throwIpcError(
+ 'PERMISSION_DENIED',
+ 'worker bridge requires a same-account execution device',
+ );
+ }
+ const request = parseOrcaRemoteWorkerBridgeRequest(raw);
+ const owner = deps.getOwnerToken();
+ const teamId = await deps.activeTeamId(request.leadSessionId);
+ assertOwner(owner);
+ const workers = await deps.listWorkers(request.leadSessionId);
+ assertOwner(owner);
+ const worker = workers.find(
+ (w) =>
+ w.teamId === teamId &&
+ w.leadSessionId === request.leadSessionId &&
+ w.executionDevice?.deviceId === caller.controllerDeviceId &&
+ w.executionDevice?.remoteSessionId === request.sessionId,
+ );
+ if (
+ !worker ||
+ worker.session.id !== worker.sessionId ||
+ request.args.worker_id !== worker.id
+ ) {
+ throwIpcError('PERMISSION_DENIED', 'remote worker does not belong to this active team');
+ }
+ // The model cannot supply a local context or select an arbitrary Lead. Reuse local
+ // schemas, sender labels, dispatch/queue semantics and manual-report settlement.
+ const settle =
+ request.tool === 'send_to_lead'
+ ? deps.captureReportSettlement?.(worker.sessionId, request.reportedInputClientIds ?? [])
+ : undefined;
+ if ((await deps.activeTeamId(request.leadSessionId)) !== teamId) {
+ throwIpcError('PERMISSION_DENIED', 'worker team has ended');
+ }
+ assertOwner(owner);
+ const result = await deps.invokeTool(
+ {
+ sessionId: worker.sessionId,
+ agentKind: worker.session.agentKind,
+ workingDir: '',
+ mcpCallerAttested: true,
+ mcpCallerKind: 'root',
+ vendorOptions: {
+ orcaRole: 'worker',
+ orcaWorkerId: worker.id,
+ orcaWorkerSessionId: worker.sessionId,
+ orcaLeadSessionId: request.leadSessionId,
+ },
+ },
+ request.tool,
+ request.args,
+ );
+ assertOwner(owner);
+ if (!result.isError) await settle?.();
+ return result;
+ },
+ };
+}
diff --git a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerHost.ts b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerHost.ts
index be7ca311c7..bb6b840cfa 100644
--- a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerHost.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerHost.ts
@@ -113,7 +113,7 @@ export function createOrcaRemoteWorkerHost(deps: OrcaRemoteWorkerHostDeps) {
return {
caps(): OrcaRemoteWorkerCaps {
requireCaller(deps);
- return { version: ORCA_REMOTE_WORKER_VERSION };
+ return { version: ORCA_REMOTE_WORKER_VERSION, workerBridge: true };
},
async open(raw: unknown): Promise<OrcaRemoteWorkerOpenResult> {
diff --git a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerRuntime.ts b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerRuntime.ts
index 644f3f0d9d..095d26e374 100644
--- a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerRuntime.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerRuntime.ts
@@ -63,6 +63,7 @@ export interface OrcaRemoteWorkerRuntimeDeps {
workerId: string,
pending: OrcaRemotePendingReport | null,
messageId?: string,
+ markWorkerDone?: boolean,
): Promise<void>;
isOwnerCurrent?(): boolean;
onTurnStarted(proxySessionId: string): Promise<void>;
@@ -108,6 +109,7 @@ interface AwaitingReport {
clientIds: string[];
baselineMessageId: string | null;
startedNotified: boolean;
+ turnStartPromise?: Promise<void>;
missingReplyPolls: number;
terminalHandler: ((turn: RemoteWorkerTurnEnd) => Promise<boolean>) | null;
/** 宿主 accepted 回调失败时恢复上一代原对象;确认成功后释放。 */
@@ -201,8 +203,9 @@ function createOptsFromRow(row: RemoteSessionRow): AgentInputCreateOpts {
};
}
-/** 远端没有 Orca Worker 桥:只带来源标签,不附 worker_id 工具提示。 */
+/** Keep the real Lead-assigned identity in the model-facing message, as for local Workers. */
export function buildRemoteWorkerQueuedMessage(params: {
+ workerId?: string;
clientId: string;
rawContent: string;
createOpts: AgentInputCreateOpts;
@@ -212,7 +215,8 @@ export function buildRemoteWorkerQueuedMessage(params: {
return {
clientId: params.clientId,
durableDelivery: true,
- text: formatAgentMessage('lead', params.rawContent),
+ text: formatAgentMessage('lead', params.rawContent, params.workerId)
+ + (params.workerId ? '\n(Cross-device Worker: bridge availability depends on both devices; final replies are automatically reported to the Lead.)' : ''),
persistedContent,
model: params.createOpts.model,
effort: params.createOpts.effort ?? '',
@@ -432,15 +436,17 @@ export function createOrcaRemoteWorkerRuntime(deps: OrcaRemoteWorkerRuntimeDeps)
async function checkAwaiting(state: WorkerState, running: boolean): Promise<void> {
const awaiting = state.awaiting;
if (!awaiting?.terminalHandler) return;
+ const clientIds = awaiting.clientIds;
if (running) {
if (!awaiting.startedNotified) {
awaiting.startedNotified = true;
- await deps.onTurnStarted(state.ref.proxySessionId);
+ awaiting.turnStartPromise = deps.onTurnStarted(state.ref.proxySessionId);
+ await awaiting.turnStartPromise;
}
return;
}
- const states = await deliveryStates(state.ref, awaiting.clientIds);
- if (!current(state) || state.awaiting !== awaiting) return;
+ const states = await deliveryStates(state.ref, clientIds);
+ if (!current(state) || state.awaiting !== awaiting || awaiting.clientIds !== clientIds) return;
// 仍在运行设备的队列里(排在用户插话之后等),继续等。
if (states.some((value) => value === 'pending')) return;
if (states.every((value) => value === 'removed')) {
@@ -466,11 +472,11 @@ export function createOrcaRemoteWorkerRuntime(deps: OrcaRemoteWorkerRuntimeDeps)
state.ref,
// 崩溃可能发生在预写身份之后、enqueue 之前,也可能只是投递回执过期。
// unknown 同样查历史,查不到时按有限轮数报告未确认执行,绝不盲目重发。
- awaiting.clientIds.filter((_, index) => states[index] !== 'removed'),
+ clientIds.filter((_, index) => states[index] !== 'removed'),
scan,
);
// 历史读取期间又派入新任务时保留新的 awaiting,下一轮按完整输入集合复核。
- if (!current(state) || state.awaiting !== awaiting) return;
+ if (!current(state) || state.awaiting !== awaiting || awaiting.clientIds !== clientIds) return;
// 扫描预算不足不代表没有回复,保留当前游标与候选,下一轮继续。
if (!last.complete) return;
awaiting.historyScan = null;
@@ -663,6 +669,7 @@ export function createOrcaRemoteWorkerRuntime(deps: OrcaRemoteWorkerRuntimeDeps)
if (!current(state)) throw new Error('remote worker owner changed');
const createOpts = createOptsFromRow(row);
const item = buildRemoteWorkerQueuedMessage({
+ workerId: ref.workerId,
clientId: params.clientId,
rawContent: params.rawContent,
createOpts,
@@ -775,6 +782,59 @@ export function createOrcaRemoteWorkerRuntime(deps: OrcaRemoteWorkerRuntimeDeps)
awaiting.previous = null;
},
+ /** Retire only inputs attested by the execution host, never the whole queued group. */
+ captureReportSettlement(
+ proxySessionId: string, reportedInputClientIds: readonly string[] = [],
+ settleTeam?: (commit: (markWorkerDone: boolean) => Promise<boolean>) => Promise<void>,
+ ): () => Promise<boolean> {
+ const state = workers.get(proxySessionId);
+ const awaiting = state?.awaiting;
+ const reported = new Set(reportedInputClientIds.filter(id => awaiting?.clientIds.includes(id)));
+ return async () => {
+ // Old peers without input evidence keep the automatic-report fallback.
+ if (!state || !awaiting || !reported.size || !current(state)) return false;
+ awaiting.startedNotified = true;
+ await awaiting.turnStartPromise;
+ const write = state.persistence.catch(() => undefined).then(async () => {
+ const pending = state.awaiting;
+ if (!current(state) || !pending || !pending.clientIds.some(id => reported.has(id))) return false;
+ const retire = async (markWorkerDone: boolean): Promise<boolean> => {
+ // Re-read after the Team lookup/transition wait, which can prepare a new B.
+ const latest = state.awaiting;
+ if (!current(state) || !latest || !latest.clientIds.some(id => reported.has(id))) return false;
+ const remaining = latest.clientIds.filter(id => !reported.has(id));
+ const next = remaining.length
+ ? { clientIds: remaining, baselineMessageId: latest.baselineMessageId } : null;
+ if (markWorkerDone) await deps.saveReport(state.ref.workerId, next, undefined, true);
+ else await deps.saveReport(state.ref.workerId, next);
+ if (!current(state)) return false;
+ // Prune rollback chains too, so a failed B cannot resurrect reported A.
+ const prune = (node: AwaitingReport | null): AwaitingReport | null => {
+ if (!node) return null;
+ node.previous = prune(node.previous);
+ const ids = node.clientIds.filter(id => !reported.has(id));
+ if (ids.length === 0) return null;
+ if (ids.length !== node.clientIds.length) {
+ node.clientIds = ids;
+ node.historyScan = null;
+ node.missingReplyPolls = 0;
+ }
+ return node;
+ };
+ state.awaiting = prune(state.awaiting);
+ return true;
+ };
+ if (pending.clientIds.every(id => reported.has(id)) && settleTeam) await settleTeam(retire);
+ else await retire(false);
+ return current(state) && state.awaiting === null;
+ });
+ // The caller observes the failure; the serialization tail must not create
+ // a second, unobserved rejection while waiting for the next poll.
+ state.persistence = write.then(() => undefined, () => undefined);
+ return write;
+ };
+ },
+
/** accepted 回调的原有异常继续上抛;这里只恢复 runtime 对应的旧回报代次。 */
async rejectDispatchAcceptance(proxySessionId: string, clientId: string): Promise<void> {
const state = workers.get(proxySessionId);
diff --git a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkers.ts b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkers.ts
index 73da0a1be0..1b700cbb88 100644
--- a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkers.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkers.ts
@@ -314,6 +314,16 @@ export function createOrcaRemoteWorkers(deps: OrcaRemoteWorkersDeps) {
return {
runtime,
+ captureReportSettlement(sessionId: string, reportedInputClientIds: readonly string[]): () => Promise<void> {
+ const service = deps.getTeamService();
+ const capture = service?.captureWorkerTerminalTurn(sessionId);
+ const settle = service && capture
+ ? runtime.captureReportSettlement(sessionId, reportedInputClientIds, commit => service.settleReportedWorker(capture, commit))
+ : undefined;
+ return async () => {
+ await settle?.();
+ };
+ },
/**
* 按当前账号恢复待回报与结束通知;同一数据库 owner 重入不清除现有派活。
@@ -666,14 +676,29 @@ export function createOrcaRemoteWorkers(deps: OrcaRemoteWorkersDeps) {
if (!(await isRemoteWorker(params.targetSessionId))) return base.dispatchWorkerMessage(params);
// 与本机派发复用同一会话锁,保持 enqueue 与 accepted/commit 身份的顺序一致。
return base.withSessionSendLock(params.targetSessionId, async () => {
+ const dispatchOwner = ownerToken();
const clientId = createId();
const meta = { source: params.dispatchMeta.source, context: params.dispatchMeta.context };
let acceptedDidRun = false;
let rollbackDidRun = false;
const rollbackAccepted = async () => {
- if (!acceptedDidRun || rollbackDidRun) return;
- rollbackDidRun = true;
- await runAcceptedRollback(params.onAcceptedRollback, params.targetSessionId, clientId, deps.log);
+ if (acceptedDidRun && !rollbackDidRun) {
+ rollbackDidRun = true;
+ await runAcceptedRollback(params.onAcceptedRollback, params.targetSessionId, clientId, deps.log);
+ }
+ // A may have reported while B was prepared. Runtime pruned A from B's
+ // rollback chain; after Team rollback, reconcile its restored A as well.
+ // The send lock excludes a newer dispatch, and the capture protects the
+ // Team identity across its async status write. Local Workers never enter here.
+ if (dispatchOwner !== ownerToken() || !ownerCurrent()
+ || !runtime.isRemote(params.targetSessionId)
+ || runtime.hasPendingReport(params.targetSessionId)) return;
+ const service = deps.getTeamService();
+ if (service) await service.settleReportedWorker(service.captureWorkerTerminalTurn(params.targetSessionId))
+ .catch((error) => deps.log.warn('orca remote worker: report reconciliation failed', {
+ workerId: params.workerId,
+ err: error instanceof Error ? error.message : String(error),
+ }));
};
try {
const result = await runtime.dispatch({
diff --git a/apps/desktop/src/main/maker-ipc/orcaSessionStartOptions.ts b/apps/desktop/src/main/maker-ipc/orcaSessionStartOptions.ts
index 9834b34511..e1d05f37ba 100644
--- a/apps/desktop/src/main/maker-ipc/orcaSessionStartOptions.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaSessionStartOptions.ts
@@ -4,7 +4,8 @@ import {
renderOrcaWorkerSystemPrompt,
} from '@cindy/orca-workflow';
-import { getSessionOrcaRole, getWorkerLink } from '../localDb/orcaTeamStore.js';
+import { getSessionOrcaRole, getWorkerLink, getRemoteOrcaSession } from '../localDb/orcaTeamStore.js';
+import type { OrcaRemoteLead } from '../../shared/orcaRemoteWorker.js';
import { createLogger } from '../logger.js';
import type { MakerSessionCreateOpts } from './sessionRequest.js';
import {
@@ -23,6 +24,7 @@ interface OrcaWorkerLink {
export interface OrcaSessionStartOptionsDeps {
getSessionRole(sessionId: string): Promise<OrcaRole | null>;
getWorkerLink(workerSessionId: string): Promise<OrcaWorkerLink | null>;
+ getRemoteLead?(sessionId: string): Promise<OrcaRemoteLead | null>;
warn(message: string, meta: Record<string, unknown>): void;
}
@@ -31,6 +33,7 @@ const log = createLogger('maker-ipc:orca-session-start');
const defaultDeps: OrcaSessionStartOptionsDeps = {
getSessionRole: getSessionOrcaRole,
getWorkerLink: (workerSessionId) => getWorkerLink({ workerSessionId }),
+ getRemoteLead: async sessionId => (await getRemoteOrcaSession(sessionId))?.orcaRemoteLead ?? null,
warn: (message, meta) => log.warn(message, meta),
};
@@ -91,6 +94,12 @@ export async function synthesizeOrcaVendorOptionsFromDb(
return true;
}
if (!hasExplicitRole) {
+ const lead = await deps.getRemoteLead?.(sessionId);
+ if (lead && lead.releasedAt === undefined) {
+ // Enable the bridge for Claude too, without inventing a local Worker/team role.
+ o.vendorOptions = { ...(o.vendorOptions ?? {}), orcaRemoteWorker: true, orcaRemoteLead: lead };
+ return true;
+ }
knownNonOrcaSessionIds.add(sessionId);
}
return false;
diff --git a/apps/desktop/src/main/maker-ipc/orcaTeamService.ts b/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
index 9b83ac9b19..302dec59b0 100644
--- a/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaTeamService.ts
@@ -418,6 +418,10 @@ export interface OrcaTeamService {
}): Promise<MoveWorkerQueuedMessageResult>;
captureWorkerText(sessionId: string, text: string, opts?: { isFinal?: boolean }): void;
clearAutoBridgeState(sessionId: string): void;
+ settleReportedWorker(
+ capture: WorkerTerminalTurnCapture,
+ commit?: (markWorkerDone: boolean) => Promise<boolean>,
+ ): Promise<void>;
/** True while an accepted worker task still owes this Lead its report. */
hasPendingWorkerReports(leadSessionId: string): boolean;
restoreWorkerPendingReport(sessionId: string, input: { workerId: string; leadSessionId: string }): void;
@@ -644,7 +648,7 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
const header =
turn.status === 'error'
? '[Auto-bridged: worker 异常终止]'
- : '[Auto-bridged: worker 完成但未调 send_to_lead]';
+ : '[Auto-bridged: worker 已完成,系统自动回传结果]';
const bridgeText = `${header}\n\n${finalText}`;
try {
const result = await deps.sendAutoBridgeToLead(
@@ -1749,6 +1753,24 @@ export function createOrcaTeamService(deps: OrcaTeamServiceDeps): OrcaTeamServic
clearAutoBridgeState(sessionId) {
clearRuntimeState(sessionId);
},
+ async settleReportedWorker(capture, commit) {
+ const link = await deps.getWorkerLinkBySessionId(capture.sessionId);
+ if (!link) return;
+ await withWorkerTransition(link.workerId, async () => {
+ const ownsReport = !!capture.autoBridgeIdentity
+ && autoBridge.get(capture.sessionId) === capture.autoBridgeIdentity;
+ if (commit) {
+ // The remote commit persists pending inputs and status in one SQL update.
+ // All fallible reads happen first; clear memory only after that commit succeeds.
+ if (!await commit(ownsReport) || !ownsReport) return;
+ } else {
+ if (!ownsReport) return;
+ await deps.updateWorkerStatus(link.workerId, 'done');
+ }
+ clearRuntimeState(capture.sessionId);
+ deps.broadcastOrcaWorkerChanged(link.leadSessionId);
+ });
+ },
hasPendingWorkerReports,
restoreWorkerPendingReport(sessionId, input) {
if (autoBridge.has(sessionId)) return;
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index f18ba83698..f1c56807c8 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -652,6 +652,7 @@ import {
ensureCodexMcpBridgeStartedForRemote,
finalizeCodexAfterAuthModeChange,
getMaker,
+ handleRemoteWorkerBridge,
listCodexGatewayHostKeys,
refreshCodexGatewayHost,
setCodexGatewayKeyRefreshHook,
@@ -1014,6 +1015,7 @@ import { createOrcaRemoteWorkers, invokeDeviceValue, isExecutionDeviceCandidate,
import { getReceivedShares, providerShareAgentDeviceId } from '../device-link/providerShareGuest.js';
import {
ORCA_EXECUTION_DEVICES_CHANNEL,
+ ORCA_REMOTE_WORKER_BRIDGE_CHANNEL,
COMPANION_CLOUD_CAPS_CHANNEL,
COMPANION_CLOUD_FLUSH_CHANNEL,
COMPANION_CLOUD_HAND_OVER_CHANNEL,
@@ -2821,6 +2823,13 @@ export function stopOrcaRemoteWorkersForOwnerBoundary(): void {
orcaRemoteWorkersForHost?.stop();
}
+export function captureRemoteWorkerReportSettlement(
+ sessionId: string, reportedInputClientIds: readonly string[],
+): () => Promise<void> {
+ return orcaRemoteWorkersForHost?.captureReportSettlement(sessionId, reportedInputClientIds)
+ ?? (async () => {});
+}
+
function markWorkerManualInterruptIfKnown(
sessionId: string,
reason: 'input_stop' | 'abort_session',
@@ -4462,6 +4471,11 @@ export function isSessionInTurn(sessionId: string): boolean {
return sessionTurnActivityTracker.isSessionInTurn(sessionId);
}
+/** Runtime-only attribution; queued or rejected steering cannot take ownership. */
+export function getSessionActiveInputClientIds(sessionId: string): string[] {
+ return agentInputCoordinatorHolder?.getActiveInputClientIds(sessionId) ?? [];
+}
+
/** Runtime-only attribution; queued or rejected steering cannot take ownership. */
export function getSessionInputProvenance(sessionId: string) {
const input = agentInputCoordinatorHolder?.getAcceptedInputProvenance(sessionId) ?? null;
@@ -9405,6 +9419,13 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
now: Date.now,
}));
+ makerSessionRegistry.handle(ORCA_REMOTE_WORKER_BRIDGE_CHANNEL, (_event: unknown, raw: unknown) => {
+ const ctx = getDeviceLinkInvokeContext();
+ return handleRemoteWorkerBridge(raw, ctx ? {
+ controllerDeviceId: ctx.controllerDeviceId, sharedTask: ctx.sharedTask,
+ } : null);
+ });
+
const readSourceReviewCards = async (sourceSessionId: string) =>
getDbClient()
.drizzle.select({
diff --git a/docs/dev-rules/orca-team-architecture.md b/docs/dev-rules/orca-team-architecture.md
index 5e0e2f4cef..827200fffb 100644
--- a/docs/dev-rules/orca-team-architecture.md
+++ b/docs/dev-rules/orca-team-architecture.md
@@ -437,7 +437,7 @@ Worker turn 被 vendor 报终止型 error,但 interrupted-turn auto-resume 仍
Lead 派完活结束本轮时,团队仍在干活,这一轮不是完成:灵动岛保持 Lead 为运行中(不出完成卡片、不响完成音、不记未读),Work Louder 键盘、侧栏卡片与远程会话列表读同一份活动快照,因此一起保持运行中;renderer 不发完成通知(桌面/手机/飞书)、不亮完成角标。Worker 回报送达后 Lead 被唤起,那一轮的 done 才是团队完成。判据只有一份,在 Main:以「仍有 accepted 派活欠 Lead 回报」(auto-bridge pending)为准,最后一份回报送达或被丢弃(手动停止、归档等)时,若 Lead 空闲则补发被推迟的完成;renderer 不自行推算 Worker 状态,完成去抖落地时读灵动岛活动快照,Main 仍把该会话保持为 `running` 就不算完成(暂停的输入队列同样会让灵动岛保持运行中,但保留原有完成提醒,故排除)。Worker 自身仍不进灵动岛;Worker 的完成不单独通知,出错与需要确认以「Lead 标题 · Worker 标题」单独通知(桌面 / 飞书 / 手机推送,走同一个 `sendSessionEventNotification`;找不到 Lead 时退回 Worker 标题;只覆盖本机 Worker),点击按 Worker id 经 `resolveSessionRoute` 落到 Lead 并打开该 Worker。Worker 出错后 Lead 被唤起处理完还会有一条 Lead 完成通知,两条都保留。已知空档(用户接受):开启灵动岛时渲染端不弹系统横幅,而 Worker 不进灵动岛,这段时间 Worker 的出错 / 确认收不到桌面弹窗,飞书 / 手机推送不受影响。实现指针:`CCAgentSidebarUpper.tsx` 的 `fireSessionNotification`,`orcaLeadWorkerAttention.ts` 的 `shouldNotifyOrcaWorkerEvent` / `formatOrcaWorkerNotificationTitle` / `findOrcaLeadSessionIdForWorker`。已知边界(刻意不处理,保持简单):派给正忙 Worker、尚在其队列里未被接收的任务还没有待回报记录(Worker 正忙通常意味着已有同一 Lead 的待回报记录);静默完成(如静默的自动运行)不走推迟,Lead 活动会直接变为完成。实现指针:`orcaTeamService.ts` 的 `hasPendingWorkerReports` / `deletePendingReport` / `onLeadWorkerReportsSettled`,`register.ts` 的 `setCompletionDeferResolver` 与 `onLeadWorkerReportsSettled` wiring,`agent-island/service.ts` 的 `notifyQueueEmptied`,renderer `state/agentIslandActivity.ts` 的 `isSessionCompletionHeldByAgentIsland` 与 `useSessionRunningStatus.ts` 的 done debounce。
10. **远端 Worker 只在运行设备上跑(状态:不变量)**
- Worker 可以放到同账号另一台电脑(运行设备)上运行:真实任务在那台,本机只有一条不跑 Agent、`working_dir` 为空的代理任务行,`orca_workers.execution_device_id` / `remote_session_id` 记录位置。代理行承接计槽、状态机、auto-bridge 与归档,任何路径都不得在本机为它起 Agent(`bootstrapSession` 对远端 Worker 直接拒绝)、不得把它复制到其他电脑;派活、停止与存活查询经 `orcaRemoteWorkers.ts` 的 `wrapTeamDeps` 分流到运行设备,其余依赖原样透传,不另造状态机。回报靠轮询:派出的消息已进入对话(投递回执 accepted)且设备不在跑时,分页读取 user / assistant 历史,按派活 user 的 clientId 定位对应的最后一条 assistant 回复并按消息 id 去重;后续用户插话的回复和异常状态不得归给此前派活,历史读取期间的新派活不得被旧回报清除。每轮最多扫描 2000 行,预算不足时保留游标下一轮续读,不误判缺少回复;宿主 onAccepted / onAcceptedCommit 完成后才冻结回报身份并允许轮询收尾,accepted 回调失败恢复上一代等待状态,保存旧结果期间不得消费新派活身份或写入其捕获文本。同一远端 Worker 的 enqueue、accepted / commit 和身份确认复用现成 session 发送锁串行执行,避免并发回调与投递顺序错位。用户在运行设备上直接发的消息算插话,不触发回报。设备不可达只是运行期投影(`executionDevice.reachable`),不扩展 `OrcaWorkerStatus`;派活时不可达直接失败,不回退到本机。首版远端 Worker 没有 `send_to_lead` 桥,也不支持 steer / 队列编辑。界面:创建弹窗的「运行设备」只在本机 Lead 上出现(`CreateWorkerPopover` 的 `executionDevicesEnabled`),复用标准下拉列表,以有界滚动和键盘按名称定位应对多设备;选了其他电脑后,工作目录提供「对话 / 指定目录」,「对话」不传 `workingDir`、在运行设备创建不绑定项目的任务,「指定目录」只使用那台电脑上的绝对路径。手机版的新任务「开启协同」与 Lead「创建 Worker」共用设备下拉列表和两种目录模式;设备列表从 Lead 所在电脑读取,Agent、模型和供应商目录从所选运行设备读取。协同面板对远端 Worker 展示运行设备上的真实任务(`RemoteWorkerSessionPane`,先登记归属再读写)。实现指针:`orcaRemoteWorkerRuntime.ts`、`orcaRemoteWorkers.ts`、`orcaWorkerCreationService.ts` 的 `createRemoteWorkerInTeam`、运行设备侧 `orcaRemoteWorkerHost.ts`;协议见 `protocol-compatibility.md`「协同远端 Worker」。
+ Worker 可以放到同账号另一台电脑(运行设备)上运行:真实任务在那台,本机只有一条不跑 Agent、`working_dir` 为空的代理任务行,`orca_workers.execution_device_id` / `remote_session_id` 记录位置。代理行承接计槽、状态机、auto-bridge 与归档,任何路径都不得在本机为它起 Agent(`bootstrapSession` 对远端 Worker 直接拒绝)、不得把它复制到其他电脑;派活、停止与存活查询经 `orcaRemoteWorkers.ts` 的 `wrapTeamDeps` 分流到运行设备,其余依赖原样透传,不另造状态机。回报靠轮询:派出的消息已进入对话(投递回执 accepted)且设备不在跑时,分页读取 user / assistant 历史,按派活 user 的 clientId 定位对应的最后一条 assistant 回复并按消息 id 去重;后续用户插话的回复和异常状态不得归给此前派活,历史读取期间的新派活不得被旧回报清除。每轮最多扫描 2000 行,预算不足时保留游标下一轮续读,不误判缺少回复;宿主 onAccepted / onAcceptedCommit 完成后才冻结回报身份并允许轮询收尾,accepted 回调失败恢复上一代等待状态,保存旧结果期间不得消费新派活身份或写入其捕获文本。同一远端 Worker 的 enqueue、accepted / commit 和身份确认复用现成 session 发送锁串行执行,避免并发回调与投递顺序错位。用户在运行设备上直接发的消息算插话,不触发回报。设备不可达只是运行期投影(`executionDevice.reachable`),不扩展 `OrcaWorkerStatus`;派活时不可达直接失败,不回退到本机。远端 Worker 通过运行设备转发四个既有 Worker 桥接工具,Lead 按同账号来源设备、真实任务、Worker 与 active team 核对归属;旧端没有该通道时保留自动回报。远端队列编辑仍不支持;send_to_lead 的 steer 由 Lead 所在电脑沿本机原有守卫判定。界面:创建弹窗的「运行设备」只在本机 Lead 上出现(`CreateWorkerPopover` 的 `executionDevicesEnabled`),复用标准下拉列表,以有界滚动和键盘按名称定位应对多设备;选了其他电脑后,工作目录提供「对话 / 指定目录」,「对话」不传 `workingDir`、在运行设备创建不绑定项目的任务,「指定目录」只使用那台电脑上的绝对路径。手机版的新任务「开启协同」与 Lead「创建 Worker」共用设备下拉列表和两种目录模式;设备列表从 Lead 所在电脑读取,Agent、模型和供应商目录从所选运行设备读取。协同面板对远端 Worker 展示运行设备上的真实任务(`RemoteWorkerSessionPane`,先登记归属再读写)。实现指针:`orcaRemoteWorkerRuntime.ts`、`orcaRemoteWorkers.ts`、`orcaWorkerCreationService.ts` 的 `createRemoteWorkerInTeam`、运行设备侧 `orcaRemoteWorkerHost.ts`;协议见 `protocol-compatibility.md`「协同远端 Worker」。
11. **Worker 的 Agent 位置:远程供应商与本机供应商一视同仁(状态:不变量,2026-10-10 用户裁决)**
与上一条「运行设备」不同,这里任务、目录、命令与文件都留在 Lead 所在电脑,只有 Worker 的 Agent 在另一台同账号电脑或分享来的供应商上运行(与普通任务的远程 Agent 同一机制,`sessions.agent_device_id`)。每个 Worker 可以单独选位置:`OrcaWorkerCreateParams.agentDeviceId` 不传 = 跟 Lead(旧调用方、旧控制端与 MCP 省略时都走这里),`null` = 任务所在电脑,string = 那台电脑或 `share:<id>`;等于本机设备 id 时按 `null`。模型与来源按 Worker 自己的位置读目录(那台只列允许被远程调用的供应商),只有与 Lead 同一位置时才沿用 Lead 的来源(来源 id 在不同电脑上不是一回事);Agent 在另一台时不按本机的 Cindy AI key 判预算模型。那台读不到目录在占槽与启动前失败(`REMOTE_AGENT_DEVICE_UNREACHABLE` / `REMOTE_AGENT_SHARE_*`),不回退到本机。SSH Lead 与运行设备 Worker 不能再指定另一台(`INVALID_PARAMS`),插件任务只能跟 Lead 或留在任务所在电脑。入口一处一套:桌面「创建 Worker / 开启协同」弹窗与新建任务用同一个模型面板,任务所在电脑的供应商之后列其他电脑与分享(`useWorkerAgentDevices`),选中哪一行 Worker 的 Agent 就在哪运行,默认选中 Lead 的位置;选了远程就不提供运行设备,选了运行设备回到任务所在电脑。桌面手动选择模型并提交创建后,在 `workerCreationPrefs.modelSelectionByHost` 按账号与任务所在电脑保存完整选择(Agent、模型、来源、Agent 所在电脑、推理强度与 Fast),下次打开优先恢复,不被 Lead 后续换模型或换位置覆盖;未手动选择时仍跟随 Lead 的位置,取消未提交的编辑不保存。旧版逐 Agent 记忆继续可读,不推测它原先属于哪台电脑;SSH 与运行设备的临时选择不写入这份位置记忆。远程选择不覆盖旧版逐 Agent 的本机目录记忆,模型行的档位预设仍使用 `agentDeviceModelMemory`。回归见 `CreateWorkerPopover.test.tsx` 的重新打开与任务所在电脑隔离用例。手机同样支持选择 Agent 位置(`useOrcaWorkerForm` 的 `agentDeviceId`,模型面板 `remote` 与新建任务同一份 `useRemoteAgentCatalogs`),通过 `orcaWorkerPrefs.modelSelectionByHost` 在手机本地按账号与任务所在电脑保存同样的完整选择,创建成功或确认新任务协同草稿后写回;异步读取不能覆盖已编辑的表单。恢复的来源或模型不可用时保留原路线,由界面阻止或宿主明确拒绝,不静默换到别处;旧端不能兑现位置时同样拒绝。回归见 `useOrcaWorkerForm.test.tsx` 与 `orcaTeam.test.ts`。被控电脑声明 `supportsOrcaWorkerAgentDevice` 时新建任务的远程供应商与协同不再互斥。Lead 的 `list_available_models` 可按 `agent_device_id` 列那里的模型并给出 `locations`,`create_worker` / `create_workers` 用同一个 `agent_device_id`。Worker 列表投影 `session.agentDeviceId`,桌面 Worker 头像叠与远程任务同款的单波纹 + 点;手机 Worker 行保持原来的状态圆点,不加远程标识(2026-10-11 用户要求维持原样)。已开始的 Lead 与 Worker 可以由用户在模型列表里换 Agent 位置(本机供应商、其他电脑、分享来的供应商一起列出),与普通任务同一套换电脑事务:选择先登记为意图,下一次发送边界全量交接后在新位置重建,协同身份不变(2026-10-16 用户裁决:任务都在本机,只换供应商所在电脑,不应排除)。运行设备 Worker 与 SSH 任务仍不开放;被控电脑上的协同任务暂不在控制端开放(旧版被控端会拒绝),手机端同样暂未开放。供应商组为任务换电脑见第 12 条。实现指针:`orcaWorkerCreationService.ts` 的 `resolveWorkerAgentDeviceId` / `agentDeviceCatalogFailure`,`register.ts` 的 `listWorkerAgentLocations` 与 `listAvailableModels`,renderer `CreateWorkerPopover.tsx`、`hooks/useWorkerAgentDevices.ts`;协议见 `protocol-compatibility.md`「协同 Worker 的 Agent 位置」。
@@ -457,6 +457,30 @@ Worker turn 被 vendor 报终止型 error,但 interrupted-turn auto-resume 仍
### 测试与回归清单
+跨设备 Worker 的主动回报(2026-10-21):运行设备从持久化 `orcaRemoteLead` 恢复桥接标记,
+仍不写本机 `orcaRole`、不创建本机团队;Claude Code、Codex、Pi 共用既有四个 Worker 工具。
+派发说明携带 Lead 分配的 `worker_id`;当前任务查询和历史任务列表投影来源标记,
+`parentSessionId` 继续只表示 Fork。运行设备在转发前核验根 Agent 身份,Lead 核验来源设备、
+真实任务、Worker 与当前 active team 后执行同一套本地桥接 handler,不接受任意工具或目标任务。
+运行宿主在任何异步查询前同步捕获协调器当前已接受输入的来源与本轮已消费的输入 ID。
+主动回报只允许当前输入来自 Orca 派活且具有已消费输入;用户在运行设备直接发送、已接受的
+人工插话接管或没有活动输入时返回 `NOT_LEAD_ASSIGNED_TURN`,不转发或结清。不能仅凭持久
+Worker 归属或累计回复 ID 判断当前输入仍属 Lead;只读 Lead 工具与本机 Worker 路径保持不变。
+已消费输入 ID 经可选 `reportedInputClientIds` 传给 Lead,
+不向模型工具增加参数。主动回报成功只剔除这些输入的运行期和持久等待记录;即使 B 已经
+排队,A 的回报也不能清掉 B 或提前把 Worker 标为 done。新派活的回滚链同步剔除已回报输入,
+避免失败回滚恢复旧等待记录。全部结清后才更新 Worker 终态;旧端缺少输入标识时保留自动回报。
+完整主动回报先完成 TeamService 的查询与身份复核,再在同一条数据库 UPDATE 中提交剩余
+等待记录与 Worker 终态,成功后才清除对应 Team 内存身份;数据库提交失败不清任何一层
+等待记录,由既有轮询继续收口,重启也不会把已提交的退役记录重新当成未回报。等待 Team
+复核期间出现新派活时重新读取剩余输入,不能按等待前的快照清掉新任务。
+远端派发失败在同一发送锁内完成两层回滚后复核;运行期已无待报输入时,也结清 TeamService
+刚恢复的旧等待身份,避免 Lead 永久等待已回报的 A;仍有待报输入时不结清。
+自动回报只说明系统转交结果,不能推断 Worker 漏调工具;本机 Worker 的主动回报规则、
+原工具定义和权限保持不变。旧端或断连仍保留自动回报,不盲目重发结果不明的写操作。
+实现见 `orcaRemoteWorkerBridge.ts`、`orcaRemoteWorkerRuntime.ts`,生产入口回归见
+`orcaRemoteWorkerBridge.test.ts` 与既有本机 `orca-bridge-mcp.test.ts`。
+
远端回报身份在 enqueue 前保存于 `orca_workers.pending_remote_report`,恢复时重建 TeamService
待回报身份;同一数据库 owner 的重复启动不清空派活。只有 Lead 接受回报或该捕获身份已被
结清/替换后,才原子更新去重游标与对应等待记录;拒收或落盘失败继续重试,不清掉新派活。
@@ -464,7 +488,8 @@ Worker turn 被 vendor 报终止型 error,但 interrupted-turn auto-resume 仍
再次核对 owner 与派发身份,才向运行设备入队。复核拒绝时不发送,恢复上一代等待记录并
按既有 accepted 回滚恢复 Lead 状态;回滚次生错误记日志,不覆盖原始拒绝异常。
明确投递失败也回滚已暂存的 accepted 状态;投递成功或结果未知后才 commit 并冻结身份。
-这不改变 queued 派活尚未消费就提交回报身份的已知缺口,也不提供跨设备事务或撤销已执行输入。
+派活 accepted 仍表示远端持久入队,不表示输入已消费;主动回报按运行宿主已消费的输入结清,
+不提供跨设备事务或撤销已执行输入。
结束协同不依赖缓存 running:先确认停止并保存 `remote_stop_confirmed_at`,再解除协同标记;
清理单飞且读取最新阶段,后续只补未完成阶段。归档提交成功后才取消远端路由。
创建回执丢失时使用同一 sessionId 核对,未确认身份保存在 `orca_remote_opens`;孤儿清理与
@@ -537,9 +562,14 @@ Codex thread start / resume 成功后必须注册 `threadId -> session context`
`switch_focus` 是纯 UI focus 操作,走单独的纯函数 `findFocusTargetWorker`(`orcaTeamService.ts`):**worker_id / session_id 优先精确匹配,label 兜底**——比 mutation 工具多接受人类友好的 label(人/agent 常按 label 切画面),故意不复用 `resolveWorkerRef`(mutation 工具不该认 label)。register.ts 的 IPC handler 与 MCP holder 两条 switch_focus 路径共用这一个 helper,不要再各自 inline find。
-#### 4. `orca_worker_bridge` 对 Codex 全局可见(状态:follow-up)
+#### 4. `orca_worker_bridge` 对 Codex/Pi 共享桥接全局可见(状态:follow-up)
-`orca_worker_bridge` 对 Codex session 的可见性必须由 handler 做角色校验兜底。可见性短期收不掉时,handler 必须用 `resolveLiziMcpSessionContext` 检查真实 `orcaRole === 'worker'`,普通 session / Lead 调用应返回明确错误,而不是 fallback 到空 ctx。
+Claude 的 per-session MCP 仅在 `orcaRole === 'worker'` 或 `orcaRemoteWorker === true`
+时挂载 Worker 桥接;普通任务与 Lead 也有 `getSessionContext`,不能把访问器存在当作 Worker
+身份证据。Codex/Pi 共享 HTTP bridge 在工厂阶段没有真实任务身份,仍需注册全局 server;
+工具调用时必须从 `getSessionContext` 读取宿主绑定的真实身份,按本地 Worker link 或远端
+Worker 来源校验,普通任务 / Lead 调用返回明确错误,不猜测缺失的 ctx。实现与挂载矩阵
+回归见 `packages/orca-workflow/src/orca-bridge-mcp.ts` 及其 `orca-bridge-mcp.test.ts`。
#### 5. Lead prompt 的诊断工具名(状态:已解决)
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 666f9f620f..e4664833c7 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -1500,6 +1500,25 @@ Codex 原生图片恢复(#6412)在既有 `maker:remote-agent:v1` 上追加
## 协同远端 Worker:Worker 在另一台电脑运行
+主动回报可选追加 `maker:orca:remote-worker:bridge`,仅同账号 allowlist;不进入共享任务、
+供应商分享清单。运行设备从本机持久来源标记选定 Lead 电脑,传真实任务 ID、Lead ID、
+四个既有 Worker 工具名之一与其原参数。Lead 从 server 盖章的来源设备 ID 反查 active team
+内的 Worker,核对真实任务和 `worker_id`,再调用与本机 MCP 相同的 handler/schema;
+请求不能自报本机 role 或指定任意目标。根 Agent 回报限制在运行设备转发前执行。
+桥接请求可选增加 `reportedInputClientIds`(最多 64 个安全 ID),由运行宿主在工具调用入口
+同步捕获本轮已消费输入,不接受模型参数指定。Lead 仅结清相交的等待输入;仍在排队的新
+输入保持持久等待记录和运行状态。旧端缺少此字段时不清除等待记录,保留自动回报兜底;
+新字段不改变四个 MCP 工具 schema,也不改变本机 Worker 的回报路径。
+`caps` 可选增加 `workerBridge: true`,协议版本仍为 1,既有 open/release 载荷不变;
+桥接沿既有同账号远控授权,Lead 电脑未开放反向远控时也保留自动回报,不扩大授权。
+旧端忽略可选字段或返回 `CHANNEL_NOT_ALLOWED`,保留原有完成后自动回报,不降级为通用 handoff,
+不自动重试结果不明的写操作。完整主动往返需要 Lead 与运行设备均更新,服务端无需变化。
+`get_current_session_id` 和 `list_sessions` 可选投影既有远端来源标记;普通任务不增加空字段。
+桌面及手机的控制端继续通过任务所属电脑使用协同,不新增 UI、push 或 Mobile 原生输入。
+故障动作只影响当前 Worker 的一次桥接请求,不重启 peer 或共享 relay;另一设备的自动回报
+继续由既有运行时处理。权限隔离、旧端、账号切换与真实 handler 往返见
+`apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerBridge.test.ts`。
+
Orca 原地 Agent 切换补充边界:执行设备任务按既有 `orca_remote_lead` 判定,
与 `orca_role` 一样拒绝用户换 Agent 位置,不新增 wire 字段或版本要求。
Mobile 对已在另一台电脑运行的 Orca Agent,按所展示的模型目录所在电脑查询
diff --git a/packages/device-link/src/__tests__/orcaRemoteWorker.test.ts b/packages/device-link/src/__tests__/orcaRemoteWorker.test.ts
index 79a18a1a8b..0755f7f59f 100644
--- a/packages/device-link/src/__tests__/orcaRemoteWorker.test.ts
+++ b/packages/device-link/src/__tests__/orcaRemoteWorker.test.ts
@@ -2,12 +2,14 @@ import { describe, expect, it } from 'vitest';
import {
INVOKE_TIMEOUT_OVERRIDES_MS,
ORCA_REMOTE_WORKER_CAPS_CHANNEL,
+ ORCA_REMOTE_WORKER_BRIDGE_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_TIMEOUT_MS,
ORCA_REMOTE_WORKER_RELEASE_CHANNEL,
REMOTE_INVOKE_ALLOWLIST,
parseOrcaRemoteWorkerOpenRequest,
parseOrcaRemoteWorkerReleaseRequest,
+ parseOrcaRemoteWorkerBridgeRequest,
} from '../index.js';
const base = {
@@ -18,11 +20,31 @@ const base = {
lead: { leadSessionId: 'lead-1', leadTitle: '整理产品访谈报告', workerLabel: '转写' },
};
+// Optional Host input correlation must survive the wire without breaking older requests.
+// Review bug: a report for A cleared queued B. Unit tier: real parser, one bridge request;
+// existing open/release tests do not cover this input-specific settlement metadata.
+describe('parseOrcaRemoteWorkerBridgeRequest', () => {
+ const request = { sessionId: 'remote-1', leadSessionId: 'lead-1', tool: 'send_to_lead', args: { worker_id: 'worker-1' } };
+ it('accepts legacy requests and copies bounded input correlation', () => {
+ expect(parseOrcaRemoteWorkerBridgeRequest(request)).toEqual(request);
+ const ids = ['a', 'a', 'b'];
+ const parsed = parseOrcaRemoteWorkerBridgeRequest({ ...request, reportedInputClientIds: ids });
+ ids.push('c');
+ expect(parsed.reportedInputClientIds).toEqual(['a', 'b']);
+ });
+ it.each([null, 'a', ['../x'], Array.from({ length: 65 }, (_, i) => `input-${i}`)])(
+ 'rejects invalid input correlation %j', (ids) => {
+ expect(() => parseOrcaRemoteWorkerBridgeRequest({ ...request, reportedInputClientIds: ids })).toThrow(/INVALID_PARAMS/);
+ },
+ );
+});
+
describe('orca remote worker channels', () => {
// Shared-task guests are refused by the desktop shared-task gate (not in its channel list).
it('registers caps / open / release on the same-account allowlist', () => {
for (const channel of [
ORCA_REMOTE_WORKER_CAPS_CHANNEL,
+ ORCA_REMOTE_WORKER_BRIDGE_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_CHANNEL,
ORCA_REMOTE_WORKER_RELEASE_CHANNEL,
]) {
diff --git a/packages/device-link/src/allowlist.ts b/packages/device-link/src/allowlist.ts
index 510a7a3415..1c346a1fce 100644
--- a/packages/device-link/src/allowlist.ts
+++ b/packages/device-link/src/allowlist.ts
@@ -30,6 +30,7 @@ import { REMOTE_AGENT_CHANNEL } from './remoteAgent.js';
import {
ORCA_EXECUTION_DEVICES_CHANNEL,
ORCA_REMOTE_WORKER_CAPS_CHANNEL,
+ ORCA_REMOTE_WORKER_BRIDGE_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_TIMEOUT_MS,
ORCA_REMOTE_WORKER_RELEASE_CHANNEL,
@@ -445,6 +446,7 @@ const EXTENDED_INVOKE_CHANNELS: readonly string[] = [
// 业务 handler 不依赖 sender、无本机 UI 副作用;来源电脑取 server 盖章的 src。
// 老版本无 handler → CHANNEL_NOT_ALLOWED,控制端提示更新而不回退普通建任务。
ORCA_REMOTE_WORKER_CAPS_CHANNEL,
+ ORCA_REMOTE_WORKER_BRIDGE_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_CHANNEL,
ORCA_REMOTE_WORKER_RELEASE_CHANNEL,
// 远程控制 Lead 所在电脑时,读取那台视角下可选的运行设备(只读,真相在被控端)。
diff --git a/packages/device-link/src/orcaRemoteWorker.ts b/packages/device-link/src/orcaRemoteWorker.ts
index 63367082fd..f399acc90e 100644
--- a/packages/device-link/src/orcaRemoteWorker.ts
+++ b/packages/device-link/src/orcaRemoteWorker.ts
@@ -1,17 +1,20 @@
/**
* 协同远端 Worker(同账号):Lead 与团队留在发起电脑(控制端),单个 Worker 的任务、目录、
* 命令与文件都在运行设备(被控端)上。运行设备上的 Worker 是一条普通任务,带「来自哪台
- * 电脑的协同」标记;派活、停止与回报复用现有会话通道,这里只登记运行设备新增的三个入口:
+ * 电脑的协同」标记;派活、停止与自动回报复用现有会话通道;以下登记专用生命周期与桥接口:
*
* - `caps`:能力探测。老版本没有该 channel → CHANNEL_NOT_ALLOWED,控制端据此提示更新,
* 不回退到普通建任务(普通任务没有防嵌套与来源标记)。
* - `open`:按控制端给定的 sessionId 新建 Worker 任务,幂等(同一控制端重复 open 返回同一任务)。
* 来源电脑身份取 server 盖章的 src,不采信载荷自报。
* - `release`:通知运行设备这个 Worker 已结束协同,任务与文件保留。幂等。
+ * - `bridge`:运行设备向 Lead 转发四个既有 Worker 工具;只允许绑定的 Worker/active team。
*/
export const ORCA_REMOTE_WORKER_CAPS_CHANNEL = 'maker:orca:remote-worker:caps';
export const ORCA_REMOTE_WORKER_OPEN_CHANNEL = 'maker:orca:remote-worker:open';
export const ORCA_REMOTE_WORKER_RELEASE_CHANNEL = 'maker:orca:remote-worker:release';
+/** Execution device → owning Lead. Never exposed to shared-task guests. */
+export const ORCA_REMOTE_WORKER_BRIDGE_CHANNEL = 'maker:orca:remote-worker:bridge';
export const ORCA_REMOTE_WORKER_VERSION = 1;
/**
@@ -41,6 +44,36 @@ export type OrcaRemoteWorkerPermissionMode =
export interface OrcaRemoteWorkerCaps {
version: number;
+ workerBridge?: true;
+}
+
+export const ORCA_REMOTE_WORKER_BRIDGE_TOOLS = ['send_to_lead', 'read_lead_history', 'read_lead', 'lead_status'] as const;
+export interface OrcaRemoteWorkerBridgeRequest {
+ sessionId: string;
+ leadSessionId: string;
+ tool: (typeof ORCA_REMOTE_WORKER_BRIDGE_TOOLS)[number];
+ args: Record<string, unknown>;
+ /** Host-captured inputs consumed by the reporting turn; absent on older peers. */
+ reportedInputClientIds?: string[];
+}
+
+export function parseOrcaRemoteWorkerBridgeRequest(raw: unknown): OrcaRemoteWorkerBridgeRequest {
+ if (!isRecord(raw) || !isOrcaRemoteWorkerSessionId(raw.sessionId)
+ || !isOrcaRemoteWorkerSessionId(raw.leadSessionId)
+ || !ORCA_REMOTE_WORKER_BRIDGE_TOOLS.includes(raw.tool as OrcaRemoteWorkerBridgeRequest['tool'])
+ || !isRecord(raw.args)
+ || (raw.reportedInputClientIds !== undefined
+ && (!Array.isArray(raw.reportedInputClientIds)
+ || raw.reportedInputClientIds.length > 64
+ || !raw.reportedInputClientIds.every(isOrcaRemoteWorkerSessionId)))) {
+ throw new Error('[INVALID_PARAMS] invalid remote worker bridge request');
+ }
+ return { sessionId: raw.sessionId, leadSessionId: raw.leadSessionId,
+ tool: raw.tool as OrcaRemoteWorkerBridgeRequest['tool'], args: raw.args,
+ ...(raw.reportedInputClientIds !== undefined
+ ? { reportedInputClientIds: [...new Set(raw.reportedInputClientIds as string[])] }
+ : {}),
+ };
}
export interface OrcaRemoteWorkerOpenRequest {
diff --git a/packages/lizi-mcps/src/__tests__/historyDevices.test.ts b/packages/lizi-mcps/src/__tests__/historyDevices.test.ts
index bba3b6b7b3..d343687782 100644
--- a/packages/lizi-mcps/src/__tests__/historyDevices.test.ts
+++ b/packages/lizi-mcps/src/__tests__/historyDevices.test.ts
@@ -99,6 +99,22 @@ function setup() {
}
describe("history device discovery and queries", () => {
+ // The execution-device Worker has no local orcaRole. Keep its persisted origin
+ // visible through the real list_sessions projection so it can identify its Lead.
+ it("projects remote Worker origin while leaving local role and Fork fields absent", async () => {
+ const s = setup();
+ const base = await s.history.listSessions({ sessionIds: null, workdir: null, fromMs: null, toMs: null,
+ agentKind: null, includeDeleted: false, limit: 1, cursor: null, order: "desc" });
+ if (!base.ok) throw new Error("fixture unavailable");
+ const lead = { leadDeviceId: "pc", leadDeviceName: "PC", leadSessionId: "lead-1", leadTitle: "Lead", workerLabel: "tester" };
+ vi.mocked(s.history.listSessions).mockResolvedValueOnce({ ...base,
+ page: { ...base.page, items: [{ ...base.page.items[0]!, orcaRemoteLead: lead }] } });
+ const result = await s.call("list_sessions");
+ expect(result.sessions[0]).toMatchObject({ orcaRemoteLead: lead });
+ expect(result.sessions[0]).not.toHaveProperty("orcaRole");
+ expect(result.sessions[0]).not.toHaveProperty("parentSessionId");
+ });
+
it("keeps legacy local queries local and preserves their response", async () => {
const s = setup();
expect(await s.call("list_sessions")).toMatchObject({
diff --git a/packages/lizi-mcps/src/__tests__/sessionContext.test.ts b/packages/lizi-mcps/src/__tests__/sessionContext.test.ts
index 543072b68d..a8fce5cf78 100644
--- a/packages/lizi-mcps/src/__tests__/sessionContext.test.ts
+++ b/packages/lizi-mcps/src/__tests__/sessionContext.test.ts
@@ -998,6 +998,18 @@ describe('dynamic lizi MCP session context', () => {
});
});
+ // Runtime identity discovery must expose cross-device origin even when no local
+ // orcaRole exists (the 2026-10-21 live probe otherwise misidentified the Worker).
+ it('returns the execution-device Worker origin from the authoritative context', async () => {
+ const lead = { leadDeviceId: 'pc', leadSessionId: 'lead-1', workerLabel: 'tester' };
+ const server = createXdtHelperMcpServer({}, {
+ agentKind: 'codex', workingDir: '/worker', sessionId: 'remote-worker',
+ vendorOptions: { orcaRemoteWorker: true, orcaRemoteLead: lead },
+ });
+ const result = await tools(server).call_tool.handler({ name: 'get_current_session_id', args: {} });
+ expect(parse(result as never)).toMatchObject({ ok: true, session_id: 'remote-worker', orca_remote_lead: lead });
+ });
+
it('fails closed when the authoritative accessor cannot resolve a session', async () => {
const provider = createLiziMcpProviders({ xdtHelper: {} }).find(
(candidate) => candidate.name === 'cindy_helper',
diff --git a/packages/lizi-mcps/src/xdt-helper/_history_types.ts b/packages/lizi-mcps/src/xdt-helper/_history_types.ts
index 368b164ba0..f568d0de9d 100644
--- a/packages/lizi-mcps/src/xdt-helper/_history_types.ts
+++ b/packages/lizi-mcps/src/xdt-helper/_history_types.ts
@@ -66,6 +66,14 @@ export interface HistorySession {
status: string;
source: string;
orcaRole: string | null;
+ orcaRemoteLead?: {
+ leadDeviceId: string;
+ leadDeviceName: string;
+ leadSessionId: string;
+ leadTitle: string;
+ workerLabel: string;
+ releasedAt?: number;
+ };
parentSessionId: string | null;
createdAt: number; // unix ms
updatedAt: number;
diff --git a/packages/lizi-mcps/src/xdt-helper/get_current_session_id.ts b/packages/lizi-mcps/src/xdt-helper/get_current_session_id.ts
index 20084b3969..c72262c06f 100644
--- a/packages/lizi-mcps/src/xdt-helper/get_current_session_id.ts
+++ b/packages/lizi-mcps/src/xdt-helper/get_current_session_id.ts
@@ -7,6 +7,7 @@ export interface GetCurrentSessionIdDeps {
sessionId?: string;
agentKind: 'claude-code' | 'codex' | 'pi';
workingDir: string;
+ vendorOptions?: Record<string, unknown>;
};
}
@@ -36,6 +37,7 @@ export function registerGetCurrentSessionIdTool(
session_id: ctx.sessionId,
agent_kind: ctx.agentKind,
working_dir: ctx.workingDir,
+ ...(ctx.vendorOptions?.orcaRemoteLead ? { orca_remote_lead: ctx.vendorOptions.orcaRemoteLead } : {}),
});
},
});
diff --git a/packages/lizi-mcps/src/xdt-helper/list_sessions.ts b/packages/lizi-mcps/src/xdt-helper/list_sessions.ts
index 0036eff287..e7cbc5b808 100644
--- a/packages/lizi-mcps/src/xdt-helper/list_sessions.ts
+++ b/packages/lizi-mcps/src/xdt-helper/list_sessions.ts
@@ -158,6 +158,7 @@ export function registerListSessionsTool(
};
if (queuedCounts !== null) out.queuedCount = queuedCounts[s.id] ?? 0;
if (s.orcaRole !== null) out.orcaRole = s.orcaRole;
+ if (s.orcaRemoteLead) out.orcaRemoteLead = s.orcaRemoteLead;
if (s.parentSessionId !== null) out.parentSessionId = s.parentSessionId;
if (s.userSendAt !== null) out.userSendAt = new Date(s.userSendAt).toISOString();
return out;
diff --git a/packages/orca-workflow/src/__tests__/orca-bridge-mcp.test.ts b/packages/orca-workflow/src/__tests__/orca-bridge-mcp.test.ts
index 6a2000756c..53e1458ed7 100644
--- a/packages/orca-workflow/src/__tests__/orca-bridge-mcp.test.ts
+++ b/packages/orca-workflow/src/__tests__/orca-bridge-mcp.test.ts
@@ -274,6 +274,54 @@ function parseToolJson(result: unknown): Record<string, unknown> {
}
describe('orca_worker_bridge MCP helpers', () => {
+ // PR #6659 discussion_r4335862026: ordinary Claude contexts also have a runtime
+ // accessor. Existing caller checks covered tool errors, not MCP exposure. Unit:
+ // the public provider must omit this server for ordinary/Lead Claude sessions,
+ // while preserving local/remote Workers and shared Codex/Pi bridge factories.
+ it.each<{
+ name: string; agentKind: AgentKind; vendorOptions?: Record<string, unknown>; enabled: boolean;
+ }>([
+ { name: 'ordinary Claude', agentKind: 'claude-code', enabled: false },
+ { name: 'Claude Lead', agentKind: 'claude-code', vendorOptions: { orcaRole: 'lead' }, enabled: false },
+ { name: 'local Claude Worker', agentKind: 'claude-code', vendorOptions: { orcaRole: 'worker' }, enabled: true },
+ { name: 'remote Claude Worker', agentKind: 'claude-code', vendorOptions: { orcaRemoteWorker: true }, enabled: true },
+ { name: 'shared Codex bridge', agentKind: 'codex', enabled: true },
+ { name: 'shared Pi bridge', agentKind: 'pi', enabled: true },
+ ])('mounts Worker tools only where needed: $name', ({ agentKind, vendorOptions, enabled }) => {
+ const { maker } = makeProvider();
+ const provider = createOrcaWorkerBridgeMcpProvider({
+ getMaker: () => maker as unknown as Maker, logger: makeLogger(),
+ persistUserMessage: async () => undefined, wireSession: () => undefined,
+ });
+ const ctx: McpProviderContext = { agentKind, workingDir: '', vendorOptions };
+ if (agentKind === 'claude-code') ctx.sessionId = 'claude-session';
+ ctx.getSessionContext = () => ctx.sessionId ? ctx : undefined;
+
+ expect(provider.isEnabled?.(ctx)).toBe(enabled);
+ const config = provider.toClaudeSdkConfig?.(ctx) as { instance: FakeMcpServer } | null;
+ if (!enabled) expect(config).toBeNull();
+ else expect(Object.keys(config!.instance._registeredTools)).toEqual([
+ 'send_to_lead', 'read_lead_history', 'read_lead', 'lead_status',
+ ]);
+ });
+
+ // Live cross-device probe: an authenticated Worker with no local role could see
+ // send_to_lead but was rejected. Forward before local-link resolution, preserving
+ // local handler behavior and the four existing MCP definitions (unit tier).
+ it('forwards a remote session report before resolving a local Worker link', async () => {
+ const { maker } = makeProvider({});
+ const forward = vi.fn(async () => ({ content: [{ type: 'text' as const,
+ text: JSON.stringify({ ok: true, queued: true, lead_session_id: 'lead-on-pc' }) }], isError: false }));
+ const provider = createOrcaWorkerBridgeMcpProvider({ getMaker: () => maker as unknown as Maker,
+ logger: makeLogger(), persistUserMessage: vi.fn(), wireSession: vi.fn(), forwardRemoteWorkerTool: forward });
+ const server = getServer(provider, { agentKind: 'codex', workingDir: '/worker',
+ sessionId: 'remote-worker', mcpCallerAttested: true, mcpCallerKind: 'root' });
+ const result = await server._registeredTools.send_to_lead.handler({ worker_id: 'worker-on-pc', message: 'result' });
+ expect(parseToolJson(result)).toMatchObject({ ok: true, queued: true, lead_session_id: 'lead-on-pc' });
+ expect(forward).toHaveBeenCalledTimes(1);
+ expect(Object.keys(server._registeredTools)).toEqual(['send_to_lead', 'read_lead_history', 'read_lead', 'lead_status']);
+ });
+
it('keeps the caller policy and model-only report contract concise', () => {
expect(authorizeSendToLeadCaller({
agentKind: 'codex',
diff --git a/packages/orca-workflow/src/index.ts b/packages/orca-workflow/src/index.ts
index a47b0b09b0..6e6c11ca1b 100644
--- a/packages/orca-workflow/src/index.ts
+++ b/packages/orca-workflow/src/index.ts
@@ -3,6 +3,7 @@ export {
formatAgentMessage,
formatOrcaCommunicationMessage,
type OrcaBridgeMcpDeps,
+ type OrcaToolResult,
type OrcaLeadHistoryCursor,
type OrcaLeadHistoryMessage,
type OrcaLeadHistoryPage,
diff --git a/packages/orca-workflow/src/orca-bridge-mcp.ts b/packages/orca-workflow/src/orca-bridge-mcp.ts
index b9990c2198..a3a5a4ad4b 100644
--- a/packages/orca-workflow/src/orca-bridge-mcp.ts
+++ b/packages/orca-workflow/src/orca-bridge-mcp.ts
@@ -120,6 +120,12 @@ export interface OrcaWorkerVendorOptions extends Record<string, unknown> {
}
export interface OrcaBridgeMcpDeps {
+ /** Host-owned routing for execution-device Workers; null means a local caller. */
+ forwardRemoteWorkerTool?: (
+ ctx: McpProviderContext,
+ tool: string,
+ args: Record<string, unknown>,
+ ) => Promise<OrcaToolResult | null>;
getMaker: () => Maker;
logger: Logger;
persistUserMessage: (
@@ -202,7 +208,14 @@ function text(data: unknown, isError = false) {
};
}
-type OrcaToolResult = ReturnType<typeof text>;
+export type OrcaToolResult = ReturnType<typeof text>;
+
+type RegisterWorkerTool = <S extends z.ZodRawShape>(
+ name: string,
+ description: string,
+ shape: S,
+ handler: (args: z.output<z.ZodObject<S>>) => Promise<OrcaToolResult>,
+) => void;
type OrcaSendSource = 'mcp-tool' | 'auto-bridge';
type HostOrcaDispatch = {
@@ -715,29 +728,16 @@ async function ensureCapturedSession(
// 契约锚点:归属校验与 auto-bridge settle 见 docs/dev-rules/orca-team-architecture.md「协同运行时行为契约」「坑点与不变量 #3」。
-// Codex MCP HTTP bridge 仍然从全局 ctx 注册 server 名称,所以 worker bridge 必须
-// 对 Codex 可见。真正的执行边界在工具调用时 fail-closed:resolveWorkerLink 会读
+// Codex/Pi MCP HTTP bridge 从全局 ctx 注册 server 名称,所以 worker bridge 必须
+// 对共享桥接可见。真正的执行边界在工具调用时 fail-closed:resolveWorkerLink 会读
// 本次调用绑定的 session ctx,并校验它确实拥有解析出的 worker link。
-export function createOrcaWorkerBridgeMcpProvider(deps: OrcaBridgeMcpDeps): McpProvider {
+export function createOrcaWorkerBridgeMcpProvider(deps: OrcaBridgeMcpDeps) {
const log = deps.logger.child('mcp/orca_worker_bridge');
const leadCaptures = new CapturedSessionRegistry();
- return {
- name: 'orca_worker_bridge',
- // Global HTTP bridges (Codex and Pi) bind the real session only at request time.
- // Keep the server registered when a dynamic context resolver exists; every tool
- // call still fails closed in resolveWorkerLink against that runtime identity.
- isEnabled: (ctx) =>
- ctx.vendorOptions?.orcaRole === 'worker'
- || ctx.agentKind === 'codex'
- || typeof ctx.getSessionContext === 'function',
- toClaudeSdkConfig: (ctx) => {
- if (
- ctx.vendorOptions?.orcaRole !== 'worker'
- && ctx.agentKind !== 'codex'
- && typeof ctx.getSessionContext !== 'function'
- ) return null;
- const server = new McpServer({ name: 'orca_worker_bridge', version: '0.1.0' });
-
+ function defineTools(
+ ctx: McpProviderContext, register: RegisterWorkerTool,
+ options: { manageWorkerStatus?: boolean } = {},
+ ): void {
async function resolveLead(workerId?: string) {
const resolved = await resolveWorkerLink(deps, ctx, workerId);
if (!resolved.ok) return resolved;
@@ -755,7 +755,7 @@ export function createOrcaWorkerBridgeMcpProvider(deps: OrcaBridgeMcpDeps): McpP
return { ok: true as const, link, entry };
}
- server.tool(
+ register(
'send_to_lead',
SEND_TO_LEAD_TOOL_DESCRIPTION,
{
@@ -808,7 +808,10 @@ export function createOrcaWorkerBridgeMcpProvider(deps: OrcaBridgeMcpDeps): McpP
const settleWorkerReport = () => {
if (workerReportSettled) return;
workerReportSettled = true;
- updatePersistedWorkerStatus(deps, link.workerId, 'done', log);
+ // The remote Host owns input-specific settlement; a later queued assignment
+ // must not be marked done by this older turn's report. Local MCP stays unchanged.
+ if (options.manageWorkerStatus !== false)
+ updatePersistedWorkerStatus(deps, link.workerId, 'done', log);
};
const dispatchError = await dispatchOrcaToolMessage({
session: liveEntry.session,
@@ -886,7 +889,7 @@ export function createOrcaWorkerBridgeMcpProvider(deps: OrcaBridgeMcpDeps): McpP
},
);
- server.tool(
+ register(
'read_lead_history',
'Read user/assistant transcript rows from your owning Lead without waking or modifying the Lead. Use only when an [Orca UI Assignment] depends on Lead context. You MUST pass your worker_id.',
{
@@ -959,7 +962,7 @@ export function createOrcaWorkerBridgeMcpProvider(deps: OrcaBridgeMcpDeps): McpP
},
);
- server.tool(
+ register(
'read_lead',
'You MUST pass your worker_id (see the Bridge note at the end of the most recent lead message). Read captured output from the lead session.',
{
@@ -980,7 +983,7 @@ export function createOrcaWorkerBridgeMcpProvider(deps: OrcaBridgeMcpDeps): McpP
},
);
- server.tool(
+ register(
'lead_status',
'You MUST pass your worker_id (see the Bridge note at the end of the most recent lead message). Check the lead session state.',
{
@@ -1000,11 +1003,60 @@ export function createOrcaWorkerBridgeMcpProvider(deps: OrcaBridgeMcpDeps): McpP
},
);
- return {
- type: 'sdk',
- name: 'orca_worker_bridge',
- instance: server,
- };
+ }
+
+ const registerRoutedTools = (
+ ctx: McpProviderContext, register: RegisterWorkerTool,
+ options: { manageWorkerStatus?: boolean } = {},
+ ) => {
+ defineTools(ctx, (name, description, shape, handler) => {
+ register(name, description, shape, async (args) => {
+ const runtime = resolveRuntimeMcpContext(ctx);
+ if (name === 'send_to_lead') {
+ const authorization = authorizeSendToLeadCaller(runtime);
+ if (!authorization.ok) return text(authorization.error, true);
+ }
+ const forwarded = await deps.forwardRemoteWorkerTool?.(runtime, name, args);
+ return forwarded ?? handler(args);
+ });
+ }, options);
+ };
+ const enabled = (ctx: McpProviderContext) =>
+ ctx.vendorOptions?.orcaRole === 'worker'
+ || ctx.vendorOptions?.orcaRemoteWorker === true
+ || ctx.agentKind === 'codex'
+ // Claude also has this accessor on ordinary per-session contexts; it is not a role.
+ || (ctx.agentKind === 'pi' && typeof ctx.getSessionContext === 'function');
+
+ return {
+ name: 'orca_worker_bridge',
+ isEnabled: enabled,
+ toClaudeSdkConfig: (ctx: McpProviderContext) => {
+ if (!enabled(ctx)) return null;
+ const server = new McpServer({ name: 'orca_worker_bridge', version: '0.1.0' });
+ registerRoutedTools(ctx, (name, description, shape, handler) => {
+ // MCP validates the shape before calling this handler; direct Host invocation below
+ // validates explicitly. Erase only the SDK's generic zod-v3/v4 compatibility wrapper.
+ server.tool<z.ZodRawShape>(name, description, shape, async args => handler(args as z.output<z.ZodObject<typeof shape>>));
+ });
+ return { type: 'sdk' as const, name: 'orca_worker_bridge', instance: server };
+ },
+ /** Same handlers and schemas as MCP, after the Host attests a remote Worker link. */
+ async invokeTool(
+ ctx: McpProviderContext, tool: string, args: Record<string, unknown>,
+ options: { manageWorkerStatus?: boolean } = {},
+ ): Promise<OrcaToolResult> {
+ let invoke: (() => Promise<OrcaToolResult>) | undefined;
+ registerRoutedTools(ctx, (name, _description, shape, handler) => {
+ if (name === tool) invoke = () => handler(z.object(shape).parse(args));
+ }, options);
+ if (!invoke) return text({ error: 'unknown worker bridge tool' }, true);
+ return invoke();
},
+ } satisfies McpProvider & {
+ invokeTool(
+ ctx: McpProviderContext, tool: string, args: Record<string, unknown>,
+ options?: { manageWorkerStatus?: boolean },
+ ): Promise<OrcaToolResult>;
};
}
diff --git a/packages/orca-workflow/src/orca-bridge-prompt.ts b/packages/orca-workflow/src/orca-bridge-prompt.ts
index 2231e1774d..adc5a26985 100644
--- a/packages/orca-workflow/src/orca-bridge-prompt.ts
+++ b/packages/orca-workflow/src/orca-bridge-prompt.ts
@@ -73,7 +73,7 @@ export function renderOrcaLeadSystemPrompt(initialWorker?: OrcaInitialWorkerRef
'Never simulate an interrupt or merge with multiple stop, update, cancel, or send calls because the queue may advance between calls.',
'5. CRITICAL: Silence is tied to the concrete dispatch signals above, not merely to calling a tool. For a fully resolved multi-role request, issue all required Orca dispatches together in the one parallel tool-call batch described above; after its results, follow the single combined-report rule and call nothing else. For a single dispatched create_worker, send_to_worker, or interrupt_worker result, end immediately with no output or further tool calls. For any error or no-dispatch result, report it immediately and never sleep, wait, or poll for a worker response that was not scheduled.',
'6. When a worker report arrives (prefixed with [From Orca Worker ...]), review it and handle any immediate follow-up. If other Orca Workers are still working, do not wait for them; their reports will arrive as new messages. Produce the final summary only after every relevant task has a terminal result from its own execution channel (rule 8).',
- '7. If you see "[Auto-bridged: ...]" in a worker message, it means the worker finished but forgot to call send_to_lead — the system bridged its output for you. Treat it the same as a normal worker report.',
+ '7. If you see "[Auto-bridged: ...]" in a worker message, the system forwarded its result automatically. Treat it the same as a normal worker report; this does not imply a missed tool call.',
'8. Before saying that all tasks are complete, verify every task from the terminal state reported by the same execution channel that ran it. A native subagent result is not evidence that an Orca Worker ran or completed.',
'9. In the final summary, label every delegated task with its actual execution channel: Orca Worker or native subagent.',
];