Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(orca): 独立记忆手动创建 Worker 的模型与远程供应商

fmfsaisaiec42b52b23c6
diff --git a/apps/desktop/src/renderer/features/cc-agent/CreateWorkerPopover.tsx b/apps/desktop/src/renderer/features/cc-agent/CreateWorkerPopover.tsx
index bb3ad54cfd..d05ac4cdc3 100644
--- a/apps/desktop/src/renderer/features/cc-agent/CreateWorkerPopover.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/CreateWorkerPopover.tsx
@@ -1,3 +1,4 @@
+import { getDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
import * as Dialog from '@radix-ui/react-dialog';
import { WINDOW_NO_DRAG_STYLE } from '@/components/layout/windowDrag';
import { Button } from '@/components/ui/button';
@@ -200,8 +201,9 @@ export function CreateWorkerPopover({
const directoryTargetRef = useRef<{ deviceId: string | null; open: boolean; pickerOpen: boolean }>({ deviceId: null, open, pickerOpen: false });
directoryTargetRef.current = { deviceId: executionDeviceId, open, pickerOpen: directoryPickerOpen };
useEffect(() => { setDirectoryPickerOpen(false); }, [executionDeviceId, open]);
- // Worker 的 Agent 所在电脑(远程供应商);null = 任务所在电脑。打开时跟 Lead。
+ // Worker 的 Agent 所在电脑(远程供应商);null = 任务所在电脑。没有手动记忆时跟 Lead。
const [agentDeviceId, setAgentDeviceId] = useState<string | null>(null);
+ const modelSelectionScope = JSON.stringify([getDataOwnerGeneration().dataOwnerId, leadDeviceId ?? 'local']);
// 模型、供应商与能力按 Worker 的 Agent 实际运行的电脑读取:选了远程供应商读那台(或分享),
// 远程控制的 Lead 读它所在的电脑,选了运行设备则读运行设备。权限档始终跟 Lead 所在电脑走。
const deviceId = agentDeviceId ?? leadDeviceId ?? executionDeviceId ?? undefined;
@@ -386,36 +388,40 @@ export function CreateWorkerPopover({
// 打开弹窗时恢复上次选择;initial task 不记忆,避免把旧任务误带到下一次创建。
// Lead 的位置按打开那一刻读:打开期间它变化(分享列表异步读到、任务快照刷新)不清掉用户已填的内容,
- // 只在用户还没自己选过位置时让 Worker 的位置继续跟着 Lead。
+ // 只在没有已保存的模型选择、本次也没手选时让 Worker 的位置继续跟着 Lead。
const leadAgentDeviceIdRef = useRef(leadAgentDeviceId ?? null);
leadAgentDeviceIdRef.current = leadAgentDeviceId ?? null;
- const agentLocationChosenRef = useRef(false);
+ const modelSelectionChosenRef = useRef(false);
+ const restoredModelSelectionRef = useRef(false);
useEffect(() => {
if (!open) {
setPrefsRestored(false);
return;
}
const stored = readWorkerCreationPrefs();
- const agentPrefs = stored[stored.lastAgent];
- // Worker 默认跟 Lead 在同一处运行 Agent;本机的来源记忆只用于任务所在电脑是本机、Agent 也在本机时。
+ const selection = sshRemote ? undefined : stored.modelSelectionByHost?.[modelSelectionScope];
+ const rememberedAgent = selection?.agent ?? stored.lastAgent;
+ const agentPrefs = selection ?? stored[rememberedAgent];
+ // 完整选择优先;旧版逐 Agent 记忆没有位置信息,仍按原规则跟 Lead,不猜测旧值的归属。
const leadLocation = leadAgentDeviceIdRef.current;
- agentLocationChosenRef.current = false;
+ modelSelectionChosenRef.current = selection !== undefined;
+ restoredModelSelectionRef.current = selection !== undefined;
setPrefs(stored);
- setAgent(stored.lastAgent);
+ setAgent(rememberedAgent);
setModel(agentPrefs.model);
setEffort(agentPrefs.effort);
setFast(agentPrefs.fast);
- setAgentDeviceId(leadLocation);
- setProviderSource(leadDeviceId || leadLocation ? null : agentPrefs.providerId);
+ setAgentDeviceId(selection ? selection.agentDeviceId : leadLocation);
+ setProviderSource(selection ? selection.providerId : leadDeviceId || leadLocation ? null : agentPrefs.providerId);
setInitialTask('');
setSelectedWorkerPermissionMode(stored.workerPermissionMode);
setExecutionDeviceId(null);
setRemoteDirMode('dialogue');
setRemoteDir('');
setPrefsRestored(true);
- }, [leadDeviceId, open]);
+ }, [leadDeviceId, modelSelectionScope, open, sshRemote]);
useEffect(() => {
- if (open && !agentLocationChosenRef.current) setAgentDeviceId(leadAgentDeviceId ?? null);
+ if (open && !modelSelectionChosenRef.current) setAgentDeviceId(leadAgentDeviceId ?? null);
}, [leadAgentDeviceId, open]);
// 可选运行设备:每次打开读一次;读不到就只有这台电脑,不提示错误。
@@ -440,6 +446,8 @@ export function CreateWorkerPopover({
const selectExecutionDevice = useCallback(
(next: string | null) => {
if (next === executionDeviceId) return;
+ restoredModelSelectionRef.current = false;
+ modelSelectionChosenRef.current = false;
setExecutionDeviceId(next);
setRemoteDirMode('dialogue');
setRemoteDir('');
@@ -458,13 +466,17 @@ export function CreateWorkerPopover({
}
}, [selectedWorkerPermissionMode, supportsWorkerPermissionModeSelection]);
+ const rememberedSourceUnavailable = restoredModelSelectionRef.current
+ && providerSource !== null && narrowProviderSource(providerSource, model) !== providerSource;
+
// capabilities 可能尚未加载或模型被移除;加载后把当前选择收敛到可用模型和 effort。
useEffect(() => {
- if (!open || !prefsRestored || modelCatalogLoading) return;
+ if (!open || !prefsRestored || modelCatalogLoading || rememberedSourceUnavailable) return;
const models = activeModels;
if (models.length === 0) return;
let selected = models.find((m) => m.id === model);
if (!selected) {
+ if (restoredModelSelectionRef.current) return;
// Provider loading has settled, so activeModels is authoritative for both local and remote
// creation. A capability entry alone does not make a disconnected provider's model usable.
selected = models[0];
@@ -481,7 +493,7 @@ export function CreateWorkerPopover({
// 恢复出来的显式来源可能已断开或不提供收敛后的模型 —— 目录就绪后同步收窄。
if (providerSource !== null) {
const narrowed = narrowProviderSource(providerSource, selected.id);
- if (narrowed !== providerSource) setProviderSource(narrowed);
+ if (narrowed !== providerSource && !restoredModelSelectionRef.current) setProviderSource(narrowed);
}
}, [
activeModels,
@@ -492,20 +504,23 @@ export function CreateWorkerPopover({
narrowProviderSource,
open,
prefsRestored,
+ rememberedSourceUnavailable,
providerSource,
routeEffortMetaFor,
]);
useEffect(() => {
- if (currentModel && !currentModelSupportsFast && fast) {
+ if (!modelCatalogLoading && !rememberedSourceUnavailable && currentModel && !currentModelSupportsFast && fast) {
setFast(false);
}
- }, [currentModel, currentModelSupportsFast, fast]);
+ }, [currentModel, currentModelSupportsFast, fast, modelCatalogLoading, rememberedSourceUnavailable]);
const vendorKey = agentKindToVendor(agent);
const updateAgent = useCallback(
(nextAgent: 'claude-code' | 'codex' | 'pi') => {
if (nextAgent === agent) return;
+ modelSelectionChosenRef.current = true;
+ restoredModelSelectionRef.current = false;
// 切走前把当前 agent 的 live 编辑(模型/effort/Fast/来源)快照进内存 prefs:
// 恢复读的是 prefs,不快照会把「改了还没提交就切了个 tab」的编辑静默回滚到
// 打开弹窗时的旧值(codex review)。只更新内存态,localStorage 仍只在提交时
@@ -513,15 +528,13 @@ export function CreateWorkerPopover({
const snapshot: WorkerCreationPrefs = {
...prefs,
// 另一台电脑(远程供应商)目录里的选择不进本机 Worker 偏好,与提交路径同规则。
- [agent]: agentDeviceId
+ [agent]: deviceId
? prefs[agent]
: {
model,
effort,
fast,
- // device-link 面板无来源维度(providerSource 恒 null),保留本地记忆原值,
- // 与提交路径同规则。
- providerId: deviceId ? prefs[agent].providerId : providerSource,
+ providerId: providerSource,
},
};
setPrefs(snapshot);
@@ -537,6 +550,8 @@ export function CreateWorkerPopover({
const updateModel = useCallback(
(nextModel: string) => {
+ modelSelectionChosenRef.current = true;
+ restoredModelSelectionRef.current = false;
setModel(nextModel);
// flat 面板换模型(device-link 退化路径):effort 同样按路由来源档位表收敛,
// 与收敛 effect / 提交同口径,不留显示与派发不一致的窗口。
@@ -562,6 +577,8 @@ export function CreateWorkerPopover({
// effort/Fast 在选中该行后被丢弃);Fast 还要叠加该来源条目的 per-provider 能力。
const handleProviderChange = useCallback(
(providerId: string | null, modelId?: string, reconciledEffort?: Effort, reconciledFast?: boolean) => {
+ modelSelectionChosenRef.current = true;
+ restoredModelSelectionRef.current = false;
const nextModel = modelId ?? model;
const narrowed = narrowProviderSource(providerId, nextModel);
// 「钉/重选当前生效来源」与「切到恰好提供同一模型的另一来源」必须区分
@@ -726,6 +743,7 @@ export function CreateWorkerPopover({
!remoteModelListBlocked &&
!remoteDirInvalid &&
!agentLocationUnsendable &&
+ !rememberedSourceUnavailable &&
(!requireWorkerPermissionModeSupport || !remoteWorkerPermissionModeUnsupported) &&
!!currentModel;
const resolvedTitle = title ?? t('orca.createWorker.title');
@@ -759,19 +777,25 @@ export function CreateWorkerPopover({
const submitProviderId = narrowProviderSource(providerSource, model);
const nextPrefs: WorkerCreationPrefs = {
...prefs,
+ // 只记手动确认的路线,默认跟随与运行设备的临时目录不固化成模型偏好。
+ ...(!sshRemote && !executionDevice && modelSelectionChosenRef.current ? {
+ modelSelectionByHost: {
+ ...prefs.modelSelectionByHost,
+ [modelSelectionScope]: { agent, agentDeviceId, model, effort, fast, providerId: submitProviderId },
+ },
+ } : {}),
lastAgent: agent,
workerPermissionMode: supportsWorkerPermissionModeSelection
? selectedWorkerPermissionMode
: prefs.workerPermissionMode,
- // 另一台电脑(远程供应商)目录里的选择不进本机 Worker 偏好(那台的档位已记在那台的那份记忆)。
- [agent]: agentDeviceId
+ // 远程路线单独记在 modelSelectionByHost,不覆盖旧版逐 Agent 的本机目录记忆。
+ [agent]: deviceId
? prefs[agent]
: {
model,
effort,
fast,
- // device-link 创建不覆盖本地来源记忆(远程面板没有来源维度)。
- providerId: deviceId ? prefs[agent].providerId : submitProviderId,
+ providerId: submitProviderId,
},
};
setPrefs(nextPrefs);
@@ -819,6 +843,8 @@ export function CreateWorkerPopover({
}, [
canCreate,
prefs,
+ modelSelectionScope,
+ sshRemote,
activeRole,
agent,
agentDeviceId,
@@ -990,11 +1016,12 @@ export function CreateWorkerPopover({
fastModeConfigurable={['codex', 'pi']}
unifiedAgents={sshRemote ? (pickerAgents ?? ['claude-code', 'codex']).filter((kind) => kind !== 'pi') : pickerAgents}
onUnifiedSelect={deviceId && remoteProviders.unsupported ? undefined : (selection) => {
+ modelSelectionChosenRef.current = true;
+ restoredModelSelectionRef.current = false;
const nextAgent = selection.engine === 'cc' ? 'claude-code' : selection.engine;
updateAgent(nextAgent);
// 列出远程供应商时,行带着它所属的电脑(null = 任务所在电脑):一起换 Worker 的 Agent 位置。
if (selection.agentDevice !== undefined) {
- agentLocationChosenRef.current = true;
setAgentDeviceId(selection.agentDevice?.deviceId ?? null);
}
setModel(selection.modelId);
diff --git a/apps/desktop/src/renderer/features/cc-agent/__tests__/CreateWorkerPopover.test.tsx b/apps/desktop/src/renderer/features/cc-agent/__tests__/CreateWorkerPopover.test.tsx
index c91299c2a4..329db66b64 100644
--- a/apps/desktop/src/renderer/features/cc-agent/__tests__/CreateWorkerPopover.test.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/__tests__/CreateWorkerPopover.test.tsx
@@ -1,5 +1,7 @@
// @vitest-environment jsdom
+import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+
import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
import { useState } from 'react';
import userEvent from '@testing-library/user-event';
@@ -74,6 +76,7 @@ const mocks = vi.hoisted(() => ({
id: string;
name: string;
connected: boolean;
+ remoteInvocationEnabled?: boolean;
agents: string[];
models: Record<
string,
@@ -187,6 +190,7 @@ vi.mock('@/components/new-chat/ModelSelector', () => ({
<button data-testid="pick-claude-model" onClick={() => props.onUnifiedSelect?.({ engine: 'cc', modelId: 'claude-sonnet-4-6', providerId: 'anthropic', effort: 'high', fast: false, favoriteUid: null })} />
<button data-testid="pick-codex-config" onClick={() => props.onUnifiedSelect?.({ engine: 'codex', modelId: 'gpt-5.5', providerId: 'xd', effort: 'low', fast: false, favoriteUid: null })} />
{/* 远程供应商栏里的行带着它所属的电脑(null = 任务所在电脑)。 */}
+ <button data-testid="pick-shared-codex" onClick={() => (props.onUnifiedSelect as ((selection: unknown) => void) | undefined)?.({ engine: 'codex', modelId: 'codex/gpt-5.5', providerId: 'openai', effort: 'high', fast: false, favoriteUid: null, agentDevice: { deviceId: 'share:s1', name: 'Shared' } })} />
<button data-testid="pick-remote-codex" onClick={() => (props.onUnifiedSelect as ((selection: unknown) => void) | undefined)?.({ engine: 'codex', modelId: 'codex/gpt-5.5', providerId: 'openai', effort: 'high', fast: false, favoriteUid: null, agentDevice: { deviceId: 'agent-pc', name: 'Agent PC' } })} />
<button data-testid="pick-home-codex" onClick={() => (props.onUnifiedSelect as ((selection: unknown) => void) | undefined)?.({ engine: 'codex', modelId: 'codex/gpt-5.5', providerId: 'xd', effort: 'high', fast: false, favoriteUid: null, agentDevice: null })} />
<button
@@ -1845,7 +1849,7 @@ describe('CreateWorkerPopover execution device', () => {
// 远程供应商与本机供应商一视同仁(2026-10-10):Worker 的 Agent 可以放到另一台电脑或分享上。
describe('CreateWorkerPopover remote providers', () => {
- const devices = [{ deviceId: 'agent-pc', name: 'Agent PC' }];
+ const devices = [{ deviceId: 'agent-pc', name: 'Agent PC' }, { deviceId: 'share:s1', name: 'Shared' }];
const submit = () => fireEvent.click(screen.getByRole('button', { name: 'orca.createWorker.submit' }));
beforeEach(() => {
@@ -1853,6 +1857,7 @@ describe('CreateWorkerPopover remote providers', () => {
resetProviderModelMemoryForTest();
mocks.modelsByAgent.codex = [model('codex/gpt-5.5')];
mocks.capabilitiesByAgent.codex = { availableModels: [{ id: 'codex/gpt-5.5' }] };
+ mocks.capabilitiesByAgent['claude-code'] = { availableModels: [] };
mocks.localProviders = [];
mocks.remoteProviders = [];
mocks.remoteUnsupported = false;
@@ -1921,6 +1926,115 @@ describe('CreateWorkerPopover remote providers', () => {
await waitFor(() => expect(onCreate).toHaveBeenLastCalledWith(expect.objectContaining({ agentDeviceId: null })));
});
+ // 回归 7af90460e2:真实弹窗提交后重新挂载,模型与来源应仍是 Worker 的选择。
+ // 原有用例只在一次打开内换位置,漏掉再次打开被 Lead 覆盖;unit,最小输入是选行、提交、换 Lead 后重开。
+ it.each([
+ { pick: 'pick-remote-codex', location: 'agent-pc', provider: 'openai', nextLead: null, host: undefined },
+ { pick: 'pick-shared-codex', location: 'share:s1', provider: 'openai', nextLead: null, host: 'controlled-pc' },
+ { pick: 'pick-home-codex', location: null, provider: 'xd', nextLead: 'agent-pc', host: undefined },
+ ])('remembers the submitted Worker selection independently of the Lead: $pick', async ({ pick, location, provider, nextLead, host }) => {
+ mocks.capabilitiesByAgent['claude-code'] = { availableModels: [], supportsOrcaWorkerAgentDevice: true } as never;
+ window.localStorage.setItem('workerCreationPrefs', JSON.stringify({
+ lastAgent: 'codex', codex: { model: 'gpt-main', effort: 'high', fast: false },
+ }));
+ mocks.modelsByAgent.codex = [model('gpt-main'), model('codex/gpt-5.5')];
+ mocks.localProviders = [{
+ id: 'xd', name: 'XD', connected: true, agents: ['codex'],
+ models: { codex: mocks.modelsByAgent.codex },
+ }];
+ mocks.remoteProviders = [{
+ id: 'openai', name: 'OpenAI', connected: true, remoteInvocationEnabled: true,
+ agents: ['codex'], models: { codex: [model('codex/gpt-5.5')] },
+ }];
+ const onCreate = vi.fn();
+ const view = render(
+ <CreateWorkerPopover open deviceId={host} onClose={vi.fn()} onCreate={onCreate} remoteAgentDevices={devices} />,
+ );
+ fireEvent.click(screen.getByTestId(pick));
+ submit();
+ await waitFor(() => expect(onCreate).toHaveBeenCalledTimes(1));
+ view.unmount();
+ setProviderModelChoice('codex', 'xd', 'gpt-main', 'high');
+
+ render(
+ <CreateWorkerPopover open deviceId={host} onClose={vi.fn()} onCreate={onCreate} leadAgentDeviceId={nextLead} remoteAgentDevices={devices} />,
+ );
+ expect(screen.getByTestId('model-selector').dataset.remoteSelected).toBe(String(location));
+ expect(screen.getByTestId('model-selector').dataset.currentProvider).toBe(provider);
+ submit();
+ await waitFor(() => expect(onCreate).toHaveBeenCalledTimes(2));
+ await waitFor(() => expect(onCreate).toHaveBeenLastCalledWith(expect.objectContaining({
+ agentDeviceId: location, providerId: provider, model: 'codex/gpt-5.5',
+ })));
+ });
+
+ // 记忆恢复后目录/能力可能改变:不可静默换来源、换模型或换账号复用。
+ it.each(['provider', 'model', 'old-host', 'account'])('keeps a restored route isolated when %s changes', async (change) => {
+ mocks.remoteProviders = [{ id: 'openai', name: 'OpenAI', connected: true,
+ remoteInvocationEnabled: true, agents: ['codex'], models: { codex: [model('codex/gpt-5.5')] } }];
+ const onCreate = vi.fn();
+ const view = render(<CreateWorkerPopover open onClose={vi.fn()} onCreate={onCreate} remoteAgentDevices={devices} />);
+ fireEvent.click(screen.getByTestId('pick-remote-codex'));
+ submit();
+ await waitFor(() => expect(onCreate).toHaveBeenCalledTimes(1));
+ view.unmount();
+ if (change === 'provider') {
+ mocks.remoteProviders[0]!.connected = false;
+ mocks.remoteProviders.push({ id: 'fallback', name: 'Fallback', connected: true, remoteInvocationEnabled: true,
+ agents: ['codex'], models: { codex: [{ ...model('codex/gpt-5.5'), efforts: ['low'], defaultEffort: 'low' }] } });
+ }
+ if (change === 'model') mocks.remoteProviders[0]!.models.codex = [model('other-model')];
+ if (change === 'account') setDataOwnerGeneration('another-owner');
+ try {
+ render(<CreateWorkerPopover open onClose={vi.fn()} onCreate={onCreate}
+ remoteAgentDevices={change === 'old-host' ? undefined : devices} />);
+ if (change === 'account') {
+ expect(screen.getByTestId('model-selector').dataset.agentDevice).toBe('');
+ } else {
+ expect(screen.getByTestId('model-selector').dataset.agentDevice).toBe('agent-pc');
+ expect(screen.getByTestId('model-selector').dataset.effort).toBe('high');
+ expect((screen.getByRole('button', { name: 'orca.createWorker.submit' }) as HTMLButtonElement).disabled).toBe(true);
+ submit();
+ expect(onCreate).toHaveBeenCalledTimes(1);
+ }
+ } finally { setDataOwnerGeneration(null); }
+ });
+
+ it('keeps following the Lead after default submission or an unsubmitted model change', async () => {
+ const onCreate = vi.fn();
+ const view = render(
+ <CreateWorkerPopover open onClose={vi.fn()} onCreate={onCreate} leadAgentDeviceId="agent-pc" remoteAgentDevices={devices} />,
+ );
+ submit();
+ await waitFor(() => expect(onCreate).toHaveBeenCalledTimes(1));
+ fireEvent.click(screen.getByTestId('pick-home-codex'));
+ view.unmount();
+ render(
+ <CreateWorkerPopover open onClose={vi.fn()} onCreate={onCreate} leadAgentDeviceId="other-pc" remoteAgentDevices={devices} />,
+ );
+ expect(screen.getByTestId('model-selector').dataset.agentDevice).toBe('other-pc');
+ });
+
+ it('does not reuse a submitted local Worker selection on another task host or SSH', async () => {
+ const onCreate = vi.fn();
+ const view = render(
+ <CreateWorkerPopover open onClose={vi.fn()} onCreate={onCreate} remoteAgentDevices={devices} />,
+ );
+ fireEvent.click(screen.getByTestId('pick-remote-codex'));
+ submit();
+ await waitFor(() => expect(onCreate).toHaveBeenCalledTimes(1));
+ view.unmount();
+
+ const remote = render(
+ <CreateWorkerPopover open onClose={vi.fn()} onCreate={onCreate} deviceId="other-host" remoteAgentDevices={devices} />,
+ );
+ expect(screen.getByTestId('model-selector').dataset.agentDevice).toBe('');
+ expect(mocks.deviceProvidersFor).toBe('other-host');
+ remote.unmount();
+ render(<CreateWorkerPopover open sshRemote onClose={vi.fn()} onCreate={onCreate} />);
+ expect(screen.getByTestId('model-selector').dataset.agentDevice).toBe('');
+ });
+
it("keeps following the Lead's location until the user picks one, without wiping the form", async () => {
const onCreate = vi.fn();
const view = render(
diff --git a/apps/desktop/src/renderer/state/workerCreationPrefs.ts b/apps/desktop/src/renderer/state/workerCreationPrefs.ts
index 5cf6d43be4..99b847a28f 100644
--- a/apps/desktop/src/renderer/state/workerCreationPrefs.ts
+++ b/apps/desktop/src/renderer/state/workerCreationPrefs.ts
@@ -24,6 +24,12 @@ export interface WorkerAgentPrefs {
providerId: string | null;
}
+/** 手动选定并提交的完整模型路线;null 位置表示任务所在电脑。 */
+export interface WorkerModelSelection extends WorkerAgentPrefs {
+ agent: WorkerAgentKind;
+ agentDeviceId: string | null;
+}
+
export interface WorkerCreationPrefs {
lastAgent: WorkerAgentKind;
codex: WorkerAgentPrefs;
@@ -31,9 +37,11 @@ export interface WorkerCreationPrefs {
pi: WorkerAgentPrefs;
/** 新 Worker 的默认权限;UI 与 Orca tool 共用。 */
workerPermissionMode: OrcaWorkerPermissionMode;
+ /** 按账号与任务所在电脑隔离(JSON 二元组);缺项时继续跟随 Lead 的位置。 */
+ modelSelectionByHost?: Record<string, WorkerModelSelection>;
}
-// 首次默认值与手机端共用(@cindy/maker-shared/orca-team),两端「创建 Worker」同一套规则。
+// 首次默认值与手机端共用(@cindy/maker-shared/orca-team)。
export const DEFAULT_WORKER_CREATION_PREFS: WorkerCreationPrefs = {
lastAgent: DEFAULT_ORCA_WORKER_AGENT,
codex: { model: DEFAULT_ORCA_WORKER_MODELS.codex, effort: DEFAULT_ORCA_WORKER_EFFORT as Effort, fast: false, providerId: null },
@@ -80,12 +88,36 @@ export function readWorkerCreationPrefs(): WorkerCreationPrefs {
'claude-code': agentPrefs('claude-code'),
pi: agentPrefs('pi'),
workerPermissionMode: resolveOrcaWorkerPermissionMode(parsed.workerPermissionMode),
+ modelSelectionByHost: readModelSelections(parsed.modelSelectionByHost),
};
} catch {
return defaultPrefs();
}
}
+function readModelSelections(value: unknown): Record<string, WorkerModelSelection> {
+ if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+ return Object.fromEntries(Object.entries(value).flatMap(([host, selection]) => {
+ if (!selection || typeof selection !== 'object') return [];
+ const item = selection as Partial<WorkerModelSelection>;
+ if (
+ (item.agent !== 'codex' && item.agent !== 'claude-code' && item.agent !== 'pi')
+ || typeof item.model !== 'string' || !item.model.trim()
+ || typeof item.effort !== 'string'
+ || (item.agentDeviceId !== null && (typeof item.agentDeviceId !== 'string' || !item.agentDeviceId.trim()))
+ || (item.providerId !== null && (typeof item.providerId !== 'string' || !item.providerId.trim()))
+ ) return [];
+ return [[host, {
+ agent: item.agent,
+ agentDeviceId: item.agentDeviceId,
+ model: item.model,
+ effort: item.effort,
+ fast: item.fast === true,
+ providerId: item.providerId,
+ }]];
+ }));
+}
+
export function writeWorkerCreationPrefs(prefs: WorkerCreationPrefs): void {
try {
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(prefs));
diff --git a/apps/mobile/app/sessions/new.tsx b/apps/mobile/app/sessions/new.tsx
index 387ff337dc..73d606cd8a 100644
--- a/apps/mobile/app/sessions/new.tsx
+++ b/apps/mobile/app/sessions/new.tsx
@@ -663,6 +663,7 @@ export default function NewRemoteSessionScreen() {
executionDevicesEnabled: true,
// 按区域限定的账号键:Global 与中国大陆版同号不同人,记忆(含完全访问)不能串。
prefsScope: outboxOwner.accountKey || null,
+ taskHostDeviceId: selectedDeviceId,
active: contextSheetOpen && contextSheetView === 'collab',
setSheetOpen: setContextSheetOpen,
connectionEpoch,
diff --git a/apps/mobile/src/__tests__/orcaTeam.test.ts b/apps/mobile/src/__tests__/orcaTeam.test.ts
index d77fa02d1f..3a01e47997 100644
--- a/apps/mobile/src/__tests__/orcaTeam.test.ts
+++ b/apps/mobile/src/__tests__/orcaTeam.test.ts
@@ -429,6 +429,10 @@ describe('mobile Orca collaboration mutations', () => {
// 来源 A 仍可路由 → 原样;A 断开、B 仍提供同名模型 → 清掉来源交给被控端默认路由。
expect(narrowOrcaWorkerProvider(chosen, [provider('a'), provider('b')])).toBe(chosen);
expect(narrowOrcaWorkerProvider(chosen, [provider('a', false), provider('b')]).model?.providerId).toBeNull();
+ // 完整手动路线恢复后不可因旧来源断开而换凭证;原用例只覆盖旧版无位置的偏好。
+ // unit:同模型另有可用来源时,创建边界仍收到用户原选来源并明确拒绝。
+ const explicit = { ...chosen, modelSelectionExplicit: true };
+ expect(narrowOrcaWorkerProvider(explicit, [provider('a', false), provider('b')])).toBe(explicit);
// 目录未就绪时不猜。
expect(narrowOrcaWorkerProvider(chosen, null)).toBe(chosen);
});
diff --git a/apps/mobile/src/__tests__/orcaWorkerPrefs.test.ts b/apps/mobile/src/__tests__/orcaWorkerPrefs.test.ts
index 6f5ade781b..2a95d76e7d 100644
--- a/apps/mobile/src/__tests__/orcaWorkerPrefs.test.ts
+++ b/apps/mobile/src/__tests__/orcaWorkerPrefs.test.ts
@@ -41,7 +41,10 @@ describe('Worker creation preferences', () => {
lastAgent: 'nope',
agents: { pi: { model: 'my-model', effort: '', fast: 'yes' } },
workerPermissionMode: 'auto',
+ // unit:sanitize 旧记录缺少位置/来源时丢弃完整路线;原有覆盖仅检查逐 Agent 字段。
+ modelSelectionByHost: { host: { agent: 'pi', model: { id: 'model', effort: 'high' } } },
});
+ expect(prefs.modelSelectionByHost).toEqual({});
expect(prefs.lastAgent).toBe('codex');
expect(prefs.agents.pi).toEqual({ model: 'my-model', effort: 'high', fast: false });
expect(prefs.agents.codex.model).toBe('codex/gpt-5.5');
diff --git a/apps/mobile/src/__tests__/useOrcaWorkerForm.test.tsx b/apps/mobile/src/__tests__/useOrcaWorkerForm.test.tsx
index 2104c2c263..99a5348232 100644
--- a/apps/mobile/src/__tests__/useOrcaWorkerForm.test.tsx
+++ b/apps/mobile/src/__tests__/useOrcaWorkerForm.test.tsx
@@ -21,7 +21,7 @@ vi.mock('@/session/ContextSheetCollabView', () => ({
vi.mock('@/session/fullAccessConfirmation', () => ({ confirmFullAccessChange: async () => true }));
const { useOrcaWorkerForm } = await import('@/session/useSessionOrcaCollab');
-const { resetOrcaWorkerCreationPrefsMemory, saveOrcaWorkerCreationPrefs, defaultOrcaWorkerCreationPrefs } =
+const { resetOrcaWorkerCreationPrefsMemory, saveOrcaWorkerCreationPrefs, defaultOrcaWorkerCreationPrefs, readOrcaWorkerCreationPrefs } =
await import('@/session/orcaWorkerPrefs');
let root: Root;
@@ -46,13 +46,13 @@ function fakeMaker(): MobileMakerTransport {
} as unknown as MobileMakerTransport;
}
-function ExecutionProbe({ maker, target }: { maker: MobileMakerTransport; target: (id: string) => MobileMakerTransport }) {
- latest = useOrcaWorkerForm({ maker, executionMakerForDevice: target, executionDevicesEnabled: true, prefsScope: 'user-1', active: true, setSheetOpen: () => undefined });
+function ExecutionProbe({ maker, target, enabled = true }: { maker: MobileMakerTransport; target: (id: string) => MobileMakerTransport; enabled?: boolean }) {
+ latest = useOrcaWorkerForm({ maker, executionMakerForDevice: target, executionDevicesEnabled: enabled, prefsScope: 'user-1', active: true, setSheetOpen: () => undefined });
return null;
}
it('reads selectable devices from the Lead and reads Agent/model capabilities from the chosen device', async () => {
- const lead = { ...fakeMaker(), orca: { listExecutionDevices: vi.fn(async () => ({ devices: [
+ const lead = { ...fakeMaker(), listAvailableAgents: vi.fn(async () => ['codex']), orca: { listExecutionDevices: vi.fn(async () => ({ devices: [
{ deviceId: 'b', name: 'B', supported: true }, { deviceId: 'old', supported: false },
] })) } } as unknown as MobileMakerTransport;
const remote = { ...fakeMaker(), listAvailableAgents: vi.fn(async () => ['pi']), getCapabilities: vi.fn(async () => ({ availableModels: [model('b-model')] })) } as unknown as MobileMakerTransport;
@@ -71,6 +71,12 @@ it('reads selectable devices from the Lead and reads Agent/model capabilities fr
expect(latest!.form.remoteDir).toBe('');
await act(async () => { latest!.patch({ executionDeviceId: 'old' }); await flush(); });
expect(latest!.valid).toBe(false);
+ // 同一标记的自动默认分支:撤掉运行设备后需按 Lead 的目录重新收敛,不能残留远端显式选行标记。
+ await act(async () => { latest!.patch({ executionDeviceId: 'b' }); await flush(); });
+ await act(async () => { await latest!.modelPicker.select({ agent: 'pi', modelId: 'b-model', providerId: 'b-provider', effort: '', fast: false }); });
+ await act(async () => { root.render(<ExecutionProbe maker={lead} target={target} enabled={false} />); await flush(); });
+ expect(latest!.form.executionDeviceId).toBeUndefined();
+ expect(latest!.form.agent).toBe('codex');
});
it('does not let a late capability response from A overwrite a model chosen on B', async () => {
@@ -88,9 +94,9 @@ it('does not let a late capability response from A overwrite a model chosen on B
expect(latest!.modelPicker.flatModelOptions.map((option) => option.id)).toEqual(['b-model']);
});
-function LocationProbe({ maker, lead, selectable }: { maker: MobileMakerTransport; lead: string | null; selectable: boolean }) {
+function LocationProbe({ maker, lead, selectable, host = 'host-a', scope = 'user-1', sshRemote = false }: { maker: MobileMakerTransport; lead: string | null; selectable: boolean; host?: string; scope?: string; sshRemote?: boolean }) {
latest = useOrcaWorkerForm({
- maker, prefsScope: 'user-1', active: true, setSheetOpen: () => undefined,
+ maker, prefsScope: scope, taskHostDeviceId: host, sshRemote, active: true, setSheetOpen: () => undefined,
leadAgentDeviceId: lead, agentLocationSelectable: selectable,
});
return null;
@@ -127,6 +133,63 @@ it("defaults the Worker to the Lead's Agent computer and follows remote picks wi
expect(latest!.form.agentDeviceId).toBeNull();
});
+// 7af90460e2 后 reset 跟 Lead 丢失远程选择;旧用例只验证本次选行。
+// unit:经过表单 select → remember → 重新挂载,验证持久恢复及账号/任务电脑隔离。
+it.each(['agent-pc', 'share:s1', null])('remembers the submitted model route independently of the Lead (%s)', async (location) => {
+ const maker = fakeMaker();
+ const renderForm = async (lead: string | null, props = {}) => {
+ await act(async () => { root.render(<LocationProbe maker={maker} lead={lead} selectable {...props} />); await flush(); });
+ await act(async () => { latest!.reset(); await flush(); });
+ };
+ await renderForm('original-lead');
+ await act(async () => { await latest!.modelPicker.select(
+ { agent: 'pi', modelId: 'chosen-model', providerId: 'chosen-provider', effort: 'high', fast: true },
+ { deviceId: location },
+ ); });
+ await act(async () => { latest!.remember(latest!.form); await flush(); });
+ if (location) expect((await readOrcaWorkerCreationPrefs('user-1')).agents.pi.model)
+ .toBe(defaultOrcaWorkerCreationPrefs().agents.pi.model);
+ await act(async () => root.render(null));
+ resetOrcaWorkerCreationPrefsMemory();
+ await renderForm('new-lead');
+ expect(latest!.form).toMatchObject({ agent: 'pi', agentDeviceId: location,
+ model: { id: 'chosen-model', providerId: 'chosen-provider', effort: 'high', fast: true } });
+ // 旧端不能兑现记住的位置时阻止提交,不跟着 Lead 静默换位置。
+ await renderForm('new-lead', { selectable: false });
+ expect(latest!.valid).toBe(false);
+ for (const props of [{ host: 'host-b' }, { scope: 'user-2' }, { sshRemote: true }]) {
+ await renderForm('new-lead', props);
+ expect(latest!.form.agentDeviceId).toBe('new-lead');
+ expect(latest!.form.model).toBeNull();
+ }
+});
+
+it('does not save cancelled picks or let a late saved route replace a new pick', async () => {
+ const AsyncStorage = (await import('@react-native-async-storage/async-storage')).default;
+ const maker = fakeMaker();
+ let release!: (value: string | null) => void;
+ vi.mocked(AsyncStorage.getItem).mockImplementation(() => new Promise((resolve) => { release = resolve; }));
+ try {
+ await act(async () => root.render(<LocationProbe maker={maker} lead="lead-pc" selectable />));
+ act(() => latest!.reset());
+ await act(async () => { await latest!.modelPicker.select(
+ { agent: 'codex', modelId: 'new-pick', providerId: 'new-source', effort: 'high', fast: false },
+ { deviceId: 'share:new' },
+ ); });
+ await act(async () => { release(JSON.stringify({
+ ...defaultOrcaWorkerCreationPrefs(), modelSelectionByHost: { 'host-a': {
+ agent: 'pi', agentDeviceId: 'share:old', model: { id: 'old', providerId: 'old', effort: 'low', fast: false },
+ } },
+ })); await flush(); });
+ expect(latest!.form).toMatchObject({ agentDeviceId: 'share:new', model: { id: 'new-pick' } });
+ await act(async () => { latest!.reset(); await flush(); });
+ expect(latest!.form).toMatchObject({ agentDeviceId: 'share:old', model: { id: 'old' } });
+ expect(storage.size).toBe(0);
+ } finally {
+ vi.mocked(AsyncStorage.getItem).mockImplementation(async (key) => storage.get(key) ?? null);
+ }
+});
+
it('leaves the Worker location unset when the controlled computer cannot honor it', async () => {
await act(async () => { root.render(<LocationProbe maker={fakeMaker()} lead="agent-pc" selectable={false} />); await flush(); });
await act(async () => { latest!.reset(); await flush(); });
@@ -274,6 +337,11 @@ it('restores the last Agent and its remembered model, and drops models the compu
await act(async () => { latest!.changeAgent('codex'); await flush(); });
expect(latest!.form.model).toEqual({ id: 'codex/gpt-5.5', providerId: null, effort: 'high', fast: false });
+ // 本次完整记忆标记引入的回归:原用例只测 reset;unit 最小输入为切回旧模型已下架的 Pi。
+ // 切 Agent 自动带出的模型仍须按当前目录收敛,不能冒充显式选行而提交 retired。
+ await act(async () => { latest!.changeAgent('pi'); await flush(); });
+ expect(latest!.form.agent).toBe('pi');
+ expect(latest!.form.model).toBeNull();
});
it('remembers the submitted choice for next time', async () => {
diff --git a/apps/mobile/src/session/orcaTeam.ts b/apps/mobile/src/session/orcaTeam.ts
index d7fe59199a..512a000eb4 100644
--- a/apps/mobile/src/session/orcaTeam.ts
+++ b/apps/mobile/src/session/orcaTeam.ts
@@ -44,6 +44,8 @@ export type { OrcaTeamWorker, OrcaCollaborationSettings, OrcaWorkerAgentKind, Or
/** 创建 Worker 表单(开启协同与追加 Worker 共用)。 */
export interface OrcaWorkerFormValue {
role: string;
+ /** 手动选择或恢复的完整路线;仅供控制端表单使用,不进入创建协议。 */
+ modelSelectionExplicit?: boolean;
agent: OrcaWorkerAgentKind;
/** null = 跟随被控端默认(该 Agent 上次新建任务的选择,回落 Lead 模型)。 */
model: { id: string; providerId: string | null; effort: string | null; fast: boolean } | null;
@@ -151,6 +153,8 @@ export function narrowOrcaWorkerProvider(
&& chatEligibleSourcesForModel(views, model.id, form.agent).some((candidate) => candidate.id === model.providerId)
? model.providerId
: null;
+ // 独立记忆不能把失效来源悄悄换成另一套凭证;保留原选择由宿主明确拒绝。
+ if (form.modelSelectionExplicit && model.providerId && providerId !== model.providerId) return form;
const narrowed = providerId === model.providerId ? form : { ...form, model: { ...model, providerId } };
const sourceId = providerId ?? effectiveSourceIdForModel(views, null, model.id, form.agent);
const provider = sourceId ? views.find((candidate) => candidate.id === sourceId) : undefined;
diff --git a/apps/mobile/src/session/orcaWorkerPrefs.ts b/apps/mobile/src/session/orcaWorkerPrefs.ts
index 4a8aab7a10..b2bfa06e68 100644
--- a/apps/mobile/src/session/orcaWorkerPrefs.ts
+++ b/apps/mobile/src/session/orcaWorkerPrefs.ts
@@ -5,7 +5,7 @@
* - 没有记忆时用共享首次默认值(Codex `codex/gpt-5.5`、high、完全访问)。
*
* 与桌面控制端一样存在发起创建的这一端(手机本地,按登录账号隔离),不读写被控端的偏好。
- * 模型来源(provider)不记:桌面控制远程设备时同样不记来源,换设备后跟随被控端默认路由。
+ * 手动提交的完整模型选择按任务所在电脑隔离,远程模型不覆盖旧版逐 Agent 记忆。
*/
import AsyncStorage from '@react-native-async-storage/async-storage';
import {
@@ -27,7 +27,14 @@ export interface OrcaWorkerAgentPrefs {
fast: boolean;
}
+export interface OrcaWorkerModelSelection {
+ agent: OrcaWorkerAgentKind;
+ agentDeviceId: string | null;
+ model: { id: string; providerId: string | null; effort: string | null; fast: boolean };
+}
+
export interface OrcaWorkerCreationPrefs {
+ modelSelectionByHost?: Record<string, OrcaWorkerModelSelection>;
lastAgent: OrcaWorkerAgentKind;
agents: Record<OrcaWorkerAgentKind, OrcaWorkerAgentPrefs>;
workerPermissionMode: OrcaWorkerPermissionMode;
@@ -64,7 +71,20 @@ export function sanitizeOrcaWorkerCreationPrefs(value: unknown): OrcaWorkerCreat
fast: item?.fast === true,
};
};
+ const selections = record(raw.modelSelectionByHost);
+ const modelSelectionByHost = Object.fromEntries(Object.entries(selections ?? {}).flatMap(([host, value]) => {
+ const item = record(value);
+ const model = record(item?.model);
+ if (!item || !model || !AGENTS.includes(item.agent as OrcaWorkerAgentKind)
+ || (item.agentDeviceId !== null && (typeof item.agentDeviceId !== 'string' || !item.agentDeviceId.trim()))
+ || typeof model.id !== 'string' || !model.id.trim()
+ || (model.providerId !== null && (typeof model.providerId !== 'string' || !model.providerId.trim()))
+ || (model.effort !== null && typeof model.effort !== 'string')) return [];
+ return [[host, { agent: item.agent as OrcaWorkerAgentKind, agentDeviceId: item.agentDeviceId,
+ model: { id: model.id, providerId: model.providerId, effort: model.effort, fast: model.fast === true } }]];
+ })) as Record<string, OrcaWorkerModelSelection>;
return {
+ ...(selections ? { modelSelectionByHost } : {}),
lastAgent: AGENTS.includes(raw.lastAgent as OrcaWorkerAgentKind)
? raw.lastAgent as OrcaWorkerAgentKind
: defaults.lastAgent,
@@ -119,6 +139,9 @@ export function saveOrcaWorkerCreationPrefs(scope: string, prefs: OrcaWorkerCrea
export interface OrcaWorkerSubmittedChoice {
agent: OrcaWorkerAgentKind;
permissionMode: OrcaWorkerPermissionMode;
+ /** 只有完整手动选择带 host;旧版逐 Agent 偏好仍可单独更新。 */
+ taskHostDeviceId?: string;
+ selection?: OrcaWorkerModelSelection;
model: { id: string; effort: string | null; fast: boolean } | null;
}
@@ -129,6 +152,9 @@ export function mergeOrcaWorkerChoice(
): OrcaWorkerCreationPrefs {
return {
...previous,
+ ...(submitted.taskHostDeviceId && submitted.selection ? {
+ modelSelectionByHost: { ...previous.modelSelectionByHost, [submitted.taskHostDeviceId]: submitted.selection },
+ } : {}),
lastAgent: submitted.agent,
workerPermissionMode: submitted.permissionMode,
agents: submitted.model
diff --git a/apps/mobile/src/session/useSessionOrcaCollab.ts b/apps/mobile/src/session/useSessionOrcaCollab.ts
index 7e383eb64a..fa2c8d385e 100644
--- a/apps/mobile/src/session/useSessionOrcaCollab.ts
+++ b/apps/mobile/src/session/useSessionOrcaCollab.ts
@@ -269,8 +269,8 @@ export function useOrcaWorkerLeadSessionId(params: {
/**
* Worker 表单状态(与桌面 CreateWorkerPopover 同一套记忆规则,见 orcaWorkerPrefs):
* 打开表单时恢复上次的 Agent 与该 Agent 的模型 / 推理强度 / Fast、权限;切 Agent 时带出
- * 该 Agent 上次的选择;提交成功后调用 remember() 写回。记住的模型在当前电脑上不可用时
- * 回落「默认」(交给被控端解析)。
+ * 该 Agent 上次的选择;提交成功后调用 remember() 写回。完整手动选择按账号 / 任务电脑隔离,
+ * 不随 Lead 变化;旧版逐 Agent 记忆仍按当前电脑能力收敛。
*
* 模型选择器与 + 面板是两个 sheet(iOS 原生 sheet 不能叠开):选模型前收起面板,
* 选择器完全收起后再展开面板回到表单。
@@ -281,6 +281,8 @@ export function useOrcaWorkerForm(params: {
executionMakerForDevice?: (deviceId: string) => MobileMakerTransport;
/** 记忆按登录账号隔离;null = 未登录,不读写记忆(用首次默认值)。 */
prefsScope: string | null;
+ taskHostDeviceId?: string | null;
+ sshRemote?: boolean;
active: boolean;
setSheetOpen(open: boolean): void;
/** 隧道重连代次:断线时 Agent 列表 / 模型能力读失败,重连后在打开的表单上重读一次。 */
@@ -293,7 +295,7 @@ export function useOrcaWorkerForm(params: {
*/
agentLocationSelectable?: boolean;
}) {
- const { maker, prefsScope, active, setSheetOpen, connectionEpoch } = params;
+ const { maker, prefsScope, active, setSheetOpen, connectionEpoch, taskHostDeviceId, sshRemote } = params;
const leadAgentDeviceIdRef = useRef(params.leadAgentDeviceId ?? null);
leadAgentDeviceIdRef.current = params.leadAgentDeviceId ?? null;
const agentLocationSelectableRef = useRef(params.agentLocationSelectable === true);
@@ -344,6 +346,8 @@ export function useOrcaWorkerForm(params: {
const formEpochRef = useRef(0);
const convergeGenRef = useRef(0);
+ const hostRef = useRef(taskHostDeviceId);
+ hostRef.current = taskHostDeviceId;
const prefsScopeRef = useRef(prefsScope);
prefsScopeRef.current = prefsScope;
@@ -356,7 +360,7 @@ export function useOrcaWorkerForm(params: {
setExecutionDevices([]);
setExecutionDevicesError(null);
setForm((current) => current.executionDeviceId
- ? { ...current, executionDeviceId: undefined, remoteDirMode: undefined, remoteDir: undefined, model: null }
+ ? { ...current, executionDeviceId: undefined, remoteDirMode: undefined, remoteDir: undefined, model: null, modelSelectionExplicit: false }
: current);
}
}, [maker, params.executionDevicesEnabled]);
@@ -388,6 +392,7 @@ export function useOrcaWorkerForm(params: {
convergeGenRef.current += 1;
prefsLoadedRef.current = false;
prefsRef.current = defaultOrcaWorkerCreationPrefs();
+ setForm(withLeadLocation(orcaWorkerFormFromPrefs(prefsRef.current, prefsRef.current.lastAgent)));
if (!prefsScope) {
prefsLoadedRef.current = true;
return undefined;
@@ -401,7 +406,7 @@ export function useOrcaWorkerForm(params: {
prefsLoadedRef.current = hasLoadedOrcaWorkerCreationPrefs(scope);
});
return () => { cancelled = true; };
- }, [prefsScope]);
+ }, [prefsScope, taskHostDeviceId, withLeadLocation]);
/**
@@ -421,7 +426,7 @@ export function useOrcaWorkerForm(params: {
}
if (generation !== convergeGenRef.current || makerRef.current !== source) return;
// Agent 在另一台电脑(远程供应商)时模型属于那台的目录,不按被控电脑的能力收敛。
- setForm((current) => (current.agent === agent && !orcaWorkerAgentElsewhere(current)
+ setForm((current) => (current.agent === agent && !current.modelSelectionExplicit && !orcaWorkerAgentElsewhere(current)
? { ...current, model: convergeOrcaWorkerModel(current.model, capabilities) }
: current));
})
@@ -456,6 +461,8 @@ export function useOrcaWorkerForm(params: {
setAgents(next);
// 目标 Agent:用户明确选过就尊重其选择;否则按记忆的上次 Agent(复位时可能因列表
// 还是乐观 / 上一台电脑的而落在别的 Agent 上)。不在这台电脑上时取第一个可用。
+ // 记住的路线由其所属电脑校验,不能被任务电脑的 Agent 列表改写。
+ if (formRef.current.modelSelectionExplicit || orcaWorkerAgentElsewhere(formRef.current)) return;
const current = formRef.current.agent;
const remembered = prefsRef.current.lastAgent;
const wanted = !agentChosenRef.current && next.includes(remembered) ? remembered : current;
@@ -496,9 +503,15 @@ export function useOrcaWorkerForm(params: {
agentChosenRef.current = false;
setCustomRoleMode(false);
const apply = (prefs: OrcaWorkerCreationPrefs) => {
+ const selection = !sshRemote && taskHostDeviceId ? prefs.modelSelectionByHost?.[taskHostDeviceId] : undefined;
const available = agentsRef.current;
- const agent = available.includes(prefs.lastAgent) ? prefs.lastAgent : available[0] ?? prefs.lastAgent;
- setForm(withLeadLocation(orcaWorkerFormFromPrefs(prefs, agent)));
+ const agent = selection?.agent ?? (available.includes(prefs.lastAgent) ? prefs.lastAgent : available[0] ?? prefs.lastAgent);
+ agentChosenRef.current = !!selection;
+ setForm(selection ? {
+ ...orcaWorkerFormFromPrefs(prefs, agent),
+ ...selection,
+ modelSelectionExplicit: true,
+ } : withLeadLocation(orcaWorkerFormFromPrefs(prefs, agent)));
converge(agent);
};
apply(prefsRef.current);
@@ -506,14 +519,14 @@ export function useOrcaWorkerForm(params: {
if (!prefsLoadedRef.current && prefsScope) {
const scope = prefsScope;
void readOrcaWorkerCreationPrefs(scope).then((prefs) => {
- if (prefsScopeRef.current !== scope) return;
+ if (prefsScopeRef.current !== scope || hostRef.current !== taskHostDeviceId) return;
prefsRef.current = prefs;
prefsLoadedRef.current = hasLoadedOrcaWorkerCreationPrefs(scope);
if (epoch !== formEpochRef.current || touchedRef.current) return;
apply(prefs);
});
}
- }, [converge, prefsScope, withLeadLocation]);
+ }, [converge, prefsScope, sshRemote, taskHostDeviceId, withLeadLocation]);
/** 切 Agent:带出该 Agent 上次的模型 / 推理强度 / Fast(对齐桌面)。 */
const changeAgent = useCallback((agent: OrcaWorkerAgentKind) => {
@@ -523,6 +536,8 @@ export function useOrcaWorkerForm(params: {
setForm((current) => ({
...current,
agent,
+ // 自动带出的旧模型仍要按当前目录收敛,不能沿用上一行的显式选择标记。
+ modelSelectionExplicit: false,
// 本机记忆的模型只属于被控电脑的目录;Agent 在另一台电脑时回到「默认」。
model: orcaWorkerAgentElsewhere(current)
? null
@@ -533,8 +548,16 @@ export function useOrcaWorkerForm(params: {
/** 提交成功后写回记忆(与桌面一样只在提交时记);读—合并—写由 rememberOrcaWorkerChoice 一处完成。 */
const remember = useCallback((choice: OrcaWorkerFormValue) => {
- // 另一台电脑(远程供应商)目录里的模型不进本机 Worker 记忆,只记 Agent 与权限(与桌面同规则)。
- const submitted = orcaWorkerAgentElsewhere(choice) ? { ...choice, model: null } : choice;
+ if (prefsScopeRef.current !== prefsScope || hostRef.current !== taskHostDeviceId) return;
+ // 完整路线按任务电脑隔离,运行设备与 SSH 不进入这份记忆。
+ const submitted = {
+ ...choice,
+ model: orcaWorkerAgentElsewhere(choice) || choice.executionDeviceId ? null : choice.model,
+ ...(!sshRemote && taskHostDeviceId && choice.modelSelectionExplicit && choice.model && !choice.executionDeviceId ? {
+ taskHostDeviceId,
+ selection: { agent: choice.agent, agentDeviceId: choice.agentDeviceId === undefined ? leadAgentDeviceIdRef.current : choice.agentDeviceId, model: choice.model },
+ } : {}),
+ };
prefsRef.current = mergeOrcaWorkerChoice(prefsRef.current, submitted);
if (!prefsScope) return;
const scope = prefsScope;
@@ -543,7 +566,7 @@ export function useOrcaWorkerForm(params: {
prefsRef.current = next;
prefsLoadedRef.current = hasLoadedOrcaWorkerCreationPrefs(scope);
});
- }, [prefsScope]);
+ }, [prefsScope, sshRemote, taskHostDeviceId]);
const patch = useCallback((next: Partial<OrcaWorkerFormValue>) => {
touchedRef.current = true;
@@ -554,6 +577,7 @@ export function useOrcaWorkerForm(params: {
...current,
...next,
model: null,
+ modelSelectionExplicit: false,
remoteDirMode: 'dialogue',
remoteDir: '',
agentDeviceId: current.agentDeviceId === undefined ? undefined : null,
@@ -586,6 +610,7 @@ export function useOrcaWorkerForm(params: {
setForm((current) => ({
...current,
agent: config.agent as OrcaWorkerAgentKind,
+ modelSelectionExplicit: true,
model: {
id: config.modelId,
providerId: config.providerId || null,
@@ -639,6 +664,8 @@ export function useOrcaWorkerForm(params: {
agents,
pickerAgents,
valid: canSubmitOrcaWorkerForm(form, customRoleMode)
+ && (!form.modelSelectionExplicit || params.agentLocationSelectable === true
+ || (form.agentDeviceId ?? null) === (params.leadAgentDeviceId ?? null))
&& (!form.executionDeviceId || executionDevices.some((device) => device.deviceId === form.executionDeviceId && device.supported)),
/** 模型选择器是否列出远程供应商(被控电脑支持给 Worker 选 Agent 位置,且没选运行设备)。 */
agentLocationSelectable: params.agentLocationSelectable === true && !form.executionDeviceId,
@@ -700,6 +727,8 @@ export function useSessionOrcaCollab(params: {
executionMakerForDevice: params.executionMakerForDevice,
executionDevicesEnabled: eligible && !session?.remoteHostId && !session?.agentDeviceId,
prefsScope,
+ taskHostDeviceId: deviceId,
+ sshRemote: !!session?.remoteHostId,
active: eligible && sheetOpen && sheetView !== null,
setSheetOpen,
connectionEpoch,
diff --git a/docs/dev-rules/orca-team-architecture.md b/docs/dev-rules/orca-team-architecture.md
index 7755f36e08..96ab2b5cf6 100644
--- a/docs/dev-rules/orca-team-architecture.md
+++ b/docs/dev-rules/orca-team-architecture.md
@@ -390,7 +390,7 @@ Worker turn 被 vendor 报终止型 error,但 interrupted-turn auto-resume 仍
Worker 可以放到同账号另一台电脑(运行设备)上运行:真实任务在那台,本机只有一条不跑 Agent、`working_dir` 为空的代理任务行,`orca_workers.execution_device_id` / `remote_session_id` 记录位置。代理行承接计槽、状态机、auto-bridge 与归档,任何路径都不得在本机为它起 Agent(`bootstrapSession` 对远端 Worker 直接拒绝)、不得把它复制到其他电脑;派活、停止与存活查询经 `orcaRemoteWorkers.ts` 的 `wrapTeamDeps` 分流到运行设备,其余依赖原样透传,不另造状态机。回报靠轮询:派出的消息已进入对话(投递回执 accepted)且设备不在跑时,分页读取 user / assistant 历史,按派活 user 的 clientId 定位对应的最后一条 assistant 回复并按消息 id 去重;后续用户插话的回复和异常状态不得归给此前派活,历史读取期间的新派活不得被旧回报清除。每轮最多扫描 2000 行,预算不足时保留游标下一轮续读,不误判缺少回复;宿主 onAccepted / onAcceptedCommit 完成后才冻结回报身份并允许轮询收尾,accepted 回调失败恢复上一代等待状态,保存旧结果期间不得消费新派活身份或写入其捕获文本。同一远端 Worker 的 enqueue、accepted / commit 和身份确认复用现成 session 发送锁串行执行,避免并发回调与投递顺序错位。用户在运行设备上直接发的消息算插话,不触发回报。设备不可达只是运行期投影(`executionDevice.reachable`),不扩展 `OrcaWorkerStatus`;派活时不可达直接失败,不回退到本机。首版远端 Worker 没有 `send_to_lead` 桥,也不支持 steer / 队列编辑。界面:创建弹窗的「运行设备」只在本机 Lead 上出现(`CreateWorkerPopover` 的 `executionDevicesEnabled`),复用标准下拉列表,以有界滚动和键盘按名称定位应对多设备;选了其他电脑后,工作目录提供「对话 / 指定目录」,「对话」不传 `workingDir`、在运行设备创建不绑定项目的任务,「指定目录」只使用那台电脑上的绝对路径。手机版的新任务「开启协同」与 Lead「创建 Worker」共用设备下拉列表和两种目录模式;设备列表从 Lead 所在电脑读取,Agent、模型和供应商目录从所选运行设备读取。协同面板对远端 Worker 展示运行设备上的真实任务(`RemoteWorkerSessionPane`,先登记归属再读写)。实现指针:`orcaRemoteWorkerRuntime.ts`、`orcaRemoteWorkers.ts`、`orcaWorkerCreationService.ts` 的 `createRemoteWorkerInTeam`、运行设备侧 `orcaRemoteWorkerHost.ts`;协议见 `protocol-compatibility.md`「协同远端 Worker」。
11. **Worker 的 Agent 位置:远程供应商与本机供应商一视同仁(状态:不变量,2026-10-10 用户裁决)**
- 与上一条「运行设备」不同,这里任务、目录、命令与文件都留在 Lead 所在电脑,只有 Worker 的 Agent 在另一台同账号电脑或分享来的供应商上运行(与普通任务的远程 Agent 同一机制,`sessions.agent_device_id`)。每个 Worker 可以单独选位置:`OrcaWorkerCreateParams.agentDeviceId` 不传 = 跟 Lead(旧调用方、旧控制端与 MCP 省略时都走这里),`null` = 任务所在电脑,string = 那台电脑或 `share:<id>`;等于本机设备 id 时按 `null`。模型与来源按 Worker 自己的位置读目录(那台只列允许被远程调用的供应商),只有与 Lead 同一位置时才沿用 Lead 的来源(来源 id 在不同电脑上不是一回事);Agent 在另一台时不按本机的 Cindy AI key 判预算模型。那台读不到目录在占槽与启动前失败(`REMOTE_AGENT_DEVICE_UNREACHABLE` / `REMOTE_AGENT_SHARE_*`),不回退到本机。SSH Lead 与运行设备 Worker 不能再指定另一台(`INVALID_PARAMS`),插件任务只能跟 Lead 或留在任务所在电脑。入口一处一套:桌面「创建 Worker / 开启协同」弹窗与新建任务用同一个模型面板,任务所在电脑的供应商之后列其他电脑与分享(`useWorkerAgentDevices`),选中哪一行 Worker 的 Agent 就在哪运行,默认选中 Lead 的位置;选了远程就不提供运行设备,选了运行设备回到任务所在电脑。远程选择不写本机 Worker 偏好,档位记在本机为那台单独记的一份(`agentDeviceModelMemory`)。手机同口径(`useOrcaWorkerForm` 的 `agentDeviceId`,模型面板 `remote` 与新建任务同一份 `useRemoteAgentCatalogs`),被控电脑声明 `supportsOrcaWorkerAgentDevice` 时新建任务的远程供应商与协同不再互斥。Lead 的 `list_available_models` 可按 `agent_device_id` 列那里的模型并给出 `locations`,`create_worker` / `create_workers` 用同一个 `agent_device_id`。Worker 列表投影 `session.agentDeviceId`,桌面 Worker 头像叠与远程任务同款的单波纹 + 点;手机 Worker 行保持原来的状态圆点,不加远程标识(2026-10-11 用户要求维持原样)。已开始的 Lead 与 Worker 可以由用户在模型列表里换 Agent 位置(本机供应商、其他电脑、分享来的供应商一起列出),与普通任务同一套换电脑事务:选择先登记为意图,下一次发送边界全量交接后在新位置重建,协同身份不变(2026-10-16 用户裁决:任务都在本机,只换供应商所在电脑,不应排除)。运行设备 Worker 与 SSH 任务仍不开放;被控电脑上的协同任务暂不在控制端开放(旧版被控端会拒绝),手机端同样暂未开放。供应商组为任务换电脑见第 12 条。实现指针:`orcaWorkerCreationService.ts` 的 `resolveWorkerAgentDeviceId` / `agentDeviceCatalogFailure`,`register.ts` 的 `listWorkerAgentLocations` 与 `listAvailableModels`,renderer `CreateWorkerPopover.tsx`、`hooks/useWorkerAgentDevices.ts`;协议见 `protocol-compatibility.md`「协同 Worker 的 Agent 位置」。
+ 与上一条「运行设备」不同,这里任务、目录、命令与文件都留在 Lead 所在电脑,只有 Worker 的 Agent 在另一台同账号电脑或分享来的供应商上运行(与普通任务的远程 Agent 同一机制,`sessions.agent_device_id`)。每个 Worker 可以单独选位置:`OrcaWorkerCreateParams.agentDeviceId` 不传 = 跟 Lead(旧调用方、旧控制端与 MCP 省略时都走这里),`null` = 任务所在电脑,string = 那台电脑或 `share:<id>`;等于本机设备 id 时按 `null`。模型与来源按 Worker 自己的位置读目录(那台只列允许被远程调用的供应商),只有与 Lead 同一位置时才沿用 Lead 的来源(来源 id 在不同电脑上不是一回事);Agent 在另一台时不按本机的 Cindy AI key 判预算模型。那台读不到目录在占槽与启动前失败(`REMOTE_AGENT_DEVICE_UNREACHABLE` / `REMOTE_AGENT_SHARE_*`),不回退到本机。SSH Lead 与运行设备 Worker 不能再指定另一台(`INVALID_PARAMS`),插件任务只能跟 Lead 或留在任务所在电脑。入口一处一套:桌面「创建 Worker / 开启协同」弹窗与新建任务用同一个模型面板,任务所在电脑的供应商之后列其他电脑与分享(`useWorkerAgentDevices`),选中哪一行 Worker 的 Agent 就在哪运行,默认选中 Lead 的位置;选了远程就不提供运行设备,选了运行设备回到任务所在电脑。桌面手动选择模型并提交创建后,在 `workerCreationPrefs.modelSelectionByHost` 按账号与任务所在电脑保存完整选择(Agent、模型、来源、Agent 所在电脑、推理强度与 Fast),下次打开优先恢复,不被 Lead 后续换模型或换位置覆盖;未手动选择时仍跟随 Lead 的位置,取消未提交的编辑不保存。旧版逐 Agent 记忆继续可读,不推测它原先属于哪台电脑;SSH 与运行设备的临时选择不写入这份位置记忆。远程选择不覆盖旧版逐 Agent 的本机目录记忆,模型行的档位预设仍使用 `agentDeviceModelMemory`。回归见 `CreateWorkerPopover.test.tsx` 的重新打开与任务所在电脑隔离用例。手机同样支持选择 Agent 位置(`useOrcaWorkerForm` 的 `agentDeviceId`,模型面板 `remote` 与新建任务同一份 `useRemoteAgentCatalogs`),通过 `orcaWorkerPrefs.modelSelectionByHost` 在手机本地按账号与任务所在电脑保存同样的完整选择,创建成功或确认新任务协同草稿后写回;异步读取不能覆盖已编辑的表单。恢复的来源或模型不可用时保留原路线,由界面阻止或宿主明确拒绝,不静默换到别处;旧端不能兑现位置时同样拒绝。回归见 `useOrcaWorkerForm.test.tsx` 与 `orcaTeam.test.ts`。被控电脑声明 `supportsOrcaWorkerAgentDevice` 时新建任务的远程供应商与协同不再互斥。Lead 的 `list_available_models` 可按 `agent_device_id` 列那里的模型并给出 `locations`,`create_worker` / `create_workers` 用同一个 `agent_device_id`。Worker 列表投影 `session.agentDeviceId`,桌面 Worker 头像叠与远程任务同款的单波纹 + 点;手机 Worker 行保持原来的状态圆点,不加远程标识(2026-10-11 用户要求维持原样)。已开始的 Lead 与 Worker 可以由用户在模型列表里换 Agent 位置(本机供应商、其他电脑、分享来的供应商一起列出),与普通任务同一套换电脑事务:选择先登记为意图,下一次发送边界全量交接后在新位置重建,协同身份不变(2026-10-16 用户裁决:任务都在本机,只换供应商所在电脑,不应排除)。运行设备 Worker 与 SSH 任务仍不开放;被控电脑上的协同任务暂不在控制端开放(旧版被控端会拒绝),手机端同样暂未开放。供应商组为任务换电脑见第 12 条。实现指针:`orcaWorkerCreationService.ts` 的 `resolveWorkerAgentDeviceId` / `agentDeviceCatalogFailure`,`register.ts` 的 `listWorkerAgentLocations` 与 `listAvailableModels`,renderer `CreateWorkerPopover.tsx`、`hooks/useWorkerAgentDevices.ts`;协议见 `protocol-compatibility.md`「协同 Worker 的 Agent 位置」。
12. **协同任务归供应商组,换电脑不丢回报(状态:不变量,2026-10-10 用户裁决)**
Lead 与 Worker 与普通任务一样归供应商组分配、出问题时自动换电脑(产品口径见 `docs/product-rules/provider-groups.md` §6.1「协同任务」),只有审查任务仍排除(`readProviderGroupSessionRow`)。要点: