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。

feat(orca): Lead 可把 Worker 放到同账号另一台电脑运行

DavidShen001a010caa1f
diff --git a/apps/desktop/src/main/localDb/orcaTeamStore.ts b/apps/desktop/src/main/localDb/orcaTeamStore.ts
index c7e7e5acdf..38f463e539 100644
--- a/apps/desktop/src/main/localDb/orcaTeamStore.ts
+++ b/apps/desktop/src/main/localDb/orcaTeamStore.ts
@@ -1,5 +1,5 @@
import { BrowserWindow } from 'electron';
-import { and, desc, eq, gt, inArray, ne } from 'drizzle-orm';
+import { and, desc, eq, gt, inArray, isNotNull, isNull, ne } from 'drizzle-orm';
import { createId } from '@paralleldrive/cuid2';
import { getDbClient } from './client/current.js';
@@ -61,6 +61,30 @@ export interface OrcaWorkerRecord {
fastMode: boolean;
sdkSessionId?: string;
};
+ /**
+ * Worker 在同账号另一台电脑运行时的运行设备与那台上的真实任务 id;缺省 = 本机 Worker。
+ * 此时 sessionId / session 指本机不跑 Agent 的代理任务行。
+ */
+ executionDevice?: {
+ deviceId: string;
+ remoteSessionId: string;
+ /** 以下为运行期投影(本机轮询所得),未装配宿主时缺省。 */
+ deviceName?: string;
+ reachable?: boolean;
+ /** 运行设备上的工作目录;尚未读到时缺省。 */
+ workingDir?: string;
+ };
+}
+
+/** 远端 Worker 的运行期状态由宿主注入(轮询所得),读模型投影时附带,不落库。 */
+type RemoteWorkerStatusProvider = (
+ proxySessionId: string,
+ deviceId: string,
+) => { deviceName: string; reachable: boolean; workingDir?: string };
+let remoteWorkerStatusProvider: RemoteWorkerStatusProvider | null = null;
+
+export function setRemoteWorkerStatusProvider(provider: RemoteWorkerStatusProvider | null): void {
+ remoteWorkerStatusProvider = provider;
}
export interface OrcaWorkerLinkRecord {
@@ -683,9 +707,143 @@ function workerToRecord(
fastMode: !!session.fastMode,
sdkSessionId: session.sdkSessionId ?? undefined,
},
+ ...(worker.executionDeviceId && worker.remoteSessionId
+ ? {
+ executionDevice: {
+ deviceId: worker.executionDeviceId,
+ remoteSessionId: worker.remoteSessionId,
+ ...(remoteWorkerStatusProvider?.(worker.sessionId, worker.executionDeviceId) ?? {}),
+ },
+ }
+ : {}),
+ };
+}
+
+// ─── 协同远端 Worker(运行在同账号另一台电脑) ─────────────────────────────────
+
+export interface RemoteWorkerRow {
+ workerId: string;
+ teamId: string;
+ leadSessionId: string;
+ proxySessionId: string;
+ deviceId: string;
+ remoteSessionId: string;
+ lastBridgedMessageId: string | null;
+}
+
+/**
+ * 写入远端 Worker 的本机代理任务行:不跑 Agent,不绑定本机目录(working_dir 为空),
+ * 只用来承接现有协同的计槽、归档与回报。真实任务在运行设备上。
+ */
+export async function insertRemoteWorkerProxySession(input: {
+ id: string;
+ title: string;
+ agentKind: MakerAgentKind;
+ model: string;
+ effort: string | null;
+ permissionMode: string;
+ fastMode: boolean;
+}): Promise<void> {
+ const now = Date.now();
+ await getDbClient()
+ .drizzle.insert(sessions)
+ .values({
+ id: input.id,
+ title: input.title,
+ workingDir: null,
+ workspaceKind: 'project',
+ model: input.model,
+ effort: (input.effort ?? 'high') as (typeof sessions.$inferInsert)['effort'],
+ permissionMode: input.permissionMode as (typeof sessions.$inferInsert)['permissionMode'],
+ fastMode: input.fastMode,
+ status: 'active',
+ agentKind: input.agentKind === 'claude-code' ? 'cc' : input.agentKind,
+ orcaRole: 'worker',
+ source: 'desktop',
+ createdAt: now,
+ updatedAt: now,
+ });
+}
+
+export async function setWorkerRemoteExecution(
+ workerId: string,
+ input: { deviceId: string; remoteSessionId: string },
+): Promise<void> {
+ await getDbClient()
+ .drizzle.update(orcaWorkers)
+ .set({ executionDeviceId: input.deviceId, remoteSessionId: input.remoteSessionId, updatedAt: Date.now() })
+ .where(eq(orcaWorkers.id, workerId));
+}
+
+export async function setWorkerLastBridgedMessageId(workerId: string, messageId: string): Promise<void> {
+ await getDbClient()
+ .drizzle.update(orcaWorkers)
+ .set({ lastBridgedMessageId: messageId })
+ .where(eq(orcaWorkers.id, workerId));
+}
+
+export async function markWorkerRemoteReleased(workerId: string, at = Date.now()): Promise<void> {
+ await getDbClient()
+ .drizzle.update(orcaWorkers)
+ .set({ remoteReleasedAt: at })
+ .where(eq(orcaWorkers.id, workerId));
+}
+
+function remoteWorkerRow(
+ worker: typeof orcaWorkers.$inferSelect,
+ team: typeof orcaTeams.$inferSelect,
+): RemoteWorkerRow | null {
+ if (!worker.executionDeviceId || !worker.remoteSessionId) return null;
+ return {
+ workerId: worker.id,
+ teamId: worker.teamId,
+ leadSessionId: team.leadSessionId,
+ proxySessionId: worker.sessionId,
+ deviceId: worker.executionDeviceId,
+ remoteSessionId: worker.remoteSessionId,
+ lastBridgedMessageId: worker.lastBridgedMessageId,
};
}
+/** 仍在协同中的远端 Worker(团队与代理任务都处于活跃状态),启动时据此恢复轮询。 */
+export async function listActiveRemoteWorkers(): Promise<RemoteWorkerRow[]> {
+ const rows = await getDbClient()
+ .drizzle.select({ worker: orcaWorkers, team: orcaTeams })
+ .from(orcaWorkers)
+ .innerJoin(orcaTeams, eq(orcaTeams.id, orcaWorkers.teamId))
+ .innerJoin(sessions, eq(sessions.id, orcaWorkers.sessionId))
+ .where(and(
+ eq(orcaTeams.status, 'active'),
+ eq(sessions.status, 'active'),
+ isNotNull(orcaWorkers.executionDeviceId),
+ ));
+ return rows.flatMap((row) => remoteWorkerRow(row.worker, row.team) ?? []);
+}
+
+/** 已结束协同(归档或团队结束)但还没通知到运行设备的远端 Worker,重连后补发。 */
+export async function listUnreleasedEndedRemoteWorkers(): Promise<RemoteWorkerRow[]> {
+ const rows = await getDbClient()
+ .drizzle.select({ worker: orcaWorkers, team: orcaTeams, session: sessions })
+ .from(orcaWorkers)
+ .innerJoin(orcaTeams, eq(orcaTeams.id, orcaWorkers.teamId))
+ .innerJoin(sessions, eq(sessions.id, orcaWorkers.sessionId))
+ .where(and(isNotNull(orcaWorkers.executionDeviceId), isNull(orcaWorkers.remoteReleasedAt)));
+ return rows
+ .filter((row) => row.team.status !== 'active' || row.session.status !== 'active')
+ .flatMap((row) => remoteWorkerRow(row.worker, row.team) ?? []);
+}
+
+/** 按代理任务 id 查远端 Worker;不论团队是否仍活跃。 */
+export async function getRemoteWorkerByProxySession(proxySessionId: string): Promise<RemoteWorkerRow | null> {
+ const [row] = await getDbClient()
+ .drizzle.select({ worker: orcaWorkers, team: orcaTeams })
+ .from(orcaWorkers)
+ .innerJoin(orcaTeams, eq(orcaTeams.id, orcaWorkers.teamId))
+ .where(eq(orcaWorkers.sessionId, proxySessionId))
+ .limit(1);
+ return row ? remoteWorkerRow(row.worker, row.team) : null;
+}
+
function fromDbAgentKind(agentKind: string): MakerAgentKind {
return agentKind === 'codex' || agentKind === 'pi' ? agentKind : 'claude-code';
}
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaLifecycleService.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaLifecycleService.test.ts
index 13fe62efe5..4e9d957a03 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaLifecycleService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaLifecycleService.test.ts
@@ -163,7 +163,7 @@ describe('OrcaLifecycleService', () => {
insideSend = true; allowed = !revoked;
try { await runAcceptedCallback(opts.onAccepted, 'worker-session-1', 'placeholder'); nativeCalls++; return { dispatched: true }; }
finally { insideSend = false; }
- } }) }, ORCA_WORKER_READY_MESSAGE, AcceptedCallbackDispatchCancelled, assertDesktopSendDispatched: vi.fn(), log: { info: vi.fn() } };
+ } }) }, ORCA_WORKER_READY_MESSAGE, AcceptedCallbackDispatchCancelled, assertDesktopSendDispatched: vi.fn(), log: { info: vi.fn() }, orcaRemoteWorkers: { runtime: { isRemote: () => false } } };
const js = ts.transpileModule(`return ({${callback}}).sendWorkerReadyPlaceholder;`, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText;
deps.sendWorkerReadyPlaceholder = new Function('hasAcceptedUserTaskInput', ...Object.keys(bindings), js)(hasAcceptedUserTaskInput, ...Object.values(bindings));
deps.rollbackCreatedWorker = vi.fn(async () => { expect(insideSend).toBe(false); });
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerRuntime.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerRuntime.test.ts
new file mode 100644
index 0000000000..fa3978f85d
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkerRuntime.test.ts
@@ -0,0 +1,290 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+ createOrcaRemoteWorkerRuntime,
+ type OrcaRemoteWorkerRuntimeDeps,
+ type RemoteWorkerRef,
+} from '../orcaRemoteWorkerRuntime.js';
+
+const ref: RemoteWorkerRef = {
+ workerId: 'worker-1',
+ teamId: 'team-1',
+ leadSessionId: 'lead-1',
+ proxySessionId: 'proxy-1',
+ deviceId: 'mac-mini',
+ remoteSessionId: 'remote-1',
+ lastBridgedMessageId: null,
+};
+
+interface FakeDevice {
+ offline: boolean;
+ running: boolean;
+ receipts: Record<string, string>;
+ assistant: { id: string; content: unknown } | null;
+ terminalError: boolean;
+ enqueueError?: Error & { inFlight?: boolean };
+ enqueued: unknown[];
+ aborted: number;
+ released: number;
+}
+
+function setup(device: Partial<FakeDevice> = {}) {
+ const state: FakeDevice = {
+ offline: false,
+ running: false,
+ receipts: {},
+ assistant: { id: 'msg-0', content: '旧回复' },
+ terminalError: false,
+ enqueued: [],
+ aborted: 0,
+ released: 0,
+ ...device,
+ };
+ const invoke = vi.fn(async (_deviceId: string, channel: string, args: unknown[]) => {
+ if (state.offline) throw new Error('[DEVICE_OFFLINE] target offline');
+ switch (channel) {
+ case 'maker:list-active':
+ return {
+ format: 'active-sessions-v2',
+ sessions: [{ sessionId: 'remote-1', isTurnRunning: state.running }],
+ };
+ case 'local-db:sessions:get':
+ return {
+ id: 'remote-1',
+ status: 'active',
+ agentKind: 'cc',
+ workingDir: '/Users/demo/Interviews',
+ model: 'claude-opus-5-5',
+ effort: 'high',
+ permissionMode: 'auto',
+ fastMode: false,
+ sdkSessionId: 'sdk-1',
+ };
+ case 'local-db:history:messages':
+ return {
+ items: state.assistant ? [state.assistant] : [],
+ hasMore: false,
+ nextCursor: null,
+ terminal: state.terminalError ? { status: 'error' } : null,
+ };
+ case 'maker:input:enqueue':
+ if (state.enqueueError) throw state.enqueueError;
+ state.enqueued.push(args[1]);
+ state.receipts[(args[1] as { clientId: string }).clientId] = 'pending';
+ return {};
+ case 'maker:input:get-projection': {
+ const ids = (args[1] as { deliveryClientIds: string[] }).deliveryClientIds;
+ return {
+ deliveryReceipts: ids.map((clientId) => ({
+ clientId,
+ state: state.receipts[clientId] ?? 'unknown',
+ })),
+ };
+ }
+ case 'maker:abort-session':
+ state.aborted += 1;
+ return undefined;
+ case 'maker:orca:remote-worker:release':
+ state.released += 1;
+ return { released: true };
+ default:
+ throw new Error(`[CHANNEL_NOT_ALLOWED] ${channel}`);
+ }
+ });
+ const deps: OrcaRemoteWorkerRuntimeDeps = {
+ invoke,
+ deviceName: () => 'Mac mini',
+ saveLastBridgedMessageId: vi.fn(async () => undefined),
+ onTurnStarted: vi.fn(async () => undefined),
+ onTurnEnded: vi.fn(async () => undefined),
+ onWorkerStateChanged: vi.fn(),
+ now: () => Date.parse('2026-10-09T10:24:00Z'),
+ setTimeout: vi.fn(() => ({})),
+ clearTimeout: vi.fn(),
+ log: { info: vi.fn(), warn: vi.fn() },
+ };
+ const runtime = createOrcaRemoteWorkerRuntime(deps);
+ runtime.track(ref);
+ return { runtime, deps, state, invoke };
+}
+
+describe('orca remote worker runtime', () => {
+ it('enqueues a Lead message on the execution device with the device task’s own settings', async () => {
+ const { runtime, state } = setup();
+ await expect(
+ runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: '转写这段访谈', clientId: 'c-1' }),
+ ).resolves.toEqual({ ok: true, mode: 'dispatched' });
+ expect(state.enqueued).toHaveLength(1);
+ expect(state.enqueued[0]).toMatchObject({
+ clientId: 'c-1',
+ durableDelivery: true,
+ text: '[From Orca Lead]\n转写这段访谈',
+ origin: { kind: 'orca', senderLabel: 'Lead', displayText: '转写这段访谈' },
+ createOpts: {
+ agentKind: 'claude-code',
+ workingDir: '/Users/demo/Interviews',
+ model: 'claude-opus-5-5',
+ resumeSessionId: 'sdk-1',
+ },
+ });
+ expect((state.enqueued[0] as { text: string }).text).not.toContain('worker_id');
+ expect(runtime.hasPendingReport('proxy-1')).toBe(true);
+ });
+
+ it('reports the turn start once and the final reply once after the message was consumed', async () => {
+ const { runtime, deps, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: '转写', clientId: 'c-1' });
+
+ state.running = true;
+ state.receipts['c-1'] = 'accepted';
+ await runtime.pollNow();
+ await runtime.pollNow();
+ expect(deps.onTurnStarted).toHaveBeenCalledTimes(1);
+ expect(runtime.isTurnRunning('proxy-1')).toBe(true);
+
+ state.running = false;
+ state.assistant = { id: 'msg-1', content: [{ type: 'text', text: '逐字稿已生成' }] };
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledWith('proxy-1', {
+ status: 'done',
+ finalText: '逐字稿已生成',
+ });
+ expect(deps.saveLastBridgedMessageId).toHaveBeenCalledWith('worker-1', 'msg-1');
+ expect(runtime.hasPendingReport('proxy-1')).toBe(false);
+
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledTimes(1);
+ });
+
+ 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' });
+ state.assistant = { id: 'msg-user-turn', content: '插话的回复' };
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).not.toHaveBeenCalled();
+ expect(runtime.hasPendingReport('proxy-1')).toBe(true);
+ });
+
+ it('does not report turns started by someone on the device itself', async () => {
+ const { runtime, deps, state } = setup();
+ state.running = true;
+ await runtime.pollNow();
+ expect(runtime.isTurnRunning('proxy-1')).toBe(true);
+ state.running = false;
+ state.assistant = { id: 'msg-9', content: '插话的回复' };
+ await runtime.pollNow();
+ expect(deps.onTurnStarted).not.toHaveBeenCalled();
+ expect(deps.onTurnEnded).not.toHaveBeenCalled();
+ });
+
+ it('marks the device unreachable without failing the worker, then recovers and still reports', async () => {
+ const { runtime, deps, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: '转写', clientId: 'c-1' });
+ state.offline = true;
+ await runtime.pollNow();
+ expect(runtime.isReachable('proxy-1')).toBe(false);
+ expect(deps.onWorkerStateChanged).toHaveBeenCalledWith('lead-1');
+ expect(deps.onTurnEnded).not.toHaveBeenCalled();
+
+ state.offline = false;
+ state.receipts['c-1'] = 'accepted';
+ state.assistant = { id: 'msg-1', content: '断线期间完成' };
+ await runtime.pollNow();
+ expect(runtime.isReachable('proxy-1')).toBe(true);
+ expect(deps.onTurnEnded).toHaveBeenCalledWith('proxy-1', {
+ status: 'done',
+ finalText: '断线期间完成',
+ });
+ });
+
+ it('fails a dispatch to an offline device instead of queueing it', async () => {
+ const { runtime, state } = setup({ offline: true });
+ const result = await runtime.dispatch({
+ proxySessionId: 'proxy-1',
+ rawContent: 'x',
+ clientId: 'c-1',
+ });
+ expect(result).toMatchObject({ ok: false, code: 'DEVICE_UNREACHABLE' });
+ expect(state.enqueued).toHaveLength(0);
+ expect(runtime.hasPendingReport('proxy-1')).toBe(false);
+ });
+
+ it('treats a lost enqueue reply as delivered when the device already holds the message', async () => {
+ const lost = Object.assign(new Error('[INVOKE_TIMEOUT] no reply'), { inFlight: true });
+ const { runtime, state } = setup({ enqueueError: lost, receipts: { 'c-1': 'pending' } });
+ await expect(
+ runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'x', clientId: 'c-1' }),
+ ).resolves.toEqual({ ok: true, mode: 'dispatched' });
+ expect(state.enqueued).toHaveLength(0);
+ expect(runtime.hasPendingReport('proxy-1')).toBe(true);
+ });
+
+ it('does not re-report an already bridged reply and ends with an error when no new reply appears', async () => {
+ const { runtime, deps, state } = setup({ assistant: { id: 'msg-0', content: '旧回复' } });
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'x', clientId: 'c-1' });
+ state.receipts['c-1'] = 'accepted';
+ for (let i = 0; i < 14; i += 1) await runtime.pollNow();
+ expect(deps.onTurnEnded).not.toHaveBeenCalled();
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledWith(
+ 'proxy-1',
+ expect.objectContaining({ status: 'error' }),
+ );
+ });
+
+ it('reports an error turn when the device marks the session as failed', async () => {
+ const { runtime, deps, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'x', clientId: 'c-1' });
+ state.receipts['c-1'] = 'accepted';
+ state.terminalError = true;
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledWith(
+ 'proxy-1',
+ expect.objectContaining({ status: 'error' }),
+ );
+ });
+
+ it('reports an error when the message was withdrawn on the device', async () => {
+ const { runtime, deps, state } = setup();
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'x', clientId: 'c-1' });
+ state.receipts['c-1'] = 'removed';
+ await runtime.pollNow();
+ expect(deps.onTurnEnded).toHaveBeenCalledWith(
+ 'proxy-1',
+ expect.objectContaining({ status: 'error' }),
+ );
+ });
+
+ it('aborts and releases through the device and treats an already-deleted task as released', async () => {
+ const { runtime, state, invoke } = setup();
+ await expect(runtime.abort('proxy-1')).resolves.toBe(true);
+ expect(state.aborted).toBe(1);
+ await expect(runtime.release(ref)).resolves.toBe(true);
+ expect(state.released).toBe(1);
+ invoke.mockRejectedValueOnce(new Error('[NOT_FOUND] gone'));
+ await expect(runtime.release(ref)).resolves.toBe(true);
+ state.offline = true;
+ await expect(runtime.release(ref)).resolves.toBe(false);
+ });
+
+ it('learns the working directory on the device once for display', async () => {
+ const { runtime, deps, invoke } = setup();
+ expect(runtime.workingDir('proxy-1')).toBeNull();
+ await runtime.pollNow();
+ expect(runtime.workingDir('proxy-1')).toBe('/Users/demo/Interviews');
+ expect(deps.onWorkerStateChanged).toHaveBeenCalledWith('lead-1');
+ await runtime.pollNow();
+ expect(invoke.mock.calls.filter(([, channel]) => channel === 'local-db:sessions:get')).toHaveLength(1);
+ runtime.track({ ...ref, proxySessionId: 'proxy-2' }, { workingDir: 'D:\\work' });
+ expect(runtime.workingDir('proxy-2')).toBe('D:\\work');
+ });
+
+ it('polls slowly when idle and quickly while a report is pending', async () => {
+ const { runtime, deps } = setup();
+ expect(deps.setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 15_000);
+ await runtime.dispatch({ proxySessionId: 'proxy-1', rawContent: 'x', clientId: 'c-1' });
+ expect(deps.setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 2_000);
+ runtime.untrack('proxy-1');
+ expect(runtime.isRemote('proxy-1')).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkers.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkers.test.ts
new file mode 100644
index 0000000000..b2d614eae7
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaRemoteWorkers.test.ts
@@ -0,0 +1,302 @@
+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 { OrcaTeamServiceDeps } from '../orcaTeamService.js';
+
+const store = vi.hoisted(() => ({
+ archiveSingleWorkerSession: vi.fn(async () => undefined),
+ getRemoteWorkerByProxySession: vi.fn(async () => null),
+ insertRemoteWorkerProxySession: vi.fn(async () => undefined),
+ listActiveRemoteWorkers: vi.fn(async () => []),
+ listUnreleasedEndedRemoteWorkers: vi.fn(async () => []),
+ markWorkerRemoteReleased: vi.fn(async () => undefined),
+ setWorkerLastBridgedMessageId: vi.fn(async () => undefined),
+ setWorkerRemoteExecution: vi.fn(async () => undefined),
+}));
+vi.mock('../../localDb/orcaTeamStore.js', () => store);
+
+import {
+ createOrcaRemoteWorkers,
+ invokeDeviceValue,
+ isExecutionDeviceCandidate,
+} from '../orcaRemoteWorkers.js';
+
+function device(overrides: Partial<DeviceLinkDeviceView>): DeviceLinkDeviceView {
+ return {
+ deviceId: 'mac-mini',
+ name: 'Mac mini',
+ platform: 'darwin',
+ appVersion: '1.0.0',
+ lastSeenAt: null,
+ online: true,
+ busy: false,
+ remoteControlEnabled: true,
+ controlEnabled: true,
+ isSelf: false,
+ ...overrides,
+ };
+}
+
+const ok = (result: unknown): InvokeResultPayload => ({ ok: true, result }) as InvokeResultPayload;
+const fail = (code: string, message: string): InvokeResultPayload =>
+ ({ ok: false, error: { code, message } }) as InvokeResultPayload;
+
+function setup(opts: {
+ devices?: DeviceLinkDeviceView[];
+ handle?: (deviceId: string, channel: string, args: unknown[]) => InvokeResultPayload | undefined;
+} = {}) {
+ const devices = opts.devices ?? [device({})];
+ const remoteInvoke = vi.fn(async (deviceId: string, channel: string, args: unknown[]) => {
+ const custom = opts.handle?.(deviceId, channel, args);
+ if (custom) return custom;
+ switch (channel) {
+ case 'maker:orca:remote-worker:caps':
+ return ok({ version: 1 });
+ case 'maker:orca:remote-worker:open':
+ return ok({
+ sessionId: (args[0] as { sessionId: string }).sessionId,
+ workingDir: '/Users/demo/Interviews',
+ model: 'claude-opus-5-5',
+ agentKind: 'claude-code',
+ });
+ case 'local-db:sessions:get':
+ return ok({ id: 'remote-1', status: 'active', agentKind: 'cc', workingDir: '/Users/demo/Interviews', model: 'm' });
+ case 'local-db:history:messages':
+ return ok({ items: [], terminal: null });
+ case 'maker:input:enqueue':
+ return ok({});
+ case 'maker:abort-session':
+ return ok(undefined);
+ case 'maker:orca:remote-worker:release':
+ return ok({ released: true });
+ default:
+ return fail('CHANNEL_NOT_ALLOWED', channel);
+ }
+ });
+ const workers = createOrcaRemoteWorkers({
+ remoteInvoke,
+ listDevices: async () => ({ devices }),
+ getTeamService: () => null,
+ broadcastOrcaWorkerChanged: vi.fn(),
+ readLeadTitle: async () => '访谈整理',
+ log: { info: vi.fn(), warn: vi.fn() },
+ });
+ return { workers, remoteInvoke };
+}
+
+const openInput = {
+ deviceId: 'mac-mini',
+ workerId: 'w-1',
+ teamId: 'team-1',
+ leadSessionId: 'lead-1',
+ label: 'transcriber',
+ role: 'developer',
+ agent: 'claude-code' as const,
+ permissionMode: 'auto' as const,
+ title: 'transcriber',
+};
+
+function baseDeps() {
+ return {
+ getLiveSession: vi.fn(() => null),
+ dispatchWorkerMessage: vi.fn(async () => ({ ok: true, local: true })),
+ hasPendingWorkerInput: vi.fn(async () => true),
+ archiveWorkerSession: vi.fn(async () => undefined),
+ } as unknown as OrcaTeamServiceDeps;
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+});
+
+describe('invokeDeviceValue', () => {
+ it('unwraps the tunnel result and keeps the original error code', async () => {
+ await expect(invokeDeviceValue(async () => ok(3), 'd', 'c', [])).resolves.toBe(3);
+ await expect(
+ invokeDeviceValue(async () => fail('IPC_ERROR', '[NOT_FOUND] gone'), 'd', 'c', []),
+ ).rejects.toThrow(/^\[NOT_FOUND\]/);
+ await expect(
+ invokeDeviceValue(async () => fail('DEVICE_OFFLINE', 'offline'), 'd', 'c', []),
+ ).rejects.toThrow(/^\[DEVICE_OFFLINE\]/);
+ });
+
+ it('marks link errors that hit an in-flight request', async () => {
+ const lost = Object.assign(new DeviceLinkError('INVOKE_TIMEOUT' as never, 'lost'), {
+ inFlight: true,
+ });
+ await expect(
+ invokeDeviceValue(async () => Promise.reject(lost), 'd', 'c', []),
+ ).rejects.toMatchObject({ message: '[INVOKE_TIMEOUT] lost', inFlight: true });
+ });
+});
+
+describe('execution devices', () => {
+ it('only offers other online desktops that allow remote control', () => {
+ expect(isExecutionDeviceCandidate(device({}))).toBe(true);
+ expect(isExecutionDeviceCandidate(device({ online: false }))).toBe(false);
+ expect(isExecutionDeviceCandidate(device({ remoteControlEnabled: false }))).toBe(false);
+ expect(isExecutionDeviceCandidate(device({ controlEnabled: false }))).toBe(false);
+ expect(isExecutionDeviceCandidate(device({ isSelf: true }))).toBe(false);
+ expect(isExecutionDeviceCandidate(device({ platform: 'ios' }))).toBe(false);
+ });
+
+ it('lists outdated devices as unsupported and leaves out devices that did not answer', async () => {
+ const { workers } = setup({
+ devices: [
+ device({}),
+ device({ deviceId: 'old-pc', name: 'Old PC', platform: 'win32' }),
+ device({ deviceId: 'flaky', name: 'Flaky' }),
+ ],
+ handle: (deviceId, channel) =>
+ channel !== 'maker:orca:remote-worker:caps'
+ ? undefined
+ : deviceId === 'old-pc'
+ ? fail('CHANNEL_NOT_ALLOWED', channel)
+ : deviceId === 'flaky'
+ ? fail('DEVICE_OFFLINE', 'offline')
+ : undefined,
+ });
+ await expect(workers.listExecutionDevices()).resolves.toEqual([
+ { deviceId: 'mac-mini', name: 'Mac mini', platform: 'darwin', supported: true },
+ { deviceId: 'old-pc', name: 'Old PC', platform: 'win32', supported: false },
+ ]);
+ });
+});
+
+describe('openRemoteWorker', () => {
+ it('opens the task on the device and writes a local proxy row without a directory', async () => {
+ const { workers, remoteInvoke } = setup();
+ const result = await workers.openRemoteWorker({ ...openInput, workingDir: '/Users/demo/Interviews' });
+ expect(result).toMatchObject({
+ ok: true,
+ agent: 'claude-code',
+ model: 'claude-opus-5-5',
+ workingDir: '/Users/demo/Interviews',
+ });
+ const open = remoteInvoke.mock.calls.find(([, channel]) => channel === 'maker:orca:remote-worker:open');
+ expect(open?.[2][0]).toMatchObject({
+ agentKind: 'claude-code',
+ permissionMode: 'auto',
+ workingDir: '/Users/demo/Interviews',
+ lead: { leadSessionId: 'lead-1', leadTitle: '访谈整理', workerLabel: 'transcriber' },
+ });
+ expect(store.insertRemoteWorkerProxySession).toHaveBeenCalledWith(
+ expect.objectContaining({ model: 'claude-opus-5-5', permissionMode: 'auto' }),
+ );
+ });
+
+ it('refuses an offline device without falling back to this computer', async () => {
+ const { workers, remoteInvoke } = setup({ devices: [device({ online: false })] });
+ await expect(workers.openRemoteWorker(openInput)).resolves.toMatchObject({
+ ok: false,
+ errorCode: 'REMOTE_AGENT_DEVICE_UNREACHABLE',
+ });
+ expect(remoteInvoke).not.toHaveBeenCalled();
+ expect(store.insertRemoteWorkerProxySession).not.toHaveBeenCalled();
+ });
+
+ it('reports an outdated device as unsupported', async () => {
+ const { workers } = setup({
+ handle: (_d, channel) =>
+ channel === 'maker:orca:remote-worker:caps' ? fail('CHANNEL_NOT_ALLOWED', channel) : undefined,
+ });
+ await expect(workers.openRemoteWorker(openInput)).resolves.toMatchObject({
+ ok: false,
+ errorCode: 'UNSUPPORTED_CAPABILITY',
+ });
+ });
+
+ it('explains a rejected directory on the device', async () => {
+ const { workers } = setup({
+ handle: (_d, channel) =>
+ channel === 'maker:orca:remote-worker:open' ? fail('CHANNEL_NOT_ALLOWED', 'path guard') : undefined,
+ });
+ await expect(
+ workers.openRemoteWorker({ ...openInput, workingDir: '/nope' }),
+ ).resolves.toMatchObject({ ok: false, errorCode: 'INVALID_PARAMS', message: expect.stringContaining('/nope') });
+ });
+});
+
+describe('wrapTeamDeps', () => {
+ async function trackedWorker(setupOpts?: Parameters<typeof setup>[0]) {
+ const ctx = setup(setupOpts);
+ await ctx.workers.recordRemoteWorker({
+ workerId: 'w-1',
+ teamId: 'team-1',
+ leadSessionId: 'lead-1',
+ proxySessionId: 'proxy-1',
+ deviceId: 'mac-mini',
+ remoteSessionId: 'remote-1',
+ workingDir: '/Users/demo/Interviews',
+ });
+ return ctx;
+ }
+
+ it('leaves local workers on the existing path', async () => {
+ const { workers } = await trackedWorker();
+ const base = baseDeps();
+ const wrapped = workers.wrapTeamDeps(base);
+ await wrapped.dispatchWorkerMessage({ targetSessionId: 'local-1' } as never);
+ expect(base.dispatchWorkerMessage).toHaveBeenCalledTimes(1);
+ await expect(wrapped.hasPendingWorkerInput('local-1')).resolves.toBe(true);
+ workers.stop();
+ });
+
+ it('sends a Lead message for a remote worker to its device', async () => {
+ const { workers, remoteInvoke } = await trackedWorker();
+ const base = baseDeps();
+ const onAccepted = vi.fn(async () => undefined);
+ const result = await workers.wrapTeamDeps(base).dispatchWorkerMessage({
+ targetSessionId: 'proxy-1',
+ workerId: 'w-1',
+ message: '转写这段访谈',
+ dispatchMeta: { source: 'mcp', context: 'send_to_worker' },
+ onAccepted,
+ } as never);
+ expect(result).toMatchObject({ ok: true, mode: 'dispatched' });
+ expect(onAccepted).toHaveBeenCalledTimes(1);
+ expect(base.dispatchWorkerMessage).not.toHaveBeenCalled();
+ expect(remoteInvoke.mock.calls.some(([, channel]) => channel === 'maker:input:enqueue')).toBe(true);
+ workers.stop();
+ });
+
+ it('fails the dispatch when the device is offline instead of queueing it', async () => {
+ let offline = false;
+ const { workers } = await trackedWorker({
+ handle: () => (offline ? fail('DEVICE_OFFLINE', 'offline') : undefined),
+ });
+ offline = true;
+ const result = await workers.wrapTeamDeps(baseDeps()).dispatchWorkerMessage({
+ targetSessionId: 'proxy-1',
+ workerId: 'w-1',
+ message: 'x',
+ dispatchMeta: { source: 'mcp', context: 'send_to_worker' },
+ } as never);
+ expect(result).toMatchObject({
+ ok: false,
+ dispatchOutcome: { kind: 'host-send', accepted: false, code: 'HOST_NOT_READY' },
+ });
+ workers.stop();
+ });
+
+ it('archives a remote worker by releasing it on the device and keeping the task there', async () => {
+ const { workers, remoteInvoke } = await trackedWorker();
+ store.getRemoteWorkerByProxySession.mockResolvedValueOnce({
+ workerId: 'w-1',
+ teamId: 'team-1',
+ leadSessionId: 'lead-1',
+ proxySessionId: 'proxy-1',
+ deviceId: 'mac-mini',
+ remoteSessionId: 'remote-1',
+ lastBridgedMessageId: null,
+ } as never);
+ const base = baseDeps();
+ await workers.wrapTeamDeps(base).archiveWorkerSession('proxy-1');
+ expect(base.archiveWorkerSession).not.toHaveBeenCalled();
+ expect(store.archiveSingleWorkerSession).toHaveBeenCalledWith('proxy-1', undefined);
+ expect(remoteInvoke.mock.calls.some(([, channel]) => channel === 'maker:orca:remote-worker:release')).toBe(true);
+ expect(store.markWorkerRemoteReleased).toHaveBeenCalledWith('w-1');
+ expect(workers.runtime.isRemote('proxy-1')).toBe(false);
+ });
+});
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 bdf1dc358d..5ddcfd9137 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaTeamService.test.ts
@@ -151,6 +151,7 @@ describe('model Orca cleanup authority', () => {
cleanupPendingInteractionsForSession: vi.fn(), forgetKnownOrcaWorkerSession: vi.fn(),
markTeamEnded: vi.fn(), markWorkersStatusByTeam: vi.fn(), archiveWorkersByTeam: archive,
broadcastToAllWindows: vi.fn(), MAKER_PUSH: { ORCA_WORKER_CHANGED: 'changed' }, log: { info: vi.fn(), warn: vi.fn() },
+ orcaRemoteWorkers: { releaseEnded: vi.fn(async () => undefined) },
};
const api = compile(bindings, `${disable}\nreturn { api: {${callbacks}}, disableOrcaInternal };`);
const result = phase === 'user' ? await api.disableOrcaInternal('lead-1') : await api.api.endTeam({ leadSessionId: 'lead-1' });
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
index b172c0bb41..05cbd3f529 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
@@ -240,6 +240,132 @@ describe('SSH Codex Worker catalog', () => {
});
});
+describe('Worker running on another device (execution device)', () => {
+ const remoteDeps = (overrides: Partial<OrcaWorkerCreationDeps> = {}) => createDeps({
+ openRemoteWorker: vi.fn(async (input) => ({
+ ok: true as const,
+ proxySessionId: 'proxy-1',
+ remoteSessionId: 'remote-1',
+ agent: input.agent,
+ model: input.model ?? 'device-default-model',
+ workingDir: input.workingDir ?? '/Users/demo/Cindy/dialogues/remote-1',
+ })),
+ recordRemoteWorker: vi.fn(async () => undefined),
+ discardRemoteWorker: vi.fn(async () => undefined),
+ ...overrides,
+ });
+
+ it('creates the task on the device, records a proxy worker and skips local model admission', async () => {
+ const { deps, service } = remoteDeps();
+ const result = await service.createWorker({
+ leadSessionId: 'lead-1', role: '转写', label: 'transcribe', agent: 'claude-code',
+ executionDeviceId: 'mac-mini', workingDir: '/Users/demo/Interviews', model: 'only-on-device',
+ });
+ expect(result).toMatchObject({
+ ok: true,
+ workerSessionId: 'proxy-1',
+ resolved: { agent: 'claude-code', model: 'only-on-device', label: 'transcribe' },
+ });
+ expect(deps.openRemoteWorker).toHaveBeenCalledWith(expect.objectContaining({
+ deviceId: 'mac-mini', workerId: 'worker-1', teamId: 'team-1', leadSessionId: 'lead-1',
+ label: 'transcribe', role: '转写', agent: 'claude-code', model: 'only-on-device',
+ permissionMode: 'auto', workingDir: '/Users/demo/Interviews', title: 'Worker · 转写 · transcribe',
+ }));
+ expect(deps.addOrUpdateWorker).toHaveBeenCalledWith(expect.objectContaining({
+ id: 'worker-1', sessionId: 'proxy-1', status: 'idle',
+ }));
+ expect(deps.recordRemoteWorker).toHaveBeenCalledWith({
+ workerId: 'worker-1', teamId: 'team-1', leadSessionId: 'lead-1',
+ proxySessionId: 'proxy-1', deviceId: 'mac-mini', remoteSessionId: 'remote-1',
+ workingDir: '/Users/demo/Interviews',
+ });
+ expect(deps.getProviderRoutingContext).not.toHaveBeenCalled();
+ expect(deps.bootstrapSession).not.toHaveBeenCalled();
+ expect(deps.resolveWorkerWorkingDir).not.toHaveBeenCalled();
+ expect(deps.releaseWorkerCreationReservation).toHaveBeenCalledWith('worker-1');
+ });
+
+ it('lets the device allocate a directory when none is given and accepts Windows paths', async () => {
+ const { deps, service } = remoteDeps();
+ await service.createWorker({
+ leadSessionId: 'lead-1', role: 'dev', label: 'a', agent: 'codex', executionDeviceId: 'office',
+ });
+ expect(deps.openRemoteWorker).toHaveBeenLastCalledWith(expect.not.objectContaining({ workingDir: expect.anything() }));
+ const windows = await service.createWorker({
+ leadSessionId: 'lead-1', role: 'dev', label: 'b', agent: 'codex', executionDeviceId: 'office',
+ workingDir: 'D:\\projects\\site',
+ });
+ expect(windows.ok).toBe(true);
+ });
+
+ it.each([
+ ['relative directory', { workingDir: 'relative/dir' }],
+ ['malformed device id', { executionDeviceId: 'bad id/../' }],
+ ])('rejects a %s before reserving a slot', async (_name, patch) => {
+ const { deps, service } = remoteDeps();
+ const result = await service.createWorker({
+ leadSessionId: 'lead-1', role: 'dev', label: 'a', agent: 'codex', executionDeviceId: 'office', ...patch,
+ });
+ expect(result).toMatchObject({ ok: false, errorCode: 'INVALID_PARAMS' });
+ expect(deps.reserveWorkerCreation).not.toHaveBeenCalled();
+ expect(deps.openRemoteWorker).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ ['SSH', { remoteHostId: 'host-1' }],
+ ['remote Agent', { agentDeviceId: 'device-b' }],
+ ])('refuses to mix with a Lead on %s', async (_name, leadPatch) => {
+ const { deps, service } = remoteDeps({
+ getLeadSessionRow: vi.fn(async () => ({
+ id: 'lead-1', agentKind: 'codex' as const, workspaceKind: 'project' as const, workingDir: '/repo',
+ model: 'gpt-5.5', effort: 'medium', permissionMode: 'default', fastMode: false, providerId: 'xd',
+ remoteHostId: null, ...leadPatch,
+ })),
+ });
+ const result = await service.createWorker({
+ leadSessionId: 'lead-1', role: 'dev', label: 'a', agent: 'codex', executionDeviceId: 'office',
+ });
+ expect(result).toMatchObject({ ok: false, errorCode: 'INVALID_PARAMS' });
+ expect(deps.openRemoteWorker).not.toHaveBeenCalled();
+ });
+
+ it('passes through device errors without recording a worker', async () => {
+ const { deps, service } = remoteDeps({
+ openRemoteWorker: vi.fn(async () => ({
+ ok: false as const, errorCode: 'UNSUPPORTED_CAPABILITY' as const, message: 'Mac mini 需要更新',
+ })),
+ });
+ const result = await service.createWorker({
+ leadSessionId: 'lead-1', role: 'dev', label: 'a', agent: 'codex', executionDeviceId: 'mac-mini',
+ });
+ expect(result).toEqual({ ok: false, errorCode: 'UNSUPPORTED_CAPABILITY', message: 'Mac mini 需要更新' });
+ expect(deps.addOrUpdateWorker).not.toHaveBeenCalled();
+ expect(deps.releaseWorkerCreationReservation).toHaveBeenCalledWith('worker-1');
+ });
+
+ it('discards the device task when persisting the worker fails', async () => {
+ const { deps, service } = remoteDeps({
+ addOrUpdateWorker: vi.fn(async () => { throw new Error('disk full'); }),
+ });
+ const result = await service.createWorker({
+ leadSessionId: 'lead-1', role: 'dev', label: 'a', agent: 'codex', executionDeviceId: 'mac-mini',
+ });
+ expect(result).toMatchObject({ ok: false, errorCode: 'INTERNAL' });
+ expect(deps.discardRemoteWorker).toHaveBeenCalledWith({
+ proxySessionId: 'proxy-1', deviceId: 'mac-mini', remoteSessionId: 'remote-1',
+ });
+ expect(deps.recordRemoteWorker).not.toHaveBeenCalled();
+ });
+
+ it('reports remote workers as unsupported when the host did not wire them', async () => {
+ const { service } = createDeps();
+ const result = await service.createWorker({
+ leadSessionId: 'lead-1', role: 'dev', label: 'a', agent: 'codex', executionDeviceId: 'mac-mini',
+ });
+ expect(result).toMatchObject({ ok: false, errorCode: 'INVALID_PARAMS' });
+ });
+});
+
describe('Worker of a lead whose agent runs on another computer', () => {
const sparkModels = ['spark/qwen', 'spark/deepseek'].map((id) => ({
id, name: id, efforts: ['low', 'high'], defaultEffort: 'high', supportsFastMode: false,
diff --git a/apps/desktop/src/main/maker-ipc/orcaDiagnostics.ts b/apps/desktop/src/main/maker-ipc/orcaDiagnostics.ts
index 4703559f0d..0a85fcd9bf 100644
--- a/apps/desktop/src/main/maker-ipc/orcaDiagnostics.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaDiagnostics.ts
@@ -21,6 +21,13 @@ export interface OrcaDiagnosticWorkerSnapshot {
effort: string | null;
workingDir: string;
};
+ /** 跑在另一台电脑上的 Worker:运行设备投影;本机 Worker 无此字段。 */
+ executionDevice?: {
+ deviceId: string;
+ deviceName?: string;
+ reachable?: boolean;
+ workingDir?: string;
+ };
}
export interface OrcaDiagnosticsDeps {
@@ -68,7 +75,17 @@ async function toWorkerSummary(deps: OrcaDiagnosticsDeps, worker: OrcaDiagnostic
model: worker.session.model,
effort: worker.session.effort ?? null,
focused: worker.focused,
- working_dir: worker.session.workingDir,
+ // 远端 Worker 的本机代理行没有目录;展示运行设备上的目录。
+ working_dir: worker.executionDevice?.workingDir ?? worker.session.workingDir,
+ ...(worker.executionDevice
+ ? {
+ execution_device: {
+ device_id: worker.executionDevice.deviceId,
+ device_name: worker.executionDevice.deviceName ?? null,
+ reachable: worker.executionDevice.reachable ?? null,
+ },
+ }
+ : {}),
};
}
diff --git a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerRuntime.ts b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerRuntime.ts
new file mode 100644
index 0000000000..ef58da47aa
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkerRuntime.ts
@@ -0,0 +1,596 @@
+/**
+ * Lead 所在电脑侧:驱动在另一台电脑(运行设备)上运行的协同 Worker。
+ *
+ * 远端 Worker 在本机只有一条代理任务行(不跑 Agent),真实任务在运行设备上。本模块负责:
+ * - 派活:经 `maker:input:enqueue` 投递到运行设备的任务,按 clientId 幂等;
+ * - 轮询:每台设备一次 `maker:list-active` 得到全部远端 Worker 的运行状态,派活后加快节奏;
+ * - 回报:派出的消息已进入对话(投递回执 accepted)且运行设备不在跑时,取最后一条 assistant
+ * 消息交给现有 auto-bridge;按消息 id 去重,断线重连后自然补报,同一条只报一次;
+ * - 可达性:设备调用失败即标为不可达,恢复后自动回到在线,不判失败、不重派。
+ *
+ * 用户在运行设备上直接发的消息(插话)不会触发回报:只有本机派出、仍在等待回报的消息才会。
+ */
+import {
+ DL_HISTORY_MESSAGES_CHANNEL,
+ ORCA_REMOTE_WORKER_RELEASE_CHANNEL,
+} from '@cindy/device-link';
+import { formatAgentMessage, formatOrcaCommunicationMessage } from '@cindy/orca-workflow';
+
+import type {
+ AgentInputCreateOpts,
+ AgentInputQueuedMessage,
+} from '../../shared/agentInputQueue.js';
+
+export interface RemoteWorkerRef {
+ workerId: string;
+ teamId: string;
+ leadSessionId: string;
+ /** 本机代理任务行 id;Orca 状态机、auto-bridge 都以它为键。 */
+ proxySessionId: string;
+ deviceId: string;
+ /** 运行设备上的真实任务 id。 */
+ remoteSessionId: string;
+ lastBridgedMessageId: string | null;
+}
+
+export interface RemoteWorkerTurnEnd {
+ status: 'done' | 'error';
+ finalText: string;
+ diagnostic?: string;
+}
+
+export type RemoteWorkerDispatchResult =
+ | { ok: true; mode: 'dispatched' | 'queued' }
+ | {
+ ok: false;
+ code: 'DEVICE_UNREACHABLE' | 'SESSION_NOT_FOUND' | 'SEND_FAILED';
+ message: string;
+ };
+
+export interface OrcaRemoteWorkerRuntimeDeps {
+ /** 调用运行设备的 channel;失败抛出 Error(message 形如 `[CODE] ...`)。 */
+ invoke(deviceId: string, channel: string, args: unknown[]): Promise<unknown>;
+ deviceName(deviceId: string): string;
+ saveLastBridgedMessageId(workerId: string, messageId: string): Promise<void>;
+ onTurnStarted(proxySessionId: string): Promise<void>;
+ onTurnEnded(proxySessionId: string, turn: RemoteWorkerTurnEnd): Promise<void>;
+ /** 可达性或运行状态变化,供协同面板刷新。 */
+ onWorkerStateChanged(leadSessionId: string): void;
+ now(): number;
+ setTimeout(fn: () => void, ms: number): unknown;
+ clearTimeout(handle: unknown): void;
+ log: {
+ info(message: string, fields?: Record<string, unknown>): void;
+ warn(message: string, fields?: Record<string, unknown>): void;
+ };
+}
+
+/** 派活后的轮询间隔;没有待回报时只做低频的可达性刷新。 */
+export const REMOTE_WORKER_FAST_POLL_MS = 2_000;
+export const REMOTE_WORKER_IDLE_POLL_MS = 15_000;
+/** 消息已进入对话、设备不在跑,但还没有新回复时,最多再等这么多轮才按异常收尾。 */
+const MISSING_REPLY_POLLS = 15;
+const MAX_REPORT_CHARS = 8_192;
+
+/** 视为「设备当前不可达」的错误码:relay / 链路 / 本机开关 / 熔断。其余错误按普通失败处理。 */
+const UNREACHABLE_CODES = new Set([
+ 'DEVICE_OFFLINE',
+ 'REMOTE_DISABLED',
+ 'ACCESS_REVOKED',
+ 'INVOKE_TIMEOUT',
+ 'LINK_NOT_OPEN',
+ 'NOT_CONNECTED',
+ 'DEVICE_LINK_NOT_CONNECTED',
+ 'DEVICE_LINK_CONTROL_DISABLED',
+ 'DEVICE_LINK_STANDBY',
+ 'DEVICE_UNRESPONSIVE',
+]);
+
+interface AwaitingReport {
+ clientIds: string[];
+ baselineMessageId: string | null;
+ startedNotified: boolean;
+ missingReplyPolls: number;
+}
+
+interface WorkerState {
+ ref: RemoteWorkerRef;
+ inTurn: boolean;
+ awaiting: AwaitingReport | null;
+ /** 运行设备上的工作目录(只做展示);重启后首次轮询时补读。 */
+ workingDir: string | null;
+}
+
+function errorCode(err: unknown): string | null {
+ const message = err instanceof Error ? err.message : String(err);
+ const match = /^\[([A-Z_]+)\]/.exec(message);
+ if (match) return match[1] ?? null;
+ const code = (err as { code?: unknown } | null)?.code;
+ return typeof code === 'string' ? code : null;
+}
+
+function errorMessage(err: unknown): string {
+ return err instanceof Error ? err.message : String(err);
+}
+
+function textOf(content: unknown): string {
+ if (typeof content === 'string') return content;
+ if (Array.isArray(content)) {
+ return content
+ .map((block) =>
+ typeof block === 'string'
+ ? block
+ : block &&
+ typeof block === 'object' &&
+ typeof (block as { text?: unknown }).text === 'string'
+ ? (block as { text: string }).text
+ : '',
+ )
+ .filter(Boolean)
+ .join('\n');
+ }
+ if (
+ content &&
+ typeof content === 'object' &&
+ typeof (content as { text?: unknown }).text === 'string'
+ ) {
+ return (content as { text: string }).text;
+ }
+ return '';
+}
+
+function agentKindOf(value: unknown): AgentInputCreateOpts['agentKind'] {
+ return value === 'codex' || value === 'pi' ? value : 'claude-code';
+}
+
+interface RemoteSessionRow {
+ agentKind?: unknown;
+ workingDir?: unknown;
+ model?: unknown;
+ providerId?: unknown;
+ effort?: unknown;
+ permissionMode?: unknown;
+ fastMode?: unknown;
+ planModeEnabled?: unknown;
+ sdkSessionId?: unknown;
+}
+
+/** 远端任务的建会话参数取自运行设备的任务记录;本机不知道它的原生会话 id 等运行态。 */
+function createOptsFromRow(row: RemoteSessionRow): AgentInputCreateOpts {
+ const str = (value: unknown) => (typeof value === 'string' && value ? value : undefined);
+ return {
+ agentKind: agentKindOf(row.agentKind === 'cc' ? 'claude-code' : row.agentKind),
+ workingDir: str(row.workingDir) ?? '',
+ model: str(row.model) ?? '',
+ ...(str(row.providerId) ? { providerId: str(row.providerId) } : {}),
+ ...(str(row.effort) ? { effort: str(row.effort) } : {}),
+ ...(typeof row.fastMode === 'boolean' ? { fastMode: row.fastMode } : {}),
+ ...(str(row.permissionMode) ? { permissionMode: str(row.permissionMode) } : {}),
+ ...(typeof row.planModeEnabled === 'boolean' ? { planMode: row.planModeEnabled } : {}),
+ ...(str(row.sdkSessionId) ? { resumeSessionId: str(row.sdkSessionId) } : {}),
+ };
+}
+
+/** 远端没有 Orca Worker 桥:只带来源标签,不附 worker_id 工具提示。 */
+export function buildRemoteWorkerQueuedMessage(params: {
+ clientId: string;
+ rawContent: string;
+ createOpts: AgentInputCreateOpts;
+ createdAt: string;
+}): AgentInputQueuedMessage {
+ const persistedContent = formatOrcaCommunicationMessage('lead', params.rawContent);
+ return {
+ clientId: params.clientId,
+ durableDelivery: true,
+ text: formatAgentMessage('lead', params.rawContent),
+ persistedContent,
+ model: params.createOpts.model,
+ effort: params.createOpts.effort ?? '',
+ permissionMode: params.createOpts.permissionMode ?? 'auto',
+ workingDir: params.createOpts.workingDir,
+ chatMessage: {
+ clientId: params.clientId,
+ role: 'user',
+ content: persistedContent,
+ createdAt: params.createdAt,
+ },
+ createOpts: params.createOpts,
+ origin: { kind: 'orca', senderLabel: 'Lead', displayText: params.rawContent },
+ };
+}
+
+export function createOrcaRemoteWorkerRuntime(deps: OrcaRemoteWorkerRuntimeDeps) {
+ const workers = new Map<string, WorkerState>();
+ const unreachableDevices = new Set<string>();
+ let timer: unknown = null;
+ let polling = false;
+ let stopped = false;
+
+ function deviceUnreachable(err: unknown): boolean {
+ const code = errorCode(err);
+ return code !== null && UNREACHABLE_CODES.has(code);
+ }
+
+ function leadsOnDevice(deviceId: string): string[] {
+ return [
+ ...new Set(
+ [...workers.values()]
+ .filter((state) => state.ref.deviceId === deviceId)
+ .map((state) => state.ref.leadSessionId),
+ ),
+ ];
+ }
+
+ function setReachable(deviceId: string, reachable: boolean): void {
+ const changed = reachable
+ ? unreachableDevices.delete(deviceId)
+ : !unreachableDevices.has(deviceId);
+ if (!reachable) unreachableDevices.add(deviceId);
+ if (changed) {
+ deps.log.info('orca remote worker device reachability changed', { deviceId, reachable });
+ for (const lead of leadsOnDevice(deviceId)) deps.onWorkerStateChanged(lead);
+ }
+ }
+
+ function schedule(): void {
+ if (stopped) return;
+ if (timer !== null) deps.clearTimeout(timer);
+ timer = null;
+ if (workers.size === 0) return;
+ const fast = [...workers.values()].some((state) => state.awaiting !== null);
+ timer = deps.setTimeout(
+ () => {
+ timer = null;
+ void pollOnce().finally(schedule);
+ },
+ fast ? REMOTE_WORKER_FAST_POLL_MS : REMOTE_WORKER_IDLE_POLL_MS,
+ );
+ }
+
+ async function lastAssistantMessage(ref: RemoteWorkerRef): Promise<{
+ id: string | null;
+ text: string;
+ terminalError: boolean;
+ }> {
+ const page = (await deps.invoke(ref.deviceId, DL_HISTORY_MESSAGES_CHANNEL, [
+ {
+ sessionId: ref.remoteSessionId,
+ workdir: null,
+ fromMs: null,
+ toMs: null,
+ agentKind: null,
+ roles: ['assistant'],
+ includeRewound: false,
+ limit: 1,
+ cursor: null,
+ order: 'desc',
+ contentCharLimit: MAX_REPORT_CHARS,
+ },
+ ])) as {
+ items?: Array<{ id?: unknown; content?: unknown }>;
+ terminal?: { status?: unknown } | null;
+ };
+ const item = Array.isArray(page?.items) ? page.items[0] : undefined;
+ return {
+ id: typeof item?.id === 'string' ? item.id : null,
+ text: textOf(item?.content).slice(-MAX_REPORT_CHARS),
+ terminalError: page?.terminal?.status === 'error',
+ };
+ }
+
+ async function deliveryStates(ref: RemoteWorkerRef, clientIds: string[]): Promise<string[]> {
+ const projection = (await deps.invoke(ref.deviceId, 'maker:input:get-projection', [
+ ref.remoteSessionId,
+ { deliveryClientIds: clientIds },
+ ])) as { deliveryReceipts?: Array<{ clientId?: unknown; state?: unknown }> };
+ const receipts = Array.isArray(projection?.deliveryReceipts) ? projection.deliveryReceipts : [];
+ return clientIds.map((id) => {
+ const receipt = receipts.find((entry) => entry.clientId === id);
+ return typeof receipt?.state === 'string' ? receipt.state : 'unknown';
+ });
+ }
+
+ async function finishTurn(
+ state: WorkerState,
+ turn: RemoteWorkerTurnEnd,
+ messageId: string | null,
+ ) {
+ state.awaiting = null;
+ state.inTurn = false;
+ if (messageId) {
+ state.ref = { ...state.ref, lastBridgedMessageId: messageId };
+ await deps.saveLastBridgedMessageId(state.ref.workerId, messageId).catch((err) =>
+ deps.log.warn('orca remote worker: persist bridged message id failed', {
+ workerId: state.ref.workerId,
+ err: errorMessage(err),
+ }),
+ );
+ }
+ await deps.onTurnEnded(state.ref.proxySessionId, turn);
+ deps.onWorkerStateChanged(state.ref.leadSessionId);
+ }
+
+ async function checkAwaiting(state: WorkerState, running: boolean): Promise<void> {
+ const awaiting = state.awaiting;
+ if (!awaiting) return;
+ if (running) {
+ if (!awaiting.startedNotified) {
+ awaiting.startedNotified = true;
+ await deps.onTurnStarted(state.ref.proxySessionId);
+ }
+ return;
+ }
+ const states = await deliveryStates(state.ref, awaiting.clientIds);
+ // 仍在运行设备的队列里(排在用户插话之后等),继续等。
+ if (states.some((value) => value === 'pending' || value === 'unknown')) return;
+ if (states.every((value) => value === 'removed')) {
+ await finishTurn(
+ state,
+ {
+ status: 'error',
+ finalText: '',
+ diagnostic: `派给 ${deps.deviceName(state.ref.deviceId)} 的消息在那台电脑上被撤回,Worker 没有执行。`,
+ },
+ null,
+ );
+ return;
+ }
+ const last = await lastAssistantMessage(state.ref);
+ if (
+ last.id &&
+ last.id !== awaiting.baselineMessageId &&
+ last.id !== state.ref.lastBridgedMessageId
+ ) {
+ await finishTurn(
+ state,
+ { status: last.terminalError ? 'error' : 'done', finalText: last.text },
+ last.id,
+ );
+ return;
+ }
+ awaiting.missingReplyPolls += 1;
+ if (last.terminalError || awaiting.missingReplyPolls >= MISSING_REPLY_POLLS) {
+ await finishTurn(
+ state,
+ {
+ status: 'error',
+ finalText: '',
+ diagnostic: last.terminalError
+ ? `Worker 在 ${deps.deviceName(state.ref.deviceId)} 上异常结束,没有产生回复。`
+ : `Worker 在 ${deps.deviceName(state.ref.deviceId)} 上本轮结束,但没有产生回复。`,
+ },
+ null,
+ );
+ }
+ }
+
+ async function pollDevice(deviceId: string, states: WorkerState[]): Promise<void> {
+ let active: Map<string, boolean>;
+ try {
+ const result = (await deps.invoke(deviceId, 'maker:list-active', [
+ { summary: true, snapshotVersion: 2 },
+ ])) as { sessions?: Array<{ sessionId?: unknown; isTurnRunning?: unknown }> };
+ active = new Map(
+ (Array.isArray(result?.sessions) ? result.sessions : [])
+ .filter((entry) => typeof entry.sessionId === 'string')
+ .map((entry) => [entry.sessionId as string, entry.isTurnRunning === true]),
+ );
+ setReachable(deviceId, true);
+ } catch (err) {
+ if (deviceUnreachable(err)) setReachable(deviceId, false);
+ deps.log.warn('orca remote worker: poll failed', { deviceId, err: errorMessage(err) });
+ return;
+ }
+ for (const state of states) {
+ if (state.workingDir === null) await readWorkingDir(state);
+ const running = active.get(state.ref.remoteSessionId) === true;
+ const changed = running !== state.inTurn;
+ state.inTurn = running;
+ try {
+ await checkAwaiting(state, running);
+ } catch (err) {
+ if (deviceUnreachable(err)) setReachable(deviceId, false);
+ deps.log.warn('orca remote worker: report check failed', {
+ workerId: state.ref.workerId,
+ err: errorMessage(err),
+ });
+ }
+ if (changed) deps.onWorkerStateChanged(state.ref.leadSessionId);
+ }
+ }
+
+ async function readWorkingDir(state: WorkerState): Promise<void> {
+ try {
+ const row = (await deps.invoke(state.ref.deviceId, 'local-db:sessions:get', [
+ state.ref.remoteSessionId,
+ ])) as RemoteSessionRow | null;
+ if (typeof row?.workingDir === 'string' && row.workingDir) {
+ state.workingDir = row.workingDir;
+ deps.onWorkerStateChanged(state.ref.leadSessionId);
+ }
+ } catch {
+ // 只影响展示,下一轮再试。
+ }
+ }
+
+ async function pollOnce(): Promise<void> {
+ if (polling) return;
+ polling = true;
+ try {
+ const byDevice = new Map<string, WorkerState[]>();
+ for (const state of workers.values()) {
+ byDevice.set(state.ref.deviceId, [...(byDevice.get(state.ref.deviceId) ?? []), state]);
+ }
+ await Promise.all([...byDevice].map(([deviceId, states]) => pollDevice(deviceId, states)));
+ } finally {
+ polling = false;
+ }
+ }
+
+ return {
+ track(ref: RemoteWorkerRef, opts: { workingDir?: string } = {}): void {
+ const existing = workers.get(ref.proxySessionId);
+ const workingDir = opts.workingDir || existing?.workingDir || null;
+ workers.set(
+ ref.proxySessionId,
+ existing
+ ? { ...existing, ref, workingDir }
+ : { ref, inTurn: false, awaiting: null, workingDir },
+ );
+ if (timer === null) schedule();
+ },
+
+ untrack(proxySessionId: string): void {
+ workers.delete(proxySessionId);
+ if (workers.size === 0) schedule();
+ },
+
+ isRemote(proxySessionId: string): boolean {
+ return workers.has(proxySessionId);
+ },
+
+ get(proxySessionId: string): RemoteWorkerRef | null {
+ return workers.get(proxySessionId)?.ref ?? null;
+ },
+
+ isTurnRunning(proxySessionId: string): boolean {
+ return workers.get(proxySessionId)?.inTurn ?? false;
+ },
+
+ hasPendingReport(proxySessionId: string): boolean {
+ return workers.get(proxySessionId)?.awaiting != null;
+ },
+
+ workingDir(proxySessionId: string): string | null {
+ return workers.get(proxySessionId)?.workingDir ?? null;
+ },
+
+ isReachable(proxySessionId: string): boolean {
+ const state = workers.get(proxySessionId);
+ return state ? !unreachableDevices.has(state.ref.deviceId) : true;
+ },
+
+ async dispatch(params: {
+ proxySessionId: string;
+ rawContent: string;
+ clientId: string;
+ }): Promise<RemoteWorkerDispatchResult> {
+ const state = workers.get(params.proxySessionId);
+ if (!state)
+ return { ok: false, code: 'SESSION_NOT_FOUND', message: 'remote worker is not tracked' };
+ const { ref } = state;
+ const deviceName = deps.deviceName(ref.deviceId);
+ try {
+ const row = (await deps.invoke(ref.deviceId, 'local-db:sessions:get', [
+ ref.remoteSessionId,
+ ])) as (RemoteSessionRow & { status?: unknown }) | null;
+ if (typeof row?.workingDir === 'string' && row.workingDir) state.workingDir = row.workingDir;
+ if (!row || (row.status !== undefined && row.status !== 'active')) {
+ return {
+ ok: false,
+ code: 'SESSION_NOT_FOUND',
+ message: `Worker 在 ${deviceName} 上的任务已不存在或已归档,消息没有发出。`,
+ };
+ }
+ const baseline = state.awaiting?.baselineMessageId ?? (await lastAssistantMessage(ref)).id;
+ const item = buildRemoteWorkerQueuedMessage({
+ clientId: params.clientId,
+ rawContent: params.rawContent,
+ createOpts: createOptsFromRow(row),
+ createdAt: new Date(deps.now()).toISOString(),
+ });
+ const accept = (): RemoteWorkerDispatchResult => {
+ setReachable(ref.deviceId, true);
+ const mode = state.inTurn ? 'queued' : 'dispatched';
+ state.awaiting = {
+ clientIds: [...(state.awaiting?.clientIds ?? []), params.clientId].slice(-64),
+ baselineMessageId: baseline,
+ startedNotified: state.awaiting?.startedNotified ?? false,
+ missingReplyPolls: 0,
+ };
+ schedule();
+ return { ok: true, mode };
+ };
+ try {
+ await deps.invoke(ref.deviceId, 'maker:input:enqueue', [ref.remoteSessionId, item]);
+ } catch (err) {
+ // 请求可能已送达、只是回执丢了:按 clientId 查一次投递回执,已在队列或对话里就算送达,
+ // 不重发(enqueue 按 clientId 幂等,但这里不做盲重试)。查不到再按失败处理。
+ if (
+ errorCode(err) === 'INVOKE_TIMEOUT' ||
+ (err as { inFlight?: unknown })?.inFlight === true
+ ) {
+ const [delivered] = await deliveryStates(ref, [params.clientId]).catch(() => [
+ 'unknown',
+ ]);
+ if (delivered === 'pending' || delivered === 'accepted') return accept();
+ }
+ throw err;
+ }
+ return accept();
+ } catch (err) {
+ if (deviceUnreachable(err)) {
+ setReachable(ref.deviceId, false);
+ return {
+ ok: false,
+ code: 'DEVICE_UNREACHABLE',
+ message: `${deviceName} 当前不可达(离线或已关闭远程控制),消息没有发出。`,
+ };
+ }
+ if (errorCode(err) === 'NOT_FOUND') {
+ return {
+ ok: false,
+ code: 'SESSION_NOT_FOUND',
+ message: `Worker 在 ${deviceName} 上的任务已不存在,消息没有发出。`,
+ };
+ }
+ return { ok: false, code: 'SEND_FAILED', message: errorMessage(err) };
+ }
+ },
+
+ /** 停止运行设备上的当前一轮;任务与记录保留。 */
+ async abort(proxySessionId: string): Promise<boolean> {
+ const state = workers.get(proxySessionId);
+ if (!state) return false;
+ try {
+ await deps.invoke(state.ref.deviceId, 'maker:abort-session', [state.ref.remoteSessionId]);
+ return true;
+ } catch (err) {
+ if (deviceUnreachable(err)) setReachable(state.ref.deviceId, false);
+ deps.log.warn('orca remote worker: abort failed', {
+ proxySessionId,
+ err: errorMessage(err),
+ });
+ return false;
+ }
+ },
+
+ /** 通知运行设备结束协同(任务与文件保留)。设备不可达时返回 false,由调用方留待重试。 */
+ async release(ref: Pick<RemoteWorkerRef, 'deviceId' | 'remoteSessionId'>): Promise<boolean> {
+ try {
+ await deps.invoke(ref.deviceId, ORCA_REMOTE_WORKER_RELEASE_CHANNEL, [
+ { sessionId: ref.remoteSessionId },
+ ]);
+ return true;
+ } catch (err) {
+ if (errorCode(err) === 'NOT_FOUND') return true;
+ deps.log.warn('orca remote worker: release failed', {
+ deviceId: ref.deviceId,
+ err: errorMessage(err),
+ });
+ return false;
+ }
+ },
+
+ /** 测试与关闭时用:立即跑一轮。 */
+ pollNow: pollOnce,
+
+ stop(): void {
+ stopped = true;
+ if (timer !== null) deps.clearTimeout(timer);
+ timer = null;
+ },
+ };
+}
+
+export type OrcaRemoteWorkerRuntime = ReturnType<typeof createOrcaRemoteWorkerRuntime>;
diff --git a/apps/desktop/src/main/maker-ipc/orcaRemoteWorkers.ts b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkers.ts
new file mode 100644
index 0000000000..9e255efbb9
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/orcaRemoteWorkers.ts
@@ -0,0 +1,519 @@
+/**
+ * Lead 所在电脑:协同远端 Worker 的宿主装配。
+ *
+ * - 可选运行设备:同账号、在线、对方开启远程控制、本机允许控制的桌面电脑;逐台探测能力,
+ * 旧版本标为需要更新(只读,控制端也经 `maker:orca:execution-devices` 读同一份);
+ * - 创建:在运行设备上 open 任务,本机写一条不跑 Agent 的代理任务行,登记到运行时轮询;
+ * - 运行:把 OrcaTeamService 的会话依赖按「是否远端 Worker」分流——派活、停止、存活查询
+ * 走运行设备,其余(计槽、回报、状态机)沿用现有实现;
+ * - 结束:归档或结束团队时通知运行设备 release,失败的留待重连后补发。
+ */
+import { createId } from '@paralleldrive/cuid2';
+import {
+ DeviceLinkError,
+ ORCA_REMOTE_WORKER_CAPS_CHANNEL,
+ ORCA_REMOTE_WORKER_OPEN_CHANNEL,
+ type InvokeResultPayload,
+ type OrcaExecutionDeviceView,
+ type OrcaRemoteWorkerOpenResult as DeviceOpenResult,
+} from '@cindy/device-link';
+import { isMobilePlatform } from '@cindy/maker-shared/device-list';
+import type { AgentKind } from '@cindy/maker-core';
+
+import type { DeviceLinkDeviceView } from '../../shared/deviceLinkIpc.js';
+import {
+ archiveSingleWorkerSession,
+ getRemoteWorkerByProxySession,
+ insertRemoteWorkerProxySession,
+ listActiveRemoteWorkers,
+ listUnreleasedEndedRemoteWorkers,
+ markWorkerRemoteReleased,
+ setWorkerLastBridgedMessageId,
+ setWorkerRemoteExecution,
+} from '../localDb/orcaTeamStore.js';
+import { createHostSendFailure } from '../maker-host/send-outcome.js';
+import type {
+ OrcaRemoteWorkerOpenResult,
+ OrcaWorkerCreationDeps,
+} from './orcaWorkerCreationService.js';
+import {
+ createOrcaRemoteWorkerRuntime,
+ type OrcaRemoteWorkerRuntime,
+ type RemoteWorkerTurnEnd,
+} from './orcaRemoteWorkerRuntime.js';
+import type { OrcaTeamService, OrcaTeamServiceDeps } from './orcaTeamService.js';
+
+const CAPS_PROBE_TIMEOUT_MS = 5_000;
+const RELEASE_RETRY_MS = 5 * 60_000;
+const EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+
+export interface OrcaRemoteWorkersDeps {
+ remoteInvoke(deviceId: string, channel: string, args: unknown[]): Promise<InvokeResultPayload>;
+ listDevices(): Promise<{ devices: DeviceLinkDeviceView[] }>;
+ /** 事件回调需要的团队服务;创建顺序上晚于本模块,按需取。 */
+ getTeamService(): OrcaTeamService | null;
+ broadcastOrcaWorkerChanged(leadSessionId: string): void;
+ readLeadTitle(leadSessionId: string): Promise<string>;
+ log: {
+ info(message: string, fields?: Record<string, unknown>): void;
+ warn(message: string, fields?: Record<string, unknown>): void;
+ };
+}
+
+/** 把隧道结果统一成「成功返回值 / 抛出带 `[CODE]` 的错误」,保留 inFlight 标记。 */
+export async function invokeDeviceValue(
+ remoteInvoke: OrcaRemoteWorkersDeps['remoteInvoke'],
+ deviceId: string,
+ channel: string,
+ args: unknown[],
+): Promise<unknown> {
+ let result: InvokeResultPayload;
+ try {
+ result = await remoteInvoke(deviceId, channel, args);
+ } catch (err) {
+ if (err instanceof DeviceLinkError) {
+ throw Object.assign(new Error(`[${err.code}] ${err.message}`), {
+ inFlight: err.inFlight === true,
+ });
+ }
+ throw err;
+ }
+ if (result.ok) return result.result;
+ const code =
+ result.error.code === 'IPC_ERROR'
+ ? (/^\[([A-Z_]+)\]/.exec(result.error.message)?.[1] ?? 'IPC_ERROR')
+ : result.error.code;
+ throw new Error(`[${code}] ${result.error.message}`);
+}
+
+function codeOf(err: unknown): string | null {
+ const message = err instanceof Error ? err.message : String(err);
+ return /^\[([A-Z_]+)\]/.exec(message)?.[1] ?? null;
+}
+
+export function isExecutionDeviceCandidate(device: DeviceLinkDeviceView): boolean {
+ return (
+ device.online &&
+ device.remoteControlEnabled &&
+ device.controlEnabled &&
+ !device.isSelf &&
+ !isMobilePlatform(device.platform)
+ );
+}
+
+export function createOrcaRemoteWorkers(deps: OrcaRemoteWorkersDeps) {
+ const deviceNames = new Map<string, string>();
+ let releaseRetryTimer: ReturnType<typeof setInterval> | null = null;
+ const invoke = (deviceId: string, channel: string, args: unknown[]) =>
+ invokeDeviceValue(deps.remoteInvoke, deviceId, channel, args);
+ const nameOf = (deviceId: string) => deviceNames.get(deviceId) || '另一台电脑';
+
+ const runtime: OrcaRemoteWorkerRuntime = createOrcaRemoteWorkerRuntime({
+ invoke,
+ deviceName: nameOf,
+ saveLastBridgedMessageId: setWorkerLastBridgedMessageId,
+ onTurnStarted: async (proxySessionId) => {
+ await deps.getTeamService()?.handleWorkerTurnStarted(proxySessionId);
+ },
+ onTurnEnded: async (proxySessionId, turn: RemoteWorkerTurnEnd) => {
+ const service = deps.getTeamService();
+ if (!service) return;
+ if (turn.finalText)
+ service.captureWorkerText(proxySessionId, turn.finalText, { isFinal: true });
+ await service.handleWorkerTerminalTurn({
+ sessionId: proxySessionId,
+ status: turn.status,
+ finalText: turn.finalText,
+ ...(turn.diagnostic ? { diagnostic: turn.diagnostic } : {}),
+ });
+ },
+ onWorkerStateChanged: deps.broadcastOrcaWorkerChanged,
+ now: Date.now,
+ setTimeout: (fn, ms) => {
+ const handle = setTimeout(fn, ms);
+ handle.unref?.();
+ return handle;
+ },
+ clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+ log: deps.log,
+ });
+
+ async function refreshDeviceNames(): Promise<DeviceLinkDeviceView[]> {
+ const { devices } = await deps.listDevices();
+ for (const device of devices) if (device.name) deviceNames.set(device.deviceId, device.name);
+ return devices;
+ }
+
+ async function probeSupported(deviceId: string): Promise<boolean | null> {
+ try {
+ await Promise.race([
+ invoke(deviceId, ORCA_REMOTE_WORKER_CAPS_CHANNEL, []),
+ new Promise((_, reject) =>
+ setTimeout(
+ () => reject(new Error('[INVOKE_TIMEOUT] caps probe timed out')),
+ CAPS_PROBE_TIMEOUT_MS,
+ ).unref?.(),
+ ),
+ ]);
+ return true;
+ } catch (err) {
+ return codeOf(err) === 'CHANNEL_NOT_ALLOWED' ? false : null;
+ }
+ }
+
+ async function releaseAndMark(row: {
+ workerId: string;
+ deviceId: string;
+ remoteSessionId: string;
+ }) {
+ if (await runtime.release(row))
+ await markWorkerRemoteReleased(row.workerId).catch(() => undefined);
+ }
+
+ async function retryPendingReleases(): Promise<void> {
+ const rows = await listUnreleasedEndedRemoteWorkers().catch(() => []);
+ await Promise.all(rows.map(releaseAndMark));
+ }
+
+ return {
+ runtime,
+
+ /** 启动时恢复仍在协同中的远端 Worker,并补发未送达的结束通知。 */
+ async start(): Promise<void> {
+ await refreshDeviceNames().catch(() => undefined);
+ for (const row of await listActiveRemoteWorkers()) runtime.track(row);
+ void retryPendingReleases();
+ // 结束通知在运行设备离线时发不出去;低频补发,送达即记账,不重复。
+ releaseRetryTimer = setInterval(() => void retryPendingReleases(), RELEASE_RETRY_MS);
+ releaseRetryTimer.unref?.();
+ },
+
+ stop(): void {
+ runtime.stop();
+ if (releaseRetryTimer) clearInterval(releaseRetryTimer);
+ releaseRetryTimer = null;
+ },
+
+ deviceName: nameOf,
+
+ async listExecutionDevices(): Promise<OrcaExecutionDeviceView[]> {
+ const devices = (await refreshDeviceNames()).filter(isExecutionDeviceCandidate);
+ const supported = await Promise.all(devices.map((device) => probeSupported(device.deviceId)));
+ // 探测失败(超时等)视为暂时不可用,不列出;明确不支持的列为需要更新。
+ return devices.flatMap((device, index) =>
+ supported[index] === null
+ ? []
+ : [
+ {
+ deviceId: device.deviceId,
+ name: device.name,
+ platform: device.platform,
+ supported: supported[index] === true,
+ },
+ ],
+ );
+ },
+
+ async openRemoteWorker(
+ input: Parameters<NonNullable<OrcaWorkerCreationDeps['openRemoteWorker']>>[0],
+ ): Promise<OrcaRemoteWorkerOpenResult> {
+ const devices = await refreshDeviceNames().catch(() => null);
+ const device = devices?.find((item) => item.deviceId === input.deviceId);
+ if (devices && (!device || !isExecutionDeviceCandidate(device))) {
+ return {
+ ok: false,
+ errorCode: 'REMOTE_AGENT_DEVICE_UNREACHABLE',
+ message: `${device?.name ?? '指定的电脑'} 当前不可用:需要在线,且已开启「允许远程控制」。`,
+ };
+ }
+ const name = nameOf(input.deviceId);
+ const supported = await probeSupported(input.deviceId);
+ if (supported === false) {
+ return {
+ ok: false,
+ errorCode: 'UNSUPPORTED_CAPABILITY',
+ message: `${name} 的 Cindy 版本过旧,需要更新后才能运行协同 Worker。`,
+ };
+ }
+ if (supported === null) {
+ return {
+ ok: false,
+ errorCode: 'REMOTE_AGENT_DEVICE_UNREACHABLE',
+ message: `${name} 当前不可达,Worker 没有创建。`,
+ };
+ }
+ const remoteSessionId = createId();
+ let opened: DeviceOpenResult;
+ try {
+ opened = (await invoke(input.deviceId, ORCA_REMOTE_WORKER_OPEN_CHANNEL, [
+ {
+ sessionId: remoteSessionId,
+ agentKind: input.agent,
+ ...(input.model ? { model: input.model } : {}),
+ ...(input.providerId ? { providerId: input.providerId } : {}),
+ ...(input.effort ? { effort: input.effort } : {}),
+ ...(input.fast !== undefined ? { fastMode: input.fast } : {}),
+ permissionMode: input.permissionMode,
+ ...(input.workingDir ? { workingDir: input.workingDir } : {}),
+ title: input.title,
+ lead: {
+ leadSessionId: input.leadSessionId,
+ leadTitle: await deps.readLeadTitle(input.leadSessionId).catch(() => ''),
+ workerLabel: input.label,
+ },
+ },
+ ])) as DeviceOpenResult;
+ } catch (err) {
+ const code = codeOf(err);
+ if (code === 'CHANNEL_NOT_ALLOWED' && input.workingDir) {
+ return {
+ ok: false,
+ errorCode: 'INVALID_PARAMS',
+ message: `${name} 上找不到这个目录或不允许使用:${input.workingDir}。Worker 没有创建。`,
+ };
+ }
+ if (
+ code === 'INVALID_PARAMS' ||
+ code === 'WORKDIR_NOT_FOUND' ||
+ code === 'NOT_A_DIRECTORY'
+ ) {
+ return {
+ ok: false,
+ errorCode: 'INVALID_PARAMS',
+ message: `${name} 拒绝了创建请求:${err instanceof Error ? err.message : String(err)}`,
+ };
+ }
+ if (code === 'CHANNEL_NOT_ALLOWED') {
+ return {
+ ok: false,
+ errorCode: 'UNSUPPORTED_CAPABILITY',
+ message: `${name} 的 Cindy 版本过旧,需要更新后才能运行协同 Worker。`,
+ };
+ }
+ deps.log.warn('orca remote worker: open failed', { deviceId: input.deviceId, code });
+ return {
+ ok: false,
+ errorCode:
+ code === 'INVOKE_TIMEOUT' || code === 'DEVICE_OFFLINE' || code === 'LINK_NOT_OPEN'
+ ? 'REMOTE_AGENT_DEVICE_UNREACHABLE'
+ : 'INTERNAL',
+ message: `在 ${name} 上创建 Worker 失败:${err instanceof Error ? err.message : String(err)}`,
+ };
+ }
+ const proxySessionId = createId();
+ const agent: AgentKind = opened.agentKind ?? input.agent;
+ try {
+ await insertRemoteWorkerProxySession({
+ id: proxySessionId,
+ title: input.title,
+ agentKind: agent,
+ model: opened.model || input.model || '',
+ effort: input.effort && EFFORTS.has(input.effort) ? input.effort : null,
+ permissionMode: input.permissionMode,
+ fastMode: input.fast === true,
+ });
+ } catch (err) {
+ await releaseAndMark({
+ workerId: input.workerId,
+ deviceId: input.deviceId,
+ remoteSessionId,
+ }).catch(() => undefined);
+ throw err;
+ }
+ return {
+ ok: true,
+ proxySessionId,
+ remoteSessionId: opened.sessionId || remoteSessionId,
+ agent,
+ model: opened.model,
+ workingDir: opened.workingDir,
+ };
+ },
+
+ async recordRemoteWorker(
+ input: Parameters<NonNullable<OrcaWorkerCreationDeps['recordRemoteWorker']>>[0],
+ ) {
+ await setWorkerRemoteExecution(input.workerId, {
+ deviceId: input.deviceId,
+ remoteSessionId: input.remoteSessionId,
+ });
+ const { workingDir, ...ref } = input;
+ runtime.track({ ...ref, lastBridgedMessageId: null }, { workingDir });
+ deps.broadcastOrcaWorkerChanged(input.leadSessionId);
+ },
+
+ async discardRemoteWorker(input: {
+ proxySessionId: string;
+ deviceId: string;
+ remoteSessionId: string;
+ }) {
+ runtime.untrack(input.proxySessionId);
+ await runtime.release(input);
+ await archiveSingleWorkerSession(input.proxySessionId).catch(() => undefined);
+ },
+
+ archive,
+ wrapTeamDeps,
+
+ /** 团队结束后:停掉仍在跑的远端 Worker,并补发全部未送达的结束通知。 */
+ async releaseEnded(proxySessionIds: readonly string[]): Promise<void> {
+ await Promise.all(
+ proxySessionIds
+ .filter((id) => runtime.isRemote(id))
+ .map(async (id) => {
+ if (runtime.isTurnRunning(id)) await runtime.abort(id);
+ runtime.untrack(id);
+ }),
+ );
+ await retryPendingReleases();
+ },
+ };
+
+ /** 归档或结束团队:通知运行设备结束协同(任务保留),本机归档代理行。 */
+ async function archive(
+ proxySessionId: string,
+ beforeMutation?: () => Promise<void>,
+ ): Promise<void> {
+ const row = await getRemoteWorkerByProxySession(proxySessionId);
+ runtime.untrack(proxySessionId);
+ await archiveSingleWorkerSession(proxySessionId, beforeMutation);
+ if (row) await releaseAndMark(row);
+ }
+
+ /**
+ * 包装 OrcaTeamService 的会话依赖:远端 Worker 的代理任务在本机永远不跑 Agent,
+ * 涉及会话的操作改走运行设备;其余依赖原样透传。
+ */
+ function wrapTeamDeps(base: OrcaTeamServiceDeps): OrcaTeamServiceDeps {
+ const remote = (sessionId: string) => runtime.isRemote(sessionId);
+ const wrapped: OrcaTeamServiceDeps = {
+ ...base,
+ getLiveSession: (sessionId) =>
+ remote(sessionId)
+ ? { isTurnRunning: () => runtime.isTurnRunning(sessionId) }
+ : base.getLiveSession(sessionId),
+ resumeWorkerSession: async (worker, link) => {
+ if (remote(worker.sessionId)) return;
+ await base.resumeWorkerSession(worker, link);
+ },
+ closeWorkerSession: async (sessionId, beforeClose) => {
+ if (!remote(sessionId)) return base.closeWorkerSession(sessionId, beforeClose);
+ await beforeClose?.();
+ await runtime.abort(sessionId);
+ },
+ closeWorkerSessionIfIdle: async (sessionId, sendLockHeld) =>
+ remote(sessionId)
+ ? !runtime.isTurnRunning(sessionId)
+ : base.closeWorkerSessionIfIdle(sessionId, sendLockHeld),
+ hasPendingWorkerInput: async (sessionId) =>
+ remote(sessionId)
+ ? runtime.hasPendingReport(sessionId)
+ : base.hasPendingWorkerInput(sessionId),
+ archiveWorkerSession: async (sessionId, beforeMutation) => {
+ if (!remote(sessionId)) {
+ const row = await getRemoteWorkerByProxySession(sessionId).catch(() => null);
+ if (!row) return base.archiveWorkerSession(sessionId, beforeMutation);
+ }
+ await archive(sessionId, beforeMutation);
+ },
+ dispatchWorkerMessage: async (params) => {
+ if (!remote(params.targetSessionId)) return base.dispatchWorkerMessage(params);
+ const clientId = createId();
+ const result = await runtime.dispatch({
+ proxySessionId: params.targetSessionId,
+ rawContent: params.message,
+ clientId,
+ });
+ const meta = { source: params.dispatchMeta.source, context: params.dispatchMeta.context };
+ if (!result.ok) {
+ return {
+ ok: false,
+ dispatchOutcome: {
+ ...createHostSendFailure(
+ result.code === 'DEVICE_UNREACHABLE'
+ ? 'HOST_NOT_READY'
+ : result.code === 'SESSION_NOT_FOUND'
+ ? 'SESSION_NOT_FOUND'
+ : 'SEND_FAILED',
+ result.message,
+ ),
+ ...meta,
+ },
+ };
+ }
+ await params.onAccepted?.();
+ await params.onAcceptedCommit?.();
+ return {
+ ok: true,
+ mode: result.mode,
+ clientId,
+ dispatchOutcome:
+ result.mode === 'queued'
+ ? {
+ kind: 'session-dispatch',
+ source: meta.source,
+ dispatched: true,
+ wakeKind: 'queued',
+ }
+ : { kind: 'session-dispatch', source: meta.source, dispatched: true },
+ targetTitle: null,
+ targetLastUserSendAt: null,
+ };
+ },
+ reserveWorkerMessage: async (params) => {
+ if (!remote(params.targetSessionId)) return base.reserveWorkerMessage(params);
+ // 打断改派:先停远端当前一轮,再把新指令作为下一条派过去。
+ await params.beforeReserve?.();
+ params.onReserved?.();
+ await runtime.abort(params.targetSessionId);
+ return wrapped.dispatchWorkerMessage({
+ targetSessionId: params.targetSessionId,
+ message: params.message,
+ workerId: params.workerId,
+ dispatchMeta: params.dispatchMeta,
+ onAccepted: params.onAccepted,
+ onAcceptedRollback: params.onAcceptedRollback,
+ onAcceptedCommit: params.onAcceptedCommit,
+ });
+ },
+ requestWorkerInterrupt: async (sessionId) => {
+ if (!remote(sessionId)) return base.requestWorkerInterrupt(sessionId);
+ const requested = await runtime.abort(sessionId);
+ return { stopOutcome: requested ? 'requested' : 'unconfirmed', queuePaused: false };
+ },
+ getWorkerQueuePaused: (sessionId) =>
+ remote(sessionId) ? false : base.getWorkerQueuePaused(sessionId),
+ getSessionQueueSnapshot: async (sessionId) =>
+ remote(sessionId)
+ ? {
+ pendingQueue: [],
+ steeringClientIds: [],
+ consumingClientIds: [],
+ inspectionMessages: [],
+ isWorking: runtime.isTurnRunning(sessionId),
+ willQueue: runtime.isTurnRunning(sessionId),
+ queuePaused: false,
+ }
+ : base.getSessionQueueSnapshot(sessionId),
+ ensureWorkerQueueRestored: async (sessionId) =>
+ remote(sessionId) ? false : base.ensureWorkerQueueRestored(sessionId),
+ removeQueuedMessage: (sessionId, clientId, expected) =>
+ remote(sessionId) ? false : base.removeQueuedMessage(sessionId, clientId, expected),
+ replaceQueuedMessage: (sessionId, clientId, next, expected) =>
+ remote(sessionId) ? false : base.replaceQueuedMessage(sessionId, clientId, next, expected),
+ steerStoredQueuedMessage: async (sessionId, clientId) =>
+ remote(sessionId)
+ ? { kind: 'queued', reason: 'STEER_UNSUPPORTED' }
+ : base.steerStoredQueuedMessage(sessionId, clientId),
+ moveQueuedMessage: (sessionId, clientId, position) =>
+ remote(sessionId) ? null : base.moveQueuedMessage(sessionId, clientId, position),
+ mergeQueuedMessages: (sessionId, clientIds, buildReplacement) =>
+ remote(sessionId)
+ ? false
+ : base.mergeQueuedMessages(sessionId, clientIds, buildReplacement),
+ };
+ return wrapped;
+ }
+}
+
+export type OrcaRemoteWorkers = ReturnType<typeof createOrcaRemoteWorkers>;
diff --git a/apps/desktop/src/main/maker-ipc/orcaServiceFailure.ts b/apps/desktop/src/main/maker-ipc/orcaServiceFailure.ts
index aa04a53e73..bede982e2e 100644
--- a/apps/desktop/src/main/maker-ipc/orcaServiceFailure.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaServiceFailure.ts
@@ -29,6 +29,11 @@ export function throwOrcaServiceFailure(result: { ok: false; errorCode: string;
return throwIpcError('PROVIDER_ROUTE_UNAVAILABLE', result.message);
case 'BUSY':
return throwIpcError('SESSION_RUNNING', result.message);
+ // 协同远端 Worker:运行设备不可达 / 版本过旧。device-link 控制端按既有规则降级。
+ case 'REMOTE_AGENT_DEVICE_UNREACHABLE':
+ return throwIpcError('REMOTE_AGENT_DEVICE_UNREACHABLE', result.message);
+ case 'UNSUPPORTED_CAPABILITY':
+ return throwIpcError('UNSUPPORTED_CAPABILITY', result.message);
default:
return throwIpcError('INTERNAL', result.message);
}
diff --git a/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts b/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
index e6b8ade7be..f85a4159dd 100644
--- a/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
@@ -157,6 +157,10 @@ export type OrcaWorkerCreationErrorCode =
| 'NO_PROVIDER_FOR_AGENT'
| 'PROVIDER_ROUTE_UNAVAILABLE'
| 'BUSY'
+ /** 指定的运行设备离线、未开启远程控制或调用失败。 */
+ | 'REMOTE_AGENT_DEVICE_UNREACHABLE'
+ /** 指定的运行设备版本过旧,不支持协同远端 Worker。 */
+ | 'UNSUPPORTED_CAPABILITY'
| 'INTERNAL';
/** worker 创建结果保留首条派活 outcome,让调用方区分 created-but-not-dispatched。 */
@@ -206,12 +210,36 @@ export interface OrcaWorkerCreateParams {
*/
providerId?: string | null;
initialTask?: string;
- /** Existing absolute directory on the Worker's host; omission inherits Lead. */
+ /**
+ * Existing absolute directory on the Worker's host; omission inherits Lead.
+ * 指定运行设备时是那台电脑上的目录,缺省由那台按自身设置分配任务目录。
+ */
workingDir?: string;
/** 显式值用于本次创建;缺省读取全局 Worker 创建偏好。 */
workerPermissionMode?: OrcaWorkerPermissionMode;
+ /**
+ * 运行设备:同账号另一台电脑的设备 id。指定时 Worker 的任务、目录与命令都在那台;
+ * 缺省 = 与 Lead 同一台(现有行为)。与 SSH 远端 Lead、远程 Agent Lead 互斥。
+ */
+ executionDeviceId?: string;
}
+/** 在运行设备上建好 Worker 任务、并在本机写好代理任务行之后的结果。 */
+export type OrcaRemoteWorkerOpenResult =
+ | {
+ ok: true;
+ proxySessionId: string;
+ remoteSessionId: string;
+ agent: AgentKind;
+ model: string;
+ workingDir: string;
+ }
+ | {
+ ok: false;
+ errorCode: 'REMOTE_AGENT_DEVICE_UNREACHABLE' | 'UNSUPPORTED_CAPABILITY' | 'INVALID_PARAMS' | 'INTERNAL';
+ message: string;
+ };
+
/** enableOrca 已经创建 team 后,可复用同一 worker 创建内核。 */
export interface OrcaWorkerCreateInTeamParams extends OrcaWorkerCreateParams {
teamId: string;
@@ -296,6 +324,39 @@ export interface OrcaWorkerCreationDeps {
}): Promise<DispatchWorkerTaskResult>;
broadcastSessionCreated(sessionId: string): void;
broadcastOrcaWorkerChanged(leadSessionId: string): void;
+ /**
+ * 协同远端 Worker:在运行设备上新建任务,并在本机写一条不跑 Agent 的代理任务行。
+ * 未注入 = 本机不支持远端 Worker。
+ */
+ openRemoteWorker?(input: {
+ deviceId: string;
+ workerId: string;
+ teamId: string;
+ leadSessionId: string;
+ label: string;
+ role: string;
+ agent: AgentKind;
+ model?: string;
+ providerId?: string;
+ effort?: string;
+ fast?: boolean;
+ permissionMode: OrcaWorkerPermissionMode;
+ workingDir?: string;
+ title: string;
+ }): Promise<OrcaRemoteWorkerOpenResult>;
+ /** 写入 Worker 记录后登记运行设备,开始轮询。 */
+ recordRemoteWorker?(input: {
+ workerId: string;
+ teamId: string;
+ leadSessionId: string;
+ proxySessionId: string;
+ deviceId: string;
+ remoteSessionId: string;
+ /** 运行设备上实际使用的工作目录,只做展示。 */
+ workingDir?: string;
+ }): Promise<void>;
+ /** 创建失败时回收:通知运行设备结束协同并归档本机代理行。 */
+ discardRemoteWorker?(input: { proxySessionId: string; deviceId: string; remoteSessionId: string }): Promise<void>;
}
/** Orca worker 创建服务,只负责创建既有 team 下的新 worker,不负责 team lifecycle。 */
@@ -628,6 +689,199 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
await deps.archiveWorkerSession(sessionId).catch(() => undefined);
}
+ /**
+ * 协同远端 Worker:任务、目录、命令都在运行设备上。模型与来源由运行设备按它自己的目录准入
+ * (缺省用那台的默认),本机不按自身目录预检;本机只占槽、建代理任务行并登记 Worker。
+ */
+ async function createRemoteWorkerInTeam(input: {
+ params: OrcaWorkerCreateInTeamParams;
+ role: string;
+ label: string;
+ lead: OrcaLeadSessionSnapshot;
+ settings: { workerSoftLimit: number; workerHardLimit: number };
+ validatePlan: (workingDir?: string) => Promise<number | null | undefined>;
+ assertCurrent?: () => Promise<void>;
+ onCreated?: (assertCreatedCurrent: () => Promise<void>) => void;
+ }): Promise<OrcaWorkerCreationResult> {
+ const { params, role, label, lead, settings, validatePlan, assertCurrent, onCreated } = input;
+ const deviceId = typeof params.executionDeviceId === 'string' ? params.executionDeviceId.trim() : '';
+ if (!/^[A-Za-z0-9_.:-]{1,128}$/.test(deviceId)) {
+ return { ok: false, errorCode: 'INVALID_PARAMS', message: 'execution_device_id must be a device id' };
+ }
+ if (!deps.openRemoteWorker || !deps.recordRemoteWorker || !deps.discardRemoteWorker) {
+ return { ok: false, errorCode: 'INVALID_PARAMS', message: 'this computer cannot run Workers on other devices' };
+ }
+ if (lead.remoteHostId || lead.agentDeviceId) {
+ return {
+ ok: false,
+ errorCode: 'INVALID_PARAMS',
+ message: 'a Lead on an SSH host or with its Agent on another computer cannot place Workers on other devices',
+ };
+ }
+ let requestedDir: string | undefined;
+ if (params.workingDir !== undefined) {
+ const dir = typeof params.workingDir === 'string' ? params.workingDir : '';
+ // 运行设备的系统未知:POSIX 或 Windows 绝对路径都接受,是否存在由那台校验。
+ if (
+ !dir ||
+ dir.length > 4096 ||
+ /[\0\r\n]/.test(dir) ||
+ !(path.posix.isAbsolute(dir) || path.win32.isAbsolute(dir))
+ ) {
+ return {
+ ok: false,
+ errorCode: 'INVALID_PARAMS',
+ message: 'working_dir must be an absolute directory on the execution device',
+ };
+ }
+ requestedDir = dir;
+ }
+ const permissionMode = resolveOrcaWorkerPermissionMode(params.workerPermissionMode);
+ const explicitSourceId =
+ typeof params.providerId === 'string' && params.providerId.trim() ? params.providerId.trim() : undefined;
+
+ const workerId = deps.createId();
+ let reservation:
+ | { ok: true; occupiedSlotsBefore: number }
+ | { ok: false; errorCode: 'DUPLICATE_LABEL' | 'WORKER_CREATION_IN_PROGRESS' | 'WORKER_LIMIT_HARD_EXCEEDED' };
+ try {
+ const admit = async () => {
+ const latestLimit = await validatePlan(requestedDir);
+ settings.workerHardLimit = deps.readCollaborationSettings().workerHardLimit;
+ if (latestLimit != null) settings.workerHardLimit = Math.min(settings.workerHardLimit, latestLimit);
+ return deps.reserveWorkerCreation({
+ reservationId: workerId,
+ teamId: params.teamId,
+ label,
+ hardLimit: settings.workerHardLimit,
+ leaseMs: ORCA_WORKER_CREATION_RESERVATION_LEASE_MS,
+ });
+ };
+ reservation = deps.withLeadSendLock
+ ? await deps.withLeadSendLock(params.leadSessionId, admit)
+ : await admit();
+ } catch (err) {
+ return toInternalFailure(err);
+ }
+ if (!reservation.ok) {
+ if (reservation.errorCode === 'DUPLICATE_LABEL') {
+ return { ok: false, errorCode: 'DUPLICATE_LABEL', message: `label "${label}" already used in this team` };
+ }
+ if (reservation.errorCode === 'WORKER_CREATION_IN_PROGRESS') {
+ return { ok: false, errorCode: 'WORKER_CREATION_IN_PROGRESS', message: `label "${label}" is currently being created` };
+ }
+ return {
+ ok: false,
+ errorCode: 'WORKER_LIMIT_HARD_EXCEEDED',
+ message: `hard limit ${settings.workerHardLimit} reached`,
+ limit: limitSnapshot(settings.workerHardLimit, settings.workerHardLimit),
+ };
+ }
+ const softLimitExceeded = reservation.occupiedSlotsBefore >= settings.workerSoftLimit;
+ let reservationValid = true;
+ const renewalTimer = setInterval(() => {
+ void deps.renewWorkerCreationReservation(workerId, ORCA_WORKER_CREATION_RESERVATION_LEASE_MS)
+ .then((renewed) => { if (!renewed) reservationValid = false; })
+ .catch(() => { reservationValid = false; });
+ }, Math.floor(ORCA_WORKER_CREATION_RESERVATION_LEASE_MS / 3));
+ renewalTimer.unref?.();
+
+ try {
+ await assertCurrent?.();
+ let opened: Extract<OrcaRemoteWorkerOpenResult, { ok: true }>;
+ try {
+ const result = await deps.openRemoteWorker({
+ deviceId,
+ workerId,
+ teamId: params.teamId,
+ leadSessionId: params.leadSessionId,
+ label,
+ role,
+ agent: params.agent,
+ ...(params.model !== undefined ? { model: params.model } : {}),
+ ...(explicitSourceId ? { providerId: explicitSourceId } : {}),
+ ...(params.effort !== undefined ? { effort: params.effort } : {}),
+ ...(params.fast !== undefined ? { fast: params.fast } : {}),
+ permissionMode,
+ ...(requestedDir ? { workingDir: requestedDir } : {}),
+ title: `Worker · ${role} · ${label}`,
+ });
+ if (!result.ok) return { ok: false, errorCode: result.errorCode, message: result.message };
+ opened = result;
+ } catch (err) {
+ return toInternalFailure(err);
+ }
+ const discard = () =>
+ deps.discardRemoteWorker!({
+ proxySessionId: opened.proxySessionId,
+ deviceId,
+ remoteSessionId: opened.remoteSessionId,
+ }).catch(() => undefined);
+
+ const renewed = reservationValid
+ ? await deps.renewWorkerCreationReservation(workerId, ORCA_WORKER_CREATION_RESERVATION_LEASE_MS).catch(() => false)
+ : false;
+ if (!renewed) {
+ await discard();
+ return { ok: false, errorCode: 'INTERNAL', message: 'worker creation reservation expired before persistence' };
+ }
+ try {
+ const finalPlanLimit = await validatePlan(requestedDir);
+ if (finalPlanLimit != null && reservation.occupiedSlotsBefore >= finalPlanLimit) {
+ await discard();
+ return { ok: false, errorCode: 'WORKER_LIMIT_HARD_EXCEEDED', message: 'Registered plan concurrency reached' };
+ }
+ await deps.addOrUpdateWorker({
+ id: workerId,
+ teamId: params.teamId,
+ sessionId: opened.proxySessionId,
+ status: 'idle',
+ label,
+ role,
+ focused: false,
+ });
+ await deps.recordRemoteWorker({
+ workerId,
+ teamId: params.teamId,
+ leadSessionId: params.leadSessionId,
+ proxySessionId: opened.proxySessionId,
+ deviceId,
+ remoteSessionId: opened.remoteSessionId,
+ ...(opened.workingDir ? { workingDir: opened.workingDir } : {}),
+ });
+ } catch (err) {
+ await discard();
+ await deps.removeWorker(workerId).catch(() => undefined);
+ if (isWorkerLabelConstraintError(err)) {
+ return { ok: false, errorCode: 'DUPLICATE_LABEL', message: `label "${label}" already used in this team` };
+ }
+ return toInternalFailure(err);
+ }
+
+ onCreated?.(async () => { await validatePlan(requestedDir); });
+ return {
+ ok: true,
+ teamId: params.teamId,
+ workerId,
+ workerSessionId: opened.proxySessionId,
+ softLimitExceeded,
+ limit: limitSnapshot(settings.workerHardLimit, reservation.occupiedSlotsBefore + 1),
+ resolved: {
+ agent: opened.agent,
+ model: opened.model,
+ effort: params.effort ?? null,
+ fastMode: params.fast === true,
+ providerId: explicitSourceId ?? null,
+ role,
+ label,
+ },
+ };
+ } finally {
+ clearInterval(renewalTimer);
+ await deps.releaseWorkerCreationReservation(workerId).catch(() => undefined);
+ }
+ }
+
async function createWorker(params: OrcaWorkerCreateParams, assertCurrent?: () => Promise<void>): Promise<OrcaWorkerCreationResult> {
const team = await deps.getActiveTeamByLead(params.leadSessionId);
if (!team) {
@@ -681,6 +935,18 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
if (!lead) {
return { ok: false, errorCode: 'NOT_FOUND', message: `lead session ${params.leadSessionId} not found` };
}
+ if (params.executionDeviceId !== undefined) {
+ return createRemoteWorkerInTeam({
+ params,
+ role: role.value,
+ label: label.value,
+ lead,
+ settings,
+ validatePlan,
+ assertCurrent,
+ onCreated,
+ });
+ }
// 标准面板显式选定的来源(非空 string)直接生效,由下方精确 preflight 把关「已连接且
// 提供该模型」;空串/null/undefined 一律按未显式处理(与 IPC 边界同口径,service 作为
// 共用内核自防调用方漏归一)。
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 994cd39b54..46e775a541 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -423,6 +423,7 @@ import {
removeWorker,
renewWorkerCreationReservation,
reserveWorkerCreation,
+ setRemoteWorkerStatusProvider,
setSessionOrcaRole,
setWorkerFocus,
updateWorkerStatus,
@@ -876,6 +877,8 @@ import {
createOrcaRemoteWorkerHost,
registerOrcaRemoteWorkerHandlers,
} from './orcaRemoteWorkerHost.js';
+import { createOrcaRemoteWorkers, type OrcaRemoteWorkers } from './orcaRemoteWorkers.js';
+import { ORCA_EXECUTION_DEVICES_CHANNEL } from '@cindy/device-link';
import {
parseOrcaRemoteLead,
serializeOrcaRemoteLead,
@@ -1310,6 +1313,8 @@ async function prepareProjectSkillLinksFailSoft(workingDir: unknown): Promise<bo
const workerTurnStartSequencer = createWorkerTurnStartSequencer(log);
// session event wiring 是模块级函数;service 在 registerMakerIpc 内构造后注入给事件回调。
let orcaTeamServiceForEvents: OrcaTeamService | null = null;
+// 协同远端 Worker 的宿主装配;bootstrapSession 据此拒绝在本机启动远端 Worker 的代理任务。
+let orcaRemoteWorkersForHost: OrcaRemoteWorkers | null = null;
// silent-stop 自动续跑守卫(决策语义与防死循环不变量见 silentStopAutoResume.ts 文件头)。
// 纯内存、app 级单例:额度按 sessionId 记账,kill switch 每次决策时现读(改配置即生效)。
const silentStopAutoResumeGuard = new SilentStopAutoResumeGuard({
@@ -2277,6 +2282,17 @@ interface OrcaCollabService {
effort: string | null;
focused: boolean;
working_dir: string;
+ execution_device?: {
+ device_id: string;
+ device_name: string | null;
+ reachable: boolean | null;
+ };
+ }>;
+ execution_devices?: Array<{
+ device_id: string;
+ name: string;
+ platform: string | null;
+ supported: boolean;
}>;
}
| { ok: false; errorCode: string; message: string }
@@ -7375,6 +7391,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
didInjectProjectContext: boolean;
}> {
assertAccess?.();
+ // 协同远端 Worker 的代理任务行只承接计槽与回报,真实任务在运行设备上,绝不在本机起 Agent。
+ if (o.id && orcaRemoteWorkersForHost?.runtime.isRemote(o.id)) {
+ throw new Error('[PRECONDITION_FAILED] this Worker runs on another device and cannot start locally');
+ }
// Agent 在另一台电脑上运行的任务:恢复时调用方可能没带设备,以任务记录为准。
if (o.id && o.agentDeviceId === undefined && !o.remoteHostId) {
const agentDeviceId = await readSessionAgentDeviceId(o.id);
@@ -12390,6 +12410,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
await assertCurrent?.();
const workerRecycleScope = captureSessionRecycleScope();
const archivedWorkerSessionIds = await archiveWorkersByTeam(team.id, assertCurrent);
+ // 远端 Worker:停止那台的当前一轮并通知结束协同(任务与文件保留);不可达的留待重连后补发。
+ void orcaRemoteWorkers.releaseEnded(archivedWorkerSessionIds);
await Promise.all(
archivedWorkerSessionIds.map(async (sessionId) => {
await assertCurrent?.();
@@ -12454,6 +12476,15 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
label: label.value,
initialTask:
typeof b.initialTask === 'string' && b.initialTask.length > 0 ? b.initialTask : undefined,
+ // 运行设备与那台上的目录(可选);旧控制端不带,行为不变。
+ ...(typeof b.executionDeviceId === 'string' && b.executionDeviceId.trim()
+ ? {
+ executionDeviceId: b.executionDeviceId.trim(),
+ ...(typeof b.workingDir === 'string' && b.workingDir.trim()
+ ? { workingDir: b.workingDir.trim() }
+ : {}),
+ }
+ : {}),
});
if (!result.ok) throwOrcaServiceFailure(result);
return {
@@ -12538,7 +12569,35 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
);
};
- const orcaTeamService = createOrcaTeamService({
+ // 协同远端 Worker:Worker 在同账号另一台电脑运行(见 orcaRemoteWorkers.ts)。
+ // 其代理任务行永不在本机跑 Agent,团队服务的会话依赖按是否远端分流。
+ const orcaRemoteWorkers = createOrcaRemoteWorkers({
+ remoteInvoke: (deviceId, channel, args) => invokeBotPeer(deviceId, channel, args),
+ listDevices: () => handleListDevices(deviceDirectoryDeps()),
+ getTeamService: () => orcaTeamServiceForEvents,
+ broadcastOrcaWorkerChanged: (leadSessionId) => {
+ broadcastToAllWindows(MAKER_PUSH.ORCA_WORKER_CHANGED, { leadSessionId });
+ },
+ readLeadTitle: async (leadSessionId) => {
+ const [row] = await getDbClient()
+ .drizzle.select({ title: sessions.title })
+ .from(sessions)
+ .where(eq(sessions.id, leadSessionId))
+ .limit(1);
+ return row?.title ?? '';
+ },
+ log,
+ });
+ orcaRemoteWorkersForHost = orcaRemoteWorkers;
+ setRemoteWorkerStatusProvider((proxySessionId, deviceId) => ({
+ deviceName: orcaRemoteWorkers.deviceName(deviceId),
+ reachable: orcaRemoteWorkers.runtime.isReachable(proxySessionId),
+ ...(orcaRemoteWorkers.runtime.workingDir(proxySessionId)
+ ? { workingDir: orcaRemoteWorkers.runtime.workingDir(proxySessionId)! }
+ : {}),
+ }));
+
+ const orcaTeamService = createOrcaTeamService(orcaRemoteWorkers.wrapTeamDeps({
captureControlAuthority: async (leadSessionId) => (await captureOrcaPluginAuthority(leadSessionId)).assertCurrent,
withSessionSendLock: withSendToSessionLock,
getWorkerLinkBySessionId: (workerSessionId) => getWorkerLink({ workerSessionId }),
@@ -12770,8 +12829,19 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
return { accepted: result.ok };
},
log,
- });
+ }));
orcaTeamServiceForEvents = orcaTeamService;
+ void orcaRemoteWorkers.start().catch((err) =>
+ log.warn('orca remote workers: restore failed', {
+ err: err instanceof Error ? err.message : String(err),
+ }),
+ );
+ ipcMain.handle(ORCA_EXECUTION_DEVICES_CHANNEL, async (event) => {
+ if (!isDeviceLinkInvoke()) assertTrustedAppRendererEvent(event);
+ // 共享任务访客看不到本账号的设备目录。
+ if (getDeviceLinkInvokeContext()?.sharedTask) throwIpcError('PERMISSION_DENIED', 'not available to shared task guests');
+ return { devices: await orcaRemoteWorkers.listExecutionDevices() };
+ });
const getProviderRoutingContext = () =>
readOrcaWorkerProviderRoutingContext({
@@ -12964,6 +13034,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
broadcastOrcaWorkerChanged: (leadSessionId) => {
broadcastToAllWindows(MAKER_PUSH.ORCA_WORKER_CHANGED, { leadSessionId });
},
+ openRemoteWorker: (input) => orcaRemoteWorkers.openRemoteWorker(input),
+ recordRemoteWorker: (input) => orcaRemoteWorkers.recordRemoteWorker(input),
+ discardRemoteWorker: (input) => orcaRemoteWorkers.discardRemoteWorker(input),
});
const orcaUiAssignmentHistoryGate = createOrcaUiAssignmentHistoryGate({
@@ -13024,6 +13097,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
});
},
sendWorkerReadyPlaceholder: async ({ workerSessionId, agentKind, entrypoint, context }, assertCurrent) => {
+ // 远端 Worker 的任务在运行设备上已建好并启动,无需本机占位消息。
+ if (orcaRemoteWorkers.runtime.isRemote(workerSessionId)) return;
const workerSession = maker.getSession(workerSessionId);
if (!workerSession) {
throw new Error(`worker session ${workerSessionId} not found for ready placeholder`);
@@ -13053,6 +13128,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
});
},
rollbackCreatedWorker: async ({ workerId, workerSessionId }) => {
+ if (orcaRemoteWorkers.runtime.isRemote(workerSessionId)) {
+ await orcaRemoteWorkers.archive(workerSessionId).catch(() => undefined);
+ await removeWorker(workerId);
+ return;
+ }
const workerSession = maker.getSession(workerSessionId);
if (workerSession) {
await maker.closeSession(workerSessionId).catch(() => undefined);
@@ -14249,7 +14329,19 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
},
getWorkspaceInfo: async ({ leadSessionId }) => {
try {
- return await getOrcaWorkspaceInfoReadOnly(createOrcaDiagnosticsDeps(), leadSessionId);
+ const info = await getOrcaWorkspaceInfoReadOnly(createOrcaDiagnosticsDeps(), leadSessionId);
+ if (!info.ok || !orcaRemoteWorkersForHost) return info;
+ // 运行设备目录只给 Lead 选 execution_device_id 用;探测失败不影响其余诊断。
+ const devices = await orcaRemoteWorkersForHost.listExecutionDevices().catch(() => []);
+ return {
+ ...info,
+ execution_devices: devices.map((d) => ({
+ device_id: d.deviceId,
+ name: d.name,
+ platform: d.platform,
+ supported: d.supported,
+ })),
+ };
} catch (err) {
return {
ok: false,
diff --git a/apps/desktop/src/main/right-sidebar-window/__tests__/preload-contract.test.ts b/apps/desktop/src/main/right-sidebar-window/__tests__/preload-contract.test.ts
index 0f4b24de39..095879b054 100644
--- a/apps/desktop/src/main/right-sidebar-window/__tests__/preload-contract.test.ts
+++ b/apps/desktop/src/main/right-sidebar-window/__tests__/preload-contract.test.ts
@@ -304,7 +304,7 @@ describe('sidebar nested namespace contract', () => {
expect(orcaWorkflowKeys).toEqual(expect.arrayContaining([
'getByLeadSession', 'getByWorkerSession', 'listWorkersByLead', 'listWorkersByLeads',
'createWorker', 'switchFocus', 'idleWorker', 'archiveWorker', 'endTeam',
- 'getCollaborationSettings', 'onOrcaWorkerChanged',
+ 'getCollaborationSettings', 'listExecutionDevices', 'onOrcaWorkerChanged',
]));
});
it('maker capability contract', () => {
diff --git a/apps/desktop/src/main/task-migration/service.ts b/apps/desktop/src/main/task-migration/service.ts
index e428e63d27..c1609226f5 100644
--- a/apps/desktop/src/main/task-migration/service.ts
+++ b/apps/desktop/src/main/task-migration/service.ts
@@ -257,6 +257,7 @@ async function assertSource(
if (
!row ||
!(row.status === 'active' || (worker && row.status === 'archived')) ||
+ // 含另一台电脑上 Worker 的团队也在此被拒:那名 Worker 的本机代理行没有目录。
!row.workingDir ||
row.remoteHostId ||
// Agent 在另一台电脑运行的任务:Agent 会话记录在那台,本机无法完整复制。
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index 89fe9ec1a4..055cd5f002 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -5733,6 +5733,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
ipcRenderer.invoke('maker:team:end', leadSessionId),
getCollaborationSettings: (): Promise<unknown> =>
ipcRenderer.invoke('maker:collaboration-settings:get'),
+ listExecutionDevices: (): Promise<unknown> =>
+ ipcRenderer.invoke('maker:orca:execution-devices'),
setCollaborationSetting: (key: string, value: number): Promise<unknown> =>
ipcRenderer.invoke('maker:collaboration-settings:set', { key, value }),
resetCollaborationSettings: (): Promise<unknown> =>
diff --git a/apps/desktop/src/preload/sidebarWindowPreload.ts b/apps/desktop/src/preload/sidebarWindowPreload.ts
index 9883def524..2f254ca271 100644
--- a/apps/desktop/src/preload/sidebarWindowPreload.ts
+++ b/apps/desktop/src/preload/sidebarWindowPreload.ts
@@ -514,6 +514,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
ipcRenderer.invoke('maker:team:end', leadSessionId),
getCollaborationSettings: (): Promise<unknown> =>
ipcRenderer.invoke('maker:collaboration-settings:get'),
+ listExecutionDevices: (): Promise<unknown> =>
+ ipcRenderer.invoke('maker:orca:execution-devices'),
onOrcaWorkerChanged: (cb: (payload: unknown) => void): (() => void) => onPayload('maker:orca:worker-changed', cb),
},
},
diff --git a/apps/desktop/src/renderer/__tests__/makerTransportOrcaRouting.test.ts b/apps/desktop/src/renderer/__tests__/makerTransportOrcaRouting.test.ts
index ba56fc69b4..7982f02122 100644
--- a/apps/desktop/src/renderer/__tests__/makerTransportOrcaRouting.test.ts
+++ b/apps/desktop/src/renderer/__tests__/makerTransportOrcaRouting.test.ts
@@ -69,6 +69,7 @@ describe('orcaWorkflowsFor 路由', () => {
await orca.archiveWorker('lead', 'w1');
await orca.endTeam('lead');
await orca.getCollaborationSettings();
+ await orca.listExecutionDevices();
expect(invoke).toHaveBeenCalledWith('dev-1', 'local-db:orca-workflows:list-workers-by-lead', ['lead']);
expect(invoke).toHaveBeenCalledWith('dev-1', 'local-db:orca-workflows:get-by-lead', ['lead']);
@@ -79,6 +80,7 @@ describe('orcaWorkflowsFor 路由', () => {
expect(invoke).toHaveBeenCalledWith('dev-1', 'maker:worker:archive', [{ leadSessionId: 'lead', workerId: 'w1' }]);
expect(invoke).toHaveBeenCalledWith('dev-1', 'maker:team:end', ['lead']);
expect(invoke).toHaveBeenCalledWith('dev-1', 'maker:collaboration-settings:get', []);
+ expect(invoke).toHaveBeenCalledWith('dev-1', 'maker:orca:execution-devices', []);
// 注:setCollaborationSetting / create / addWorker / updateWorkerStatus 刻意不在远程可路由集
// (channel 不在 allowlist、无远程调用方);本机走 window.electronAPI.localDb.orcaWorkflows。
});
diff --git a/apps/desktop/src/renderer/lib/makerTransport.ts b/apps/desktop/src/renderer/lib/makerTransport.ts
index cecc2bfe3f..9338d65b91 100644
--- a/apps/desktop/src/renderer/lib/makerTransport.ts
+++ b/apps/desktop/src/renderer/lib/makerTransport.ts
@@ -908,6 +908,7 @@ export interface RoutableOrcaWorkflows {
archiveWorker: FullOrca['archiveWorker'];
endTeam: FullOrca['endTeam'];
getCollaborationSettings: FullOrca['getCollaborationSettings'];
+ listExecutionDevices: FullOrca['listExecutionDevices'];
}
/**
@@ -953,6 +954,7 @@ function remoteOrcaWorkflows(deviceId: string): RoutableOrcaWorkflows {
getCollaborationSettings: t(
'maker:collaboration-settings:get',
) as FullOrca['getCollaborationSettings'],
+ listExecutionDevices: t('maker:orca:execution-devices') as FullOrca['listExecutionDevices'],
};
}
diff --git a/apps/desktop/src/renderer/vite-env.d.ts b/apps/desktop/src/renderer/vite-env.d.ts
index 188e070f6a..f649d0bb64 100644
--- a/apps/desktop/src/renderer/vite-env.d.ts
+++ b/apps/desktop/src/renderer/vite-env.d.ts
@@ -5075,6 +5075,8 @@ interface ElectronAPI {
archiveWorker: (leadSessionId: string, workerId: string) => Promise<unknown>;
endTeam: (leadSessionId: string) => Promise<unknown>;
getCollaborationSettings: () => Promise<unknown>;
+ /** 可放 Worker 的同账号其他电脑(`{ devices: OrcaExecutionDeviceView[] }`)。 */
+ listExecutionDevices: () => Promise<unknown>;
setCollaborationSetting: (key: string, value: number) => Promise<unknown>;
resetCollaborationSettings: () => Promise<unknown>;
};
diff --git a/docs/dev-rules/orca-team-architecture.md b/docs/dev-rules/orca-team-architecture.md
index ea41ce1d87..8b69d2da21 100644
--- a/docs/dev-rules/orca-team-architecture.md
+++ b/docs/dev-rules/orca-team-architecture.md
@@ -383,6 +383,9 @@ Worker turn 被 vendor 报终止型 error,但 interrupted-turn auto-resume 仍
9. **Lead 的完成以团队收口为准(状态:不变量)**
Lead 派完活结束本轮时,团队仍在干活,这一轮不是完成:灵动岛保持 Lead 为运行中(不出完成卡片、不响完成音、不记未读),Work Louder 键盘、侧栏卡片与远程会话列表读同一份活动快照,因此一起保持运行中;renderer 不发完成通知(桌面/手机/飞书)、不亮完成角标。Worker 回报送达后 Lead 被唤起,那一轮的 done 才是团队完成。判据只有一份,在 Main:以「仍有 accepted 派活欠 Lead 回报」(auto-bridge pending)为准,最后一份回报送达或被丢弃(手动停止、归档等)时,若 Lead 空闲则补发被推迟的完成;renderer 不自行推算 Worker 状态,完成去抖落地时读灵动岛活动快照,Main 仍把该会话保持为 `running` 就不算完成(暂停的输入队列同样会让灵动岛保持运行中,但保留原有完成提醒,故排除)。Worker 自身仍不进灵动岛、不单独发通知。已知边界(刻意不处理,保持简单):派给正忙 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)且设备不在跑时取最后一条 assistant 消息,按消息 id 去重;用户在运行设备上直接发的消息算插话,不触发回报。设备不可达只是运行期投影(`executionDevice.reachable`),不扩展 `OrcaWorkerStatus`;派活时不可达直接失败,不回退到本机。首版远端 Worker 没有 `send_to_lead` 桥,也不支持 steer / 队列编辑。实现指针:`orcaRemoteWorkerRuntime.ts`、`orcaRemoteWorkers.ts`、`orcaWorkerCreationService.ts` 的 `createRemoteWorkerInTeam`、运行设备侧 `orcaRemoteWorkerHost.ts`;协议见 `protocol-compatibility.md`「协同远端 Worker」。
+
### 测试与回归清单
当前文档要求保留以下回归方向:
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 8c5e26e512..7ff28df285 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -619,6 +619,12 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
B 的目录守卫(`device-link/dispatch.ts` 的 `PATH_GUARDED_CHANNELS`);不指定则由 B 分配任务目录。
- **旧端降级**:旧版 B 没有这三个 channel,回 `CHANNEL_NOT_ALLOWED`;A 据此把该电脑显示为「需要更新」,
**不回退**到普通 `maker:create-session`(普通任务没有防嵌套与来源标记)。B 新、A 旧时 B 不受影响。
+- **可选运行设备**:`maker:orca:execution-devices`(只读)由 A 本机界面与控制端共用,返回
+ `{ devices: [{ deviceId, name, platform, supported }] }`;逐台探测 caps,旧版标 `supported:false`,
+ 探测失败的不列出。共享任务访客拒绝。
+- **A 驱动 B 的其余通道**全部是已有同账号 channel:`maker:input:enqueue`(按 `clientId` 幂等,
+ `durableDelivery`)、`maker:input:get-projection`(投递回执)、`maker:list-active`、`local-db:sessions:get`、
+ `local-db:history:messages`、`maker:abort-session`;B 不需要知道「这是协同派活」,只认来源标签。
- **B 侧约束**:带标记的任务不能再开启协同(`assertLeadCollabProjectEnabled` 统一拒绝 Worker 与远端 Worker,
覆盖 IPC、远程与 Agent 工具入口),不能复制到其他电脑(`task-migration/service.ts`);侧栏照常显示,
任务头标注「来自 X 的协同」,结束后显示「协同已结束」。
diff --git a/docs/dev-rules/remote-and-mobile-adaptation.md b/docs/dev-rules/remote-and-mobile-adaptation.md
index 6eb73d656c..7ceb0371b0 100644
--- a/docs/dev-rules/remote-and-mobile-adaptation.md
+++ b/docs/dev-rules/remote-and-mobile-adaptation.md
@@ -83,6 +83,19 @@ relay 以 close 1013 `inbound backpressure` 主动断连,此时任何「立即
12 个在途配额;被控端连续立即返回空结果时控制端放慢到 1s 一次,防止空转。2 台控制端共享被控端、
其中一台静默的回归仍需在双实例实机验证中补测。
+## 协同远端 Worker 的轮询与恢复
+
+协议见 [`protocol-compatibility.md`](protocol-compatibility.md)「协同远端 Worker」,实现见
+`apps/desktop/src/main/maker-ipc/orcaRemoteWorkerRuntime.ts`。按故障半径三问:
+
+1. **故障层级**:单台运行设备的单个请求。轮询或派活失败只把这台设备标为「暂时无法获取状态」,
+ Worker 不判失败、不重派;下一轮成功即恢复,并按消息 id 补报缺失的回报。派活时设备不可达直接失败,
+ 不排队、不重试;`enqueue` 回执丢失时只查一次投递回执,不盲重发。
+2. **动作层级**:只影响这台设备上的远端 Worker;不重建 link、不断开 relay,不影响其它设备与普通远控。
+ 结束通知(release)送不到时留待重连或 5 分钟后低频补发。
+3. **多 peer 与负载**:每台设备每轮只发一次 `maker:list-active`,有待回报时 2s 一轮,否则 15s 一轮;
+ 读最后回复与投递回执只针对仍在等待回报的 Worker。多台控制端共享同一运行设备的回归仍需实机补测。
+
## 共享恢复与请求策略
普通出站 invoke 在共享 `InvokeScheduler` 中按目标设备排队:每台最多 12 个在途,
diff --git a/docs/orca-cross-device-worker-plan.md b/docs/orca-cross-device-worker-plan.md
index 9792e9cdf7..151dbd53a8 100644
--- a/docs/orca-cross-device-worker-plan.md
+++ b/docs/orca-cross-device-worker-plan.md
@@ -1,8 +1,9 @@
# 协同扩展:Worker 在另一台电脑运行
> 状态:产品决策已定(2026-10-09,见 §5),分三步实现,不是产品规则。
-> 第一步(运行设备侧支持与 schema)已落地,协议见 `docs/dev-rules/protocol-compatibility.md`
-> 「协同远端 Worker」;Lead 侧编排与界面落地后再拆入 `docs/dev-rules/orca-team-architecture.md`。
+> 第一步(运行设备侧支持与 schema)与第二步(Lead 侧编排、Agent 工具)已落地,协议见
+> `docs/dev-rules/protocol-compatibility.md`「协同远端 Worker」,运行时契约见
+> `docs/dev-rules/orca-team-architecture.md`「远端 Worker」;第三步(协同面板界面)进行中。
> 来源讨论:issue #5620「远程控制功能疑问」→ 跨设备派活。
## 1. 结论
@@ -100,24 +101,28 @@
| 在 B 创建 Worker 任务 | `maker:orca:remote-worker:open`(幂等;来源取 server 盖章的 src) |
| 结束协同 | `maker:orca:remote-worker:release` |
| 派活、补充 | `maker:input:enqueue`(按 `item.clientId` 幂等,`maker:input:get-projection` 查回执) |
-| 打断、停止 | `maker:input:stop`、`maker:abort-session` |
-| 运行状态与轮次结束 | `sessions` topic 的 `local-db:sessions:activity` |
+| 打断、停止 | `maker:abort-session` |
+| 运行状态与轮次结束 | 轮询 `maker:list-active`(每台设备一次,带 `isTurnRunning`) |
+| 可选运行设备 | `maker:orca:execution-devices`(A 本机与控制端共用,只读) |
| 最后回复 | `local-db:history:messages`(assistant、倒序、取 1 条) |
| 授权确认 | 现有远程任务确认链路 |
### 4.3 A 侧改动
-- **数据**:Orca Worker 记录新增 `execution_device_id`(空 = 本机)与远端任务 id,需新 migration,
- 旧版本读不到时按本机 Worker 处理。改动前读 `database-and-migrations.md`。
+- **数据**:Orca Worker 记录新增 `execution_device_id`(空 = 本机)、`remote_session_id`、
+ `last_bridged_message_id`、`remote_released_at`(migration 0124)。本机只留一条不跑 Agent、
+ 没有目录的代理任务行,承接计槽、归档与回报;旧版本读不到这些列时按本机 Worker 处理。
- **创建**:`orcaWorkerCreationService` 增加设备分支:校验设备(在线、版本、同账号、非共享访客)、
在 B 校验目录、创建任务并标记角色。与 `remoteHostId`、`agentDeviceId` 互斥,冲突时报错。
-- **派活**:`orcaTeamService` 的私有 dispatch 路径按 Worker 位置分到本机适配器或远端适配器;
- accepted 回调、clientId、持久化与 `activeWorkerDispatches` 计数保持同一套,不另造状态机。
-- **回报**:远端轮次结束事件触发 auto-bridge;待回报按远端轮次标识幂等。
-- **恢复**:每台设备一个订阅;断线按 `remote-and-mobile-adaptation.md` 的「故障半径三问」,
- 只影响该设备上的 Worker,不重建 link、不影响其它设备和普通远控。
-- **工具**:`create_worker` / `create_workers` 新增 `device`;新增或扩展只读工具返回可选设备;
- 归属校验 `resolveWorkerRef` 不变。
+- **派活**:`OrcaTeamService` 的会话依赖按「是否远端 Worker」分流(`orcaRemoteWorkers.ts` 的
+ `wrapTeamDeps`);accepted 回调、clientId、持久化与 `activeWorkerDispatches` 计数保持同一套,
+ 不另造状态机。
+- **回报**:轮询发现派出的消息已进入对话且设备不在跑时,取最后一条 assistant 消息交给 auto-bridge;
+ 按消息 id 去重(`last_bridged_message_id`),断线重连后补报,同一条只报一次。
+- **恢复**:轮询代替订阅(Main 侧没有可复用的订阅入口);断线按 `remote-and-mobile-adaptation.md`
+ 的「故障半径三问」,只影响该设备上的 Worker,不重建 link、不影响其它设备和普通远控。
+- **工具**:`create_worker` / `create_workers` 新增 `execution_device_id`;`get_workspace_info`
+ 返回 `execution_devices` 与每个 Worker 的 `execution_device`;归属校验 `resolveWorkerRef` 不变。
### 4.4 首版不支持
diff --git a/packages/device-link/src/allowlist.ts b/packages/device-link/src/allowlist.ts
index f142d01b9f..fe90043e90 100644
--- a/packages/device-link/src/allowlist.ts
+++ b/packages/device-link/src/allowlist.ts
@@ -27,6 +27,7 @@
import { FILE_PEER_CHANNEL } from './filePeer.js';
import { REMOTE_AGENT_CHANNEL } from './remoteAgent.js';
import {
+ ORCA_EXECUTION_DEVICES_CHANNEL,
ORCA_REMOTE_WORKER_CAPS_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_TIMEOUT_MS,
@@ -419,6 +420,8 @@ const EXTENDED_INVOKE_CHANNELS: readonly string[] = [
ORCA_REMOTE_WORKER_CAPS_CHANNEL,
ORCA_REMOTE_WORKER_OPEN_CHANNEL,
ORCA_REMOTE_WORKER_RELEASE_CHANNEL,
+ // 远程控制 Lead 所在电脑时,读取那台视角下可选的运行设备(只读,真相在被控端)。
+ ORCA_EXECUTION_DEVICES_CHANNEL,
// —— Rewind / Fork / Title / Context ——
'maker:rewind:preview',
'maker:rewind:commit',
diff --git a/packages/device-link/src/orcaRemoteWorker.ts b/packages/device-link/src/orcaRemoteWorker.ts
index 01c9822085..aba0b86bd1 100644
--- a/packages/device-link/src/orcaRemoteWorker.ts
+++ b/packages/device-link/src/orcaRemoteWorker.ts
@@ -14,6 +14,21 @@ export const ORCA_REMOTE_WORKER_OPEN_CHANNEL = 'maker:orca:remote-worker:open';
export const ORCA_REMOTE_WORKER_RELEASE_CHANNEL = 'maker:orca:remote-worker:release';
export const ORCA_REMOTE_WORKER_VERSION = 1;
+/**
+ * Lead 所在电脑的只读查询:哪些同账号电脑可以被选为运行设备。控制端(远程控制这台
+ * Lead 电脑的手机或另一台桌面)经设备互联读取,结果以 Lead 所在电脑的视角为准。
+ * 老版本没有该 channel → CHANNEL_NOT_ALLOWED,控制端按「不支持远端 Worker」隐藏入口。
+ */
+export const ORCA_EXECUTION_DEVICES_CHANNEL = 'maker:orca:execution-devices';
+
+export interface OrcaExecutionDeviceView {
+ deviceId: string;
+ name: string;
+ platform: string | null;
+ /** false = 那台电脑版本过旧,不支持协同远端 Worker(显示为需要更新)。 */
+ supported: boolean;
+}
+
/** 运行设备上 open 可能要准备工作目录并启动 Agent,给足执行与回程余量。 */
export const ORCA_REMOTE_WORKER_OPEN_TIMEOUT_MS = 60_000;
diff --git a/packages/lizi-mcps/src/orca/server.ts b/packages/lizi-mcps/src/orca/server.ts
index 4a3e3a1b66..f405863383 100644
--- a/packages/lizi-mcps/src/orca/server.ts
+++ b/packages/lizi-mcps/src/orca/server.ts
@@ -105,11 +105,12 @@ export interface OrcaMcpDeps {
fast?: boolean;
label: string;
workingDir?: string;
+ executionDeviceId?: string;
initialTask?: string;
}) => Promise<
ControlResult<
{ workerId: string; workerSessionId: string; softLimitExceeded?: boolean; dispatched?: boolean; dispatchOutcome?: import('../lizi_xdtHelperMcpServer.js').ControlDispatchOutcome; queuedMessageId?: string },
- 'INVALID_PARAMS' | 'NOT_FOUND' | 'WORKER_LIMIT_HARD_EXCEEDED' | 'DUPLICATE_LABEL' | 'WORKER_CREATION_IN_PROGRESS' | 'BUDGET_MODEL_REQUIRES_API_MODE' | 'NO_PROVIDER_FOR_AGENT' | 'PROVIDER_ROUTE_UNAVAILABLE'
+ 'INVALID_PARAMS' | 'NOT_FOUND' | 'WORKER_LIMIT_HARD_EXCEEDED' | 'DUPLICATE_LABEL' | 'WORKER_CREATION_IN_PROGRESS' | 'BUDGET_MODEL_REQUIRES_API_MODE' | 'NO_PROVIDER_FOR_AGENT' | 'PROVIDER_ROUTE_UNAVAILABLE' | 'REMOTE_AGENT_DEVICE_UNREACHABLE' | 'UNSUPPORTED_CAPABILITY'
>
>;
/** 列出当前 workflow 所有 worker。 */
@@ -304,6 +305,19 @@ export interface OrcaWorkspaceInfo {
effort: string | null;
focused: boolean;
working_dir: string;
+ /** 跑在另一台电脑上的 Worker 才有;working_dir 是那台电脑上的目录。 */
+ execution_device?: {
+ device_id: string;
+ device_name: string | null;
+ reachable: boolean | null;
+ };
+ }>;
+ /** 可作为 create_worker.execution_device_id 的同账号电脑;宿主不支持时缺省。 */
+ execution_devices?: Array<{
+ device_id: string;
+ name: string;
+ platform: string | null;
+ supported: boolean;
}>;
}
@@ -397,7 +411,7 @@ function registerOrcaDiagnosticTools(
name: 'get_workspace_info',
category: 'control',
description:
- 'List the current Orca workflow and worker sessions, including whether each worker queue is paused.',
+ 'List the current Orca workflow and worker sessions, including whether each worker queue is paused. execution_devices lists other same-account computers a worker can run on (pass device_id as create_worker.execution_device_id only when supported=true); workers running on another computer carry execution_device.',
inputShape: {},
handler: async () => {
const ctx = resolveLeadSessionContext(getSessionContext);
@@ -409,6 +423,7 @@ function registerOrcaDiagnosticTools(
ui_capacity: result.ui_capacity,
worker_count: result.worker_count,
workers: result.workers,
+ ...(result.execution_devices ? { execution_devices: result.execution_devices } : {}),
});
},
});
diff --git a/packages/lizi-mcps/src/xdt-helper/create_worker.ts b/packages/lizi-mcps/src/xdt-helper/create_worker.ts
index 5d44695789..0521806afe 100644
--- a/packages/lizi-mcps/src/xdt-helper/create_worker.ts
+++ b/packages/lizi-mcps/src/xdt-helper/create_worker.ts
@@ -26,7 +26,9 @@ type CreateWorkerErrorCode =
| 'WORKER_CREATION_IN_PROGRESS'
| 'BUDGET_MODEL_REQUIRES_API_MODE'
| 'NO_PROVIDER_FOR_AGENT'
- | 'PROVIDER_ROUTE_UNAVAILABLE';
+ | 'PROVIDER_ROUTE_UNAVAILABLE'
+ | 'REMOTE_AGENT_DEVICE_UNREACHABLE'
+ | 'UNSUPPORTED_CAPABILITY';
interface CreateWorkerSuccessData {
workerId: string;
@@ -58,6 +60,7 @@ export interface CreateWorkerDeps {
fast?: boolean;
label: string;
workingDir?: string;
+ executionDeviceId?: string;
initialTask?: string;
}) => Promise<CreateWorkerControlResult>;
}
@@ -104,7 +107,9 @@ export const createWorkerSpecSchema = z.object({
.optional()
.describe('可选, 创建后立即派给 worker 的第一条消息'),
working_dir: z.string().min(1).max(4096).refine((value) => value.trim().length > 0).optional()
- .describe('可选,Worker 所在主机上已存在的绝对工作目录;省略则继承 Lead。创建前校验并绑定,失败不回退;不创建目录或 Git worktree。'),
+ .describe('可选,Worker 所在主机上已存在的绝对工作目录;省略则继承 Lead。创建前校验并绑定,失败不回退;不创建目录或 Git worktree。指定 execution_device_id 时是那台电脑上的目录,省略则由那台分配任务目录。'),
+ execution_device_id: z.string().trim().min(1).max(128).optional()
+ .describe('可选,运行设备:同账号另一台电脑的设备 id,只能取 get_workspace_info 返回的 execution_devices 中 supported=true 的 device_id。指定后 Worker 的任务、目录、命令与文件都在那台电脑;省略则与 Lead 同一台。那台离线、未开启远程控制或版本过旧时创建失败,不会回退到本机。'),
}).strict();
export type CreateWorkerSpec = z.infer<typeof createWorkerSpecSchema>;
@@ -133,7 +138,8 @@ const DESCRIPTION = [
'- effort: 可选, reasoning/thinking 强度 (low / medium / high / xhigh / max / ultra)。Codex: 映射 OpenAI reasoning effort(max/ultra 仅部分模型如 GPT-5.6 Sol 支持); Claude Code: 映射 extended thinking token 预算(无 ultra,自动降级为 max)。显式传入时必须匹配所选 model 能力;当前 worker 模型都不把 minimal 作为可选思考档。',
'- fast: 可选 boolean, 是否给 worker 开启 Fast 模式 (更快输出)。用户明确说「fast / 快速 / 开/关 fast」时显式传。对 codex 与 pi worker 生效 (且需所选模型声明 supportsFastMode; 否则自动降级为关); claude-code worker 忽略此参数 (其 fast mode 在 agent 层为 no-op)。不传则继承默认 (New Maker 面板默认或 lead session 的 fastMode)。',
'- label: worker 短标识, 1-32 chars, 只能含字母、数字、-、_, 同 workflow 内唯一, 用于 switch_focus 定位',
- '- working_dir: 可选,Worker 所在主机上已存在的绝对目录;创建前校验并绑定,省略继承 Lead,失败不回退。不创建目录或 Git worktree。',
+ '- working_dir: 可选,Worker 所在主机上已存在的绝对目录;创建前校验并绑定,省略继承 Lead,失败不回退。不创建目录或 Git worktree。指定 execution_device_id 时是那台电脑上的目录,省略由那台分配。',
+ '- execution_device_id: 可选,运行设备(同账号另一台电脑)的 device_id,只能取 get_workspace_info 的 execution_devices 里 supported=true 的值;指定后 Worker 的任务、目录、命令与文件都在那台电脑,结果仍自动回报给你。用户没有要求放到别的电脑时不要传。',
"- initial_task: 可选, 创建后立即派给 worker 的第一条消息;dispatch_outcome.wakeKind=queued 表示首条任务已成功入队(此时回传 queued_message_id, 被消费前可用 get_worker_queue_status / update_queued_message / cancel_queued_message / merge_queued_messages 管理);dispatch_outcome.kind='session-dispatch' 且 dispatched=false,或 kind='host-send' 且 accepted=false,表示 worker 已创建但首条任务未送达 / 派发失败",
'',
'【硬边界】',
@@ -146,6 +152,7 @@ const DESCRIPTION = [
'- 选了 tier=budget (codex/ 前缀模型) 但当前 Codex 不在 API key 模式 → 返 BUDGET_MODEL_REQUIRES_API_MODE: 应如实告知用户「该模型需切换到 API key 模式才能使用」, 不要擅自改用官方版顶替 (除非用户明确同意)。',
'- 该 agent 没有任何已连接的模型供应商 (provider) → 返 NO_PROVIDER_FOR_AGENT: 应如实把 message 转告用户 (去「设置 → 模型供应商」连接一个支持该 agent 的供应商), 或按 message 建议改用「已连接供应商的另一个 agent」创建 worker; 不要反复重试同一 agent。',
'- Worker 解析出的精确 provider + model 路由当前不可用 → 返 PROVIDER_ROUTE_UNAVAILABLE: 应如实把 message 转告用户并调整模型或供应商; 不要按“完全没有供应商”处理,也不要反复重试同一路由。',
+ '- 指定的运行设备离线 / 未开启远程控制 → 返 REMOTE_AGENT_DEVICE_UNREACHABLE;版本过旧 → 返 UNSUPPORTED_CAPABILITY。都不会改在本机创建:如实告知用户,由用户决定换设备或改在本机。',
].join('\n');
export function registerCreateWorkerTool(
@@ -157,7 +164,7 @@ export function registerCreateWorkerTool(
category: 'control',
description: DESCRIPTION,
inputShape: createWorkerSpecSchema.shape,
- handler: async ({ role, agent, model, provider_id, effort, fast, label, initial_task, working_dir }) => {
+ handler: async ({ role, agent, model, provider_id, effort, fast, label, initial_task, working_dir, execution_device_id }) => {
const ctx = deps.getSessionContext?.() ?? deps;
if (!ctx.sessionId) {
return errorPayload('LEAD_NOT_SUPPORTED', '当前 session 类型不支持作为 Lead。');
@@ -178,6 +185,7 @@ export function registerCreateWorkerTool(
fast,
label,
...(working_dir !== undefined ? { workingDir: working_dir } : {}),
+ ...(execution_device_id !== undefined ? { executionDeviceId: execution_device_id } : {}),
initialTask: initial_task,
});
if (!result.ok) {
diff --git a/packages/lizi-mcps/src/xdt-helper/create_workers.ts b/packages/lizi-mcps/src/xdt-helper/create_workers.ts
index 1025800191..8d3afef905 100644
--- a/packages/lizi-mcps/src/xdt-helper/create_workers.ts
+++ b/packages/lizi-mcps/src/xdt-helper/create_workers.ts
@@ -153,6 +153,7 @@ export function registerCreateWorkersTool(
fast: worker.fast,
label: worker.label,
...(worker.working_dir !== undefined ? { workingDir: worker.working_dir } : {}),
+ ...(worker.execution_device_id !== undefined ? { executionDeviceId: worker.execution_device_id } : {}),
initialTask: worker.initial_task,
});
limit = result.limit ?? limit;