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: 手机与桌面远程新建任务优先用模型默认缓存 (#6290)

Dashb38fa5668f10
diff --git a/apps/desktop/src/renderer/__tests__/controlledDraftRemoteAgentWiring.test.ts b/apps/desktop/src/renderer/__tests__/controlledDraftRemoteAgentWiring.test.ts
index a56d738487..6549c05f61 100644
--- a/apps/desktop/src/renderer/__tests__/controlledDraftRemoteAgentWiring.test.ts
+++ b/apps/desktop/src/renderer/__tests__/controlledDraftRemoteAgentWiring.test.ts
@@ -18,6 +18,7 @@ const read = (relative: string): string =>
readFileSync(resolve(__dirname, relative), 'utf8').replace(/\r\n/g, '\n');
const draftRouteSource = read('../features/cc-agent/NewMakerDraftRoute.tsx');
+const remoteDraftHooksSource = read('../features/cc-agent/useRemoteDraftDefaults.ts');
const chatInputSource = read('../components/new-chat/ChatInput.tsx');
describe('草稿页:建到被控电脑的任务也能选第三台电脑', () => {
@@ -66,7 +67,7 @@ describe('草稿页:建到被控电脑的任务也能选第三台电脑', () =>
const invoke = draftRouteSource.indexOf("'maker:apply-new-maker-draft-pref'", push);
expect(guard).toBeGreaterThan(push);
expect(invoke).toBeGreaterThan(guard);
- expect(draftRouteSource).toContain('if (capabilities && !effectiveAgentDeviceId) {');
+ expect(remoteDraftHooksSource).toContain('if (capabilities && !effectiveAgentDeviceId) {');
});
it('权限在被控电脑上生效:换 Agent 所在电脑沿用被控电脑草稿的权限档,被夹掉时也不掺本机偏好', () => {
diff --git a/apps/desktop/src/renderer/__tests__/newMakerProjectPicker.test.ts b/apps/desktop/src/renderer/__tests__/newMakerProjectPicker.test.ts
index 660768f30f..034baa4594 100644
--- a/apps/desktop/src/renderer/__tests__/newMakerProjectPicker.test.ts
+++ b/apps/desktop/src/renderer/__tests__/newMakerProjectPicker.test.ts
@@ -19,6 +19,7 @@ const readSource = (...segments: string[]): string =>
readFileSync(resolve(__dirname, '..', ...segments), 'utf8').replace(/\r\n?/g, '\n');
const newMakerDraftRouteSource = readSource('features', 'cc-agent', 'NewMakerDraftRoute.tsx');
+const remoteDefaultsSource = readSource('features', 'cc-agent', 'useRemoteDraftDefaults.ts');
const ccAgentSessionViewSource = readSource('features', 'cc-agent', 'CCAgentSessionView.tsx');
const worktreeChipsSource = readSource('components', 'new-chat', 'WorktreeChipsRow.tsx');
@@ -944,7 +945,7 @@ describe('Shared create project picker', () => {
});
// 远程模型目录的 loading / error 与草稿默认值都是创建前置条件:任一路径没就绪
- // 都不能把兜底值提交给对端;真实读取失败还必须告知用户,不能在 loading=false 后放行。
+ // 都不能把兜底值提交给对端;无缓存首读失败必须告知用户,不能在 loading=false 后放行。
it('blocks send and goal creation until remote models/defaults are ready, including terminal errors', () => {
expect(newMakerDraftRouteSource).toContain(
'capabilitiesError || (deviceProvidersError && !deviceProvidersUnsupported)',
@@ -966,7 +967,8 @@ describe('Shared create project picker', () => {
"throw new Error(t('ccAgent.draft.remoteDefaultsLoadFailed'))",
);
expect(newMakerDraftRouteSource).toContain('setRemoteDraftRetryEpoch((value) => value + 1)');
- expect(newMakerDraftRouteSource).toContain("status: unsupported ? 'ready' : 'error'");
+ // 首读失败阻止创建、有缓存时刷新失败保留可用状态:由 remoteDraftDefaultsCache.test.tsx
+ // 执行真实页面 hooks 验证,不再将所有读取失败都静态锁定为 error。
expect(newMakerDraftRouteSource).toContain(
"if (extractIpcError(error)?.code === 'DEVICE_LINK_CHANNEL_NOT_ALLOWED') return null;",
);
@@ -1636,12 +1638,12 @@ describe('Shared create project picker', () => {
});
it('uses the selected provider catalog for remote effort recalculation', () => {
- const pushStart = newMakerDraftRouteSource.indexOf(
+ const pushStart = remoteDefaultsSource.indexOf(
'const re = resolveDeviceLinkDraftDefaults(',
);
- const pushBlock = newMakerDraftRouteSource.slice(
+ const pushBlock = remoteDefaultsSource.slice(
pushStart,
- newMakerDraftRouteSource.indexOf('return { ...prev', pushStart),
+ remoteDefaultsSource.indexOf('return { ...prev', pushStart),
);
const modelSwitchStart = newMakerDraftRouteSource.indexOf(
'const resolved = resolveDeviceLinkDraftDefaults(',
@@ -1663,9 +1665,9 @@ describe('Shared create project picker', () => {
});
it('reapplies refreshed regional defaults only while the remote runtime is untouched', () => {
- const seed = newMakerDraftRouteSource.slice(
- newMakerDraftRouteSource.indexOf('// seed dlSel:'),
- newMakerDraftRouteSource.indexOf('// 远程草稿展示用:'),
+ const seed = remoteDefaultsSource.slice(
+ remoteDefaultsSource.indexOf('export function useRemoteDraftSelection('),
+ remoteDefaultsSource.indexOf('export function useRemoteDraftPush('),
);
expect(seed).toContain('shouldReseedDeviceLinkDraftDefaults({');
expect(seed).toContain('capabilitiesChanged,');
@@ -1700,9 +1702,9 @@ describe('Shared create project picker', () => {
* 或「永远判不成新目标」)。
*/
it('advances the device-link seed key to the engine the user just picked', () => {
- const seed = newMakerDraftRouteSource.slice(
- newMakerDraftRouteSource.indexOf('// seed dlSel:'),
- newMakerDraftRouteSource.indexOf('// 远程草稿展示用:'),
+ const seed = remoteDefaultsSource.slice(
+ remoteDefaultsSource.indexOf('export function useRemoteDraftSelection('),
+ remoteDefaultsSource.indexOf('export function useRemoteDraftPush('),
);
// 播种 effect 侧的 key 构造(正本)。
expect(seed).toContain('const key = `${catalogDeviceId}:${capabilityAgentKind}`;');
diff --git a/apps/desktop/src/renderer/__tests__/newMakerWorktreeSend.test.ts b/apps/desktop/src/renderer/__tests__/newMakerWorktreeSend.test.ts
index a30f894966..c2b69ac918 100644
--- a/apps/desktop/src/renderer/__tests__/newMakerWorktreeSend.test.ts
+++ b/apps/desktop/src/renderer/__tests__/newMakerWorktreeSend.test.ts
@@ -199,20 +199,8 @@ describe('NewMakerDraftRoute worktree send flow', () => {
expect(silentCatch).toBeGreaterThan(handoff);
});
- it('retries remote draft defaults after the relay or selected workstation reconnects', () => {
- const epochHook = source.indexOf('useDeviceLinkReconnectEpoch(');
- const defaultsFetch = source.indexOf("'maker:get-new-maker-defaults'", epochHook);
- const effectDependencies = source.indexOf('remoteDraftRefreshEpoch,', defaultsFetch);
- const transientPreserve = source.indexOf(
- 'value: unsupported ? null : previous.value',
- defaultsFetch,
- );
-
- expect(epochHook).toBeGreaterThan(-1);
- expect(defaultsFetch).toBeGreaterThan(epochHook);
- expect(effectDependencies).toBeGreaterThan(defaultsFetch);
- expect(transientPreserve).toBeGreaterThan(defaultsFetch);
- });
+ // Reconnect/default preservation is exercised through the production hooks
+ // in remoteDraftDefaultsCache.test.tsx, rather than source ordering.
it('does not auto-send if the prepared session is no longer active', () => {
const worktreeCreate = source.indexOf('window.electronAPI.worktreeCreate');
diff --git a/apps/desktop/src/renderer/__tests__/scheduleDefaultModel.test.ts b/apps/desktop/src/renderer/__tests__/scheduleDefaultModel.test.ts
index fa194be1e0..2d982dde7b 100644
--- a/apps/desktop/src/renderer/__tests__/scheduleDefaultModel.test.ts
+++ b/apps/desktop/src/renderer/__tests__/scheduleDefaultModel.test.ts
@@ -125,6 +125,21 @@ function seedChatDraft(ccModel?: string, opts: { chosen?: boolean } = {}): void
}
describe('getScheduleDefaultModel 三级回退', () => {
+ // Unit characterization for the reported Grok default: existing tests cover
+ // schedule reads, but not whether saving a schedule changes ordinary defaults.
+ it('自动任务记住 Grok 时,不改普通新建任务的模型与来源', async () => {
+ const draft = await import('@/state/newMakerDraft');
+ draft.patchVendorPrefs('pi', { model: 'gpt-6-sol', providerId: 'openai' });
+ const before = draft.getDraft().lastByVendor.pi;
+ const { makeFormFromSchedule, rememberScheduleFormPrefs, getScheduleDefaultRoute } = await loadModule();
+ rememberScheduleFormPrefs({
+ ...makeFormFromSchedule(null), agentKind: 'pi', model: 'grok-4.7', providerId: 'xai',
+ });
+ expect(getScheduleDefaultRoute('pi')).toEqual({ model: 'grok-4.7', providerId: 'xai' });
+ expect(draft.getDraft().lastByVendor.pi).toEqual(before);
+ expect(draft.getPersistedVendorModel('pi')).toBe('gpt-6-sol');
+ });
+
it('一级:上次建任务的选择优先(即使对话侧有不同选择)', async () => {
seedSchedulePrefs('claude-haiku-4-5');
seedChatDraft('claude-opus-4-8');
diff --git a/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx b/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
index 9b892e469f..7c963dca26 100644
--- a/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
@@ -1,3 +1,4 @@
+import { useRemoteDraftDefaults, useRemoteDraftSelection, useRemoteDraftPush } from './useRemoteDraftDefaults';
import { isModelEnabled, useModelVisibilityVersion } from '@/state/modelVisibilityPrefs';
/**
* NewMakerDraftRoute —— "/cc-agent/new" 路由组件:transient draft,无后端 session。
@@ -243,9 +244,8 @@ import {
getDataOwnerGeneration,
isDataOwnerGenerationCurrent,
} from '@/contexts/dataOwnerGeneration';
-import { isDeviceLinkRemotePushCurrent } from '@/lib/remoteDataOwnerPushFence';
-import { useDeviceLinkReconnectEpoch } from '@/features/device-link/useDeviceLinkReconnectEpoch';
import { extractIpcError } from '@/utils/ipcError';
+import { rememberRemoteDraftDefaults, forgetRemoteDraftDefaults } from './remoteDraftDefaultsCache';
import { matchNavigationCommandName, tryHandleNavigationCommand } from '@/lib/navigationCommands';
import {
useAgentCapabilities,
@@ -285,7 +285,6 @@ import {
import { isSubscriptionDirectModel } from '../../../shared/subscriptionModels';
import {
resolveDeviceLinkDraftDefaults,
- shouldReseedDeviceLinkDraftDefaults,
type DeviceLinkDraftSelection,
type RemoteDraftDefaults,
} from './deviceLinkDraftDefaults';
@@ -692,7 +691,7 @@ interface DraftTargetRequest {
export function NewMakerDraftRoute() {
const { t, i18n } = useTranslation();
- const { dataOwnerId } = useAuth();
+ const { dataOwnerId, dataOwnerGeneration } = useAuth();
const draft = useNewMakerDraft();
const location = useLocation();
const navigate = useNavigate();
@@ -1492,78 +1491,25 @@ export function NewMakerDraftRoute() {
// 选中模型的 model/effort/fast/permission/source 不取控制端本地(chatPrefs),改经隧道拉被控端
// 当前草稿值(maker:get-new-maker-defaults),按被控端 capabilities 校准后 seed 进一个**临时
// holder(dlSel)**;用户在远程草稿里的修改只写 dlSel,既不污染本地 newMakerDraft、也不回写被控端。
- // 只有旧版被控端明确不支持此 channel 时才回落 capabilities 默认;超时 / 断链必须保留为
- // error,不能伪装成「已读取但没有远程偏好」后放行发送。
+ // 已读过的同账号 / 设备 / 引擎默认立即复用,后台刷新;首次读取失败仍阻止创建。
// 本地草稿(无 deviceId)整段跳过,走下方 chatPrefs 路径(逐字节不变)。
- const [remoteDraftState, setRemoteDraftState] = useState<{
- status: 'idle' | 'loading' | 'ready' | 'error';
- value: RemoteDraftDefaults | null;
- }>({ status: 'idle', value: null });
- const [remoteDraftRetryEpoch, setRemoteDraftRetryEpoch] = useState(0);
- const [dlSel, setDlSel] = useState<DeviceLinkDraftSelection | null>(null);
- const dlSeedKeyRef = useRef<string | null>(null);
- const dlSeedCapabilitiesRef = useRef<AgentCapabilities | null>(null);
- /** 控制端是否编辑过当前设备 / Agent 的远程运行配置;能力刷新不得覆盖这类显式意图。 */
- const dlRuntimeTouchedRef = useRef(false);
- const skipDefaultsRefetchRef = useRef(false);
- const remoteDraftIdentityRef = useRef<string | null>(null);
- const remoteDraftRevisionRef = useRef(0);
- const remoteDraftRefreshEpoch = useDeviceLinkReconnectEpoch(
- isDeviceLinkDraft ? effectiveDeviceLinkDeviceId : undefined,
- );
-
- // 拉被控端当前草稿值。切 device/vendor 时清旧镜像;同一目标重连时后台重拉,
- // 但保留已知值直到新结果落下,避免一次瞬态失败把工作端拥有的 true 压成 false。
- useEffect(() => {
- if (!isDeviceLinkDraft || !effectiveDeviceLinkDeviceId) {
- remoteDraftIdentityRef.current = null;
- setRemoteDraftState({ status: 'idle', value: null });
- return;
- }
- const identity = `${effectiveDeviceLinkDeviceId}:${capabilityAgentKind}`;
- const sameIdentity = remoteDraftIdentityRef.current === identity;
- remoteDraftIdentityRef.current = identity;
- // handoff 路径已 inline 拉取并 set 了 remoteDraftState,跳过本次 effect 重拉。
- if (skipDefaultsRefetchRef.current) {
- skipDefaultsRefetchRef.current = false;
- return;
- }
- let cancelled = false;
- const requestRevision = remoteDraftRevisionRef.current;
- setRemoteDraftState((previous) => ({
- status: 'loading',
- value: sameIdentity ? previous.value : null,
- }));
- window.electronAPI.deviceLink
- .invoke(effectiveDeviceLinkDeviceId, 'maker:get-new-maker-defaults', [capabilityAgentKind])
- .then((v) => {
- if (!cancelled && remoteDraftRevisionRef.current === requestRevision) {
- setRemoteDraftState({
- status: 'ready',
- value: (v as RemoteDraftDefaults | null) ?? null,
- });
- }
- })
- .catch((error) => {
- if (cancelled || remoteDraftRevisionRef.current !== requestRevision) return;
- const unsupported = extractIpcError(error)?.code === 'DEVICE_LINK_CHANNEL_NOT_ALLOWED';
- // 只有确认旧端不支持时回落 capabilities 默认。超时/断链保留同目标旧镜像供展示,
- // 但状态必须是 error,发送 / 新建目标会阻止提交并触发一次显式重试。
- setRemoteDraftState((previous) => ({
- status: unsupported ? 'ready' : 'error',
- value: unsupported ? null : previous.value,
- }));
- });
- return () => {
- cancelled = true;
- };
- }, [
- isDeviceLinkDraft,
- effectiveDeviceLinkDeviceId,
- capabilityAgentKind,
+ const remoteDefaults = useRemoteDraftDefaults({
+ isDeviceLinkDraft, effectiveDeviceLinkDeviceId, capabilityAgentKind, wtPreferenceTransactionRef, dataOwnerId, dataOwnerGeneration
+ });
+ const {
+ remoteDraftState,
+ setRemoteDraftState,
+ setRemoteDraftRetryEpoch,
remoteDraftRefreshEpoch,
- remoteDraftRetryEpoch,
- ]);
+ dlSel,
+ setDlSel,
+ dlSeedKeyRef,
+ dlSeedCapabilitiesRef,
+ dlSeedDefaultsRef,
+ dlRuntimeTouchedRef,
+ skipDefaultsRefetchRef,
+ remoteDraftRevisionRef,
+ } = remoteDefaults;
// 运行 Agent 的电脑只提供模型目录:没有它的草稿默认值,改用本次运行内对这台电脑的上一次
// 选择 + 本机为这台电脑记的每模型档位(见 agentDeviceDraftMemory)。任务建到被控电脑时,权限
@@ -1592,86 +1538,11 @@ export function NewMakerDraftRoute() {
// seed dlSel:等被控端 capabilities + 草稿值都就绪后播种。切设备 / vendor 必须重种;同一目标
// 在被控端明确未选过模型且控制端未编辑时,允许 capabilities 刷新重新校准区域默认。
- useEffect(() => {
- if (!usesDeviceCatalog || !catalogDeviceId) {
- dlSeedKeyRef.current = null;
- dlSeedCapabilitiesRef.current = null;
- dlRuntimeTouchedRef.current = false;
- setDlSel(null);
- return;
- }
- // provider revision 驱逐时 hook 会保留旧快照但标 loading;必须等新代际 ready,不能用 stale
- // capabilities 把 inline handoff 或用户当前选择校准回旧目录。
- // 现代被控端还要等 provider:list;否则 flat capabilities 先播种后不会因目录到达而重校准。
- // 明确不支持该 channel 的旧端继续使用 capabilities fallback。
- const deviceProviderCatalogReady = deviceProvidersUnsupported || !deviceProvidersLoading;
- if (
- !capabilities ||
- capabilitiesLoading ||
- !deviceDraftDefaultsReady ||
- !deviceProviderCatalogReady
- ) return;
- const key = `${catalogDeviceId}:${capabilityAgentKind}`;
- const newTarget = dlSeedKeyRef.current !== key;
- const capabilitiesChanged = dlSeedCapabilitiesRef.current !== capabilities;
- if (
- !shouldReseedDeviceLinkDraftDefaults({
- currentSeedKey: dlSeedKeyRef.current,
- nextSeedKey: key,
- capabilitiesChanged,
- controllerTouched: dlRuntimeTouchedRef.current,
- remoteModelChosenByUser: deviceDraftDefaults?.modelChosenByUser,
- })
- ) {
- if (capabilitiesChanged) {
- dlSeedCapabilitiesRef.current = capabilities;
- // 显式意图只禁止“换成区域默认”,不能把已从新能力清单消失的 model / effort /
- // permission 留在草稿里。用当前控制端选择合成 active draft,只做合法性夹紧。
- setDlSel((current) =>
- current
- ? resolveDeviceLinkDraftDefaults(
- capabilities,
- {
- model: current.model,
- modelChosenByUser: true,
- effort: current.effort,
- fastMode: current.fastMode,
- permissionMode: current.permissionMode,
- providerId: current.providerId,
- },
- current.model,
- capabilityAgentKind,
- agentCatalogProviders,
- )
- : current,
- );
- }
- return;
- }
- dlSeedKeyRef.current = key;
- dlSeedCapabilitiesRef.current = capabilities;
- if (newTarget) dlRuntimeTouchedRef.current = false;
- setDlSel(
- resolveDeviceLinkDraftDefaults(
- capabilities,
- deviceDraftDefaults,
- undefined,
- capabilityAgentKind,
- agentCatalogProviders,
- ),
- );
- }, [
- usesDeviceCatalog,
- catalogDeviceId,
- capabilityAgentKind,
- agentCatalogProviders,
- capabilities,
- capabilitiesLoading,
- deviceProvidersLoading,
- deviceProvidersUnsupported,
- deviceDraftDefaultsReady,
- deviceDraftDefaults,
- ]);
+ useRemoteDraftSelection({
+ remoteDefaults, usesDeviceCatalog, catalogDeviceId, capabilityAgentKind, agentCatalogProviders,
+ capabilities, capabilitiesLoading, deviceProvidersLoading, deviceProvidersUnsupported,
+ deviceDraftDefaultsReady, deviceDraftDefaults, isAgentDeviceDraft,
+ });
// 记住这次对运行 Agent 的电脑的选择(仅本次运行),切走再切回时恢复。
useEffect(() => {
@@ -1728,42 +1599,9 @@ export function NewMakerDraftRoute() {
// 订阅被控端草稿全量变更 push:被控端本地改 / 应用控制端写穿后回流 → 刷新 remoteDraftState
// (驱动镜像 effect + 选中行还原)。控制端是纯显示,这里只更新显示态、不回写被控端。
- useEffect(() => {
- if (!isDeviceLinkDraft || !effectiveDeviceLinkDeviceId) return;
- const vendorSlot = capabilityAgentKind === 'claude-code' ? 'claudeCode' : capabilityAgentKind;
- return window.electronAPI.deviceLink.onRemotePush((push, localOwnerStamp) => {
- if (push.deviceId !== effectiveDeviceLinkDeviceId) return;
- if (!isDeviceLinkRemotePushCurrent(push, localOwnerStamp)) return;
- if (push.channel !== 'maker:new-maker-draft:changed') return;
- const payload = push.payload as Record<string, RemoteDraftDefaults | undefined> | null;
- const next = payload?.[vendorSlot] ?? null;
- remoteDraftRevisionRef.current += 1;
- setRemoteDraftState({ status: 'ready', value: next });
- // 选中行(dlSel)的 effort/fast 也跟被控端走:按当前 dlSel.model 重解析,但保留控制端的
- // permission/source/model 选择(非按模型记 / 控制端 launch 意图)。被控端改选中模型 effort 即时反映。
- // Agent 在另一台电脑运行时选中的是那台目录里的模型,档位与被控端的记忆无关,不跟。
- if (capabilities && !effectiveAgentDeviceId) {
- setDlSel((prev) => {
- if (!prev) return prev;
- const re = resolveDeviceLinkDraftDefaults(
- capabilities,
- next,
- prev.model,
- capabilityAgentKind,
- agentCatalogProviders,
- );
- return { ...prev, effort: re.effort, fastMode: re.fastMode };
- });
- }
- });
- }, [
- isDeviceLinkDraft,
- effectiveDeviceLinkDeviceId,
- effectiveAgentDeviceId,
- capabilityAgentKind,
- capabilities,
- agentCatalogProviders,
- ]);
+ useRemoteDraftPush({
+ remoteDefaults, isDeviceLinkDraft, effectiveDeviceLinkDeviceId, effectiveAgentDeviceId, capabilityAgentKind, capabilities, agentCatalogProviders, wtPreferenceTransactionRef
+ });
// ── worktree 勾选 = 工作端记忆的镜像(2026-07-29 用户裁决:状态只属于用户) ────
// 本地草稿读本地 draft.worktreeEnabled;device-link 远程草稿只接受被控端明确返回的
@@ -2045,6 +1883,9 @@ export function NewMakerDraftRoute() {
if (effectiveAgentDeviceId && !options?.taskComputerSelection) return;
const model = target?.modelId ?? dlSel?.model ?? deviceLinkInitial?.model;
if (!model) return;
+ // Until the host pushes the saved preference, do not reuse the old model on reopen.
+ remoteDraftRevisionRef.current += 1;
+ forgetRemoteDraftDefaults(effectiveDeviceLinkDeviceId);
// 只改 Fast 时也要带上激活档(被控端 trigger 要更新激活 effort)。给了显式目标就**只**
// 认目标自己的档:此刻 dlSel 里还是上一个模型的档,拿它顶上等于把 A 的档写到 B 头上;
// 目标没档就整个不下发 effort,让被控端保留它为该模型记的那份。
@@ -2309,6 +2150,7 @@ export function NewMakerDraftRoute() {
if (req.remoteSnapshot && !deviceChanged && effectiveAgentDeviceId) {
// 同一台被控电脑重新验证,但 Agent 在另一台电脑运行:草稿的模型属于那台的目录,被控电脑
// 的能力快照校准不了它(store 也不会清掉那台的选择)。只刷新被控电脑的草稿值。
+ if (req.deviceId) rememberRemoteDraftDefaults(req.deviceId, capabilityAgentKind, req.remoteSnapshot.defaults, wtPreferenceTransactionRef.current);
setRemoteDraftState({ status: 'ready', value: req.remoteSnapshot.defaults });
} else if (req.remoteSnapshot) {
const {
@@ -2321,6 +2163,7 @@ export function NewMakerDraftRoute() {
// same-device refreshes that retain a separate Agent are handled above.
dlSeedKeyRef.current = req.deviceId ? `${req.deviceId}:${capabilityAgentKind}` : null;
dlSeedCapabilitiesRef.current = freshCaps;
+ dlSeedDefaultsRef.current = freshDefaults;
if (deviceChanged) {
setDlSel(
resolveDeviceLinkDraftDefaults(
@@ -2364,6 +2207,7 @@ export function NewMakerDraftRoute() {
),
);
}
+ if (req.deviceId) rememberRemoteDraftDefaults(req.deviceId, capabilityAgentKind, freshDefaults, wtPreferenceTransactionRef.current);
setRemoteDraftState({ status: 'ready', value: freshDefaults });
} else if (deviceChanged) {
setDlSel(null);
@@ -3286,6 +3130,7 @@ export function NewMakerDraftRoute() {
setWtPreferenceSaving(true);
if (isDeviceLinkDraft && effectiveDeviceLinkDeviceId) {
remoteDraftRevisionRef.current += 1;
+ forgetRemoteDraftDefaults(effectiveDeviceLinkDeviceId);
wtPreferenceTransactionRef.current = {
seq: writeSeq,
deviceId: effectiveDeviceLinkDeviceId,
diff --git a/apps/desktop/src/renderer/features/cc-agent/__tests__/newMakerDraftTargetCatalog.test.ts b/apps/desktop/src/renderer/features/cc-agent/__tests__/newMakerDraftTargetCatalog.test.ts
index cb6556e2c0..d5b8d66cd8 100644
--- a/apps/desktop/src/renderer/features/cc-agent/__tests__/newMakerDraftTargetCatalog.test.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/__tests__/newMakerDraftTargetCatalog.test.ts
@@ -15,6 +15,7 @@ import {
type RemoteDraftDefaults,
} from '../deviceLinkDraftDefaults';
import { isSameNewMakerDevice } from '../lib/newMakerRouteState';
+import { rememberRemoteDraftDefaults } from '../remoteDraftDefaultsCache';
// Run the real async project-selection and target-transition callbacks. Only their
// React setters and IPC are replaced; catalog parsing and effort resolution stay real.
@@ -106,11 +107,12 @@ function harness(options: {
agentCatalogProviders: [provider('source', ['low'])],
isSameNewMakerDevice, normalizeDbAgentKind, resolveDeviceLinkDraftDefaults,
parseDeviceProvidersPayload, extractIpcError, patchDraft, setRemoteDraftState,
+ rememberRemoteDraftDefaults, wtPreferenceTransactionRef: { current: null },
window: { electronAPI: { deviceLink: { invoke } } },
setDlSel: (next: DeviceLinkDraftSelection | null | ((prev: DeviceLinkDraftSelection | null) => DeviceLinkDraftSelection | null)) => {
current = typeof next === 'function' ? next(current) : next;
},
- dlSeedKeyRef, dlSeedCapabilitiesRef: { current: null },
+ dlSeedKeyRef, dlSeedCapabilitiesRef: { current: null }, dlSeedDefaultsRef: { current: null },
dlRuntimeTouchedRef: { current: true }, skipDefaultsRefetchRef: { current: false },
wtBranchReadSeqRef: { current: 0 }, wtBranchWriteSeqRef: { current: 0 },
wtBranchPreferenceSavingRef: { current: false }, wtBranchTargetRef: { current: null },
diff --git a/apps/desktop/src/renderer/features/cc-agent/__tests__/remoteDraftDefaultsCache.test.tsx b/apps/desktop/src/renderer/features/cc-agent/__tests__/remoteDraftDefaultsCache.test.tsx
new file mode 100644
index 0000000000..baa85dbf01
--- /dev/null
+++ b/apps/desktop/src/renderer/features/cc-agent/__tests__/remoteDraftDefaultsCache.test.tsx
@@ -0,0 +1,149 @@
+// @vitest-environment jsdom
+import { useRemoteDraftDefaults, useRemoteDraftSelection, useRemoteDraftPush } from '../useRemoteDraftDefaults';
+import type { AgentKind, AgentCapabilities } from '@/hooks/useAgentCapabilities';
+import { act, createElement } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { getDataOwnerGeneration, setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import { forgetRemoteDraftDefaults, getRemoteDraftDefaults, rememberRemoteDraftDefaults } from '../remoteDraftDefaultsCache';
+
+// Unit regression: mount the production read/selection/push hooks, with only
+// the Electron transport replaced. Covers cache reuse and authoritative writes.
+function usePageDefaults(bindings: Parameters<typeof useRemoteDraftDefaults>[0] & { capabilities: AgentCapabilities }) {
+ const remoteDefaults = useRemoteDraftDefaults(bindings);
+ useRemoteDraftSelection({
+ remoteDefaults, usesDeviceCatalog: true, catalogDeviceId: bindings.effectiveDeviceLinkDeviceId,
+ capabilityAgentKind: bindings.capabilityAgentKind, agentCatalogProviders: [], capabilities: bindings.capabilities,
+ capabilitiesLoading: false, deviceProvidersUnsupported: true, deviceProvidersLoading: false,
+ deviceDraftDefaultsReady: remoteDefaults.remoteDraftState.status === 'ready',
+ deviceDraftDefaults: remoteDefaults.remoteDraftState.value, isAgentDeviceDraft: false,
+ });
+ useRemoteDraftPush({ ...bindings, remoteDefaults, effectiveAgentDeviceId: undefined, agentCatalogProviders: [] });
+ return { ...remoteDefaults, touch: () => { remoteDefaults.dlRuntimeTouchedRef.current = true; } };
+}
+type State = ReturnType<typeof usePageDefaults>;
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+let root: Root | undefined;
+beforeEach(() => setDataOwnerGeneration('cache-test'));
+afterEach(() => { act(() => root?.unmount()); root = undefined; vi.unstubAllGlobals(); });
+function mount(deviceId = 'host', agent: AgentKind = 'codex') {
+ act(() => root?.unmount());
+ let resolveRead!: (value: unknown) => void;
+ let rejectRead!: (error: unknown) => void;
+ const promise = new Promise((resolve, reject) => { resolveRead = resolve; rejectRead = reject; });
+ const invoke = vi.fn(() => promise);
+ let push!: (event: unknown, stamp: unknown) => void;
+ let statusChanged!: (event: { status: string }) => void;
+ Object.assign(window, { electronAPI: { deviceLink: { invoke, onPresenceChanged: () => () => {}, onStatusChanged: (callback: typeof statusChanged) => { statusChanged = callback; return () => {}; }, onRemotePush: (callback: typeof push) => { push = callback; return () => {}; } } } });
+ const bindings = {
+ isDeviceLinkDraft: true, effectiveDeviceLinkDeviceId: deviceId,
+ capabilityAgentKind: agent,
+ wtPreferenceTransactionRef: { current: null as { deviceId: string; status: string; enabled?: boolean } | null },
+ dataOwnerId: getDataOwnerGeneration().dataOwnerId,
+ dataOwnerGeneration: getDataOwnerGeneration().generation,
+ capabilities: { availableModels: ['chosen', 'new-choice', 'manual'].map(id => ({ id, displayName: id, efforts: [], contextWindow: 100_000, defaultEffort: null })), permissionModes: [], effortLevels: [], hasFastMode: false },
+ };
+ let state!: State;
+ function Harness() { state = usePageDefaults(bindings); return null; }
+ root = createRoot(document.createElement('div'));
+ const render = () => act(() => root!.render(createElement(Harness)));
+ render();
+ return { bindings, render, invoke, resolveRead, rejectRead, reconnect: () => act(() => statusChanged({ status: 'online' })), push: (value: unknown) => act(() => push({ deviceId, channel: 'maker:new-maker-draft:changed', payload: { [agent === 'claude-code' ? 'claudeCode' : agent]: value } }, { dataOwnerId: getDataOwnerGeneration().dataOwnerId, ownerGeneration: getDataOwnerGeneration().generation })), get state() { return state; } };
+}
+const defaults = (model: string) => ({ model, modelChosenByUser: true, worktreeEnabled: false });
+
+it('reopens immediately with host defaults, refreshes in the background and preserves them on failure', async () => {
+ const first = mount();
+ expect(first.state.remoteDraftState.status).toBe('loading');
+ await act(async () => first.resolveRead(defaults('chosen')));
+ const reopened = mount();
+ expect(reopened.state.remoteDraftState).toEqual({ status: 'ready', value: defaults('chosen') });
+ expect(reopened.state.dlSel?.model).toBe('chosen');
+ expect(reopened.invoke).toHaveBeenCalledTimes(1);
+ await act(async () => reopened.resolveRead(defaults('new-choice')));
+ expect(reopened.state.remoteDraftState.value?.model).toBe('new-choice');
+ expect(reopened.state.dlSel?.model).toBe('new-choice');
+ const failedRefresh = mount();
+ await act(async () => failedRefresh.rejectRead(new Error('offline')));
+ expect(failedRefresh.state.remoteDraftState).toEqual({ status: 'ready', value: defaults('new-choice') });
+ const restartingHost = mount();
+ await act(async () => restartingHost.resolveRead({}));
+ expect(restartingHost.state.remoteDraftState).toEqual({ status: 'ready', value: defaults('new-choice') });
+});
+
+it('refreshes untouched selections on push while preserving controller choices', async () => {
+ rememberRemoteDraftDefaults('host', 'codex', defaults('chosen'));
+ const page = mount();
+ page.push(defaults('new-choice'));
+ expect(page.state.dlSel?.model).toBe('new-choice');
+ page.state.touch();
+ page.push(defaults('chosen'));
+ expect(page.state.dlSel?.model).toBe('new-choice');
+});
+
+it('restarts a pending read after same-owner authentication repair', async () => {
+ const page = mount();
+ setDataOwnerGeneration('cache-test');
+ page.bindings.dataOwnerGeneration = getDataOwnerGeneration().generation;
+ page.invoke.mockImplementation(async () => defaults('new-choice'));
+ await act(async () => page.render());
+ expect(page.invoke).toHaveBeenCalledTimes(2);
+ await act(async () => page.resolveRead(defaults('chosen')));
+ expect(page.state.dlSel?.model).toBe('new-choice');
+});
+
+it.each(['writing', 'reconciling-success', 'reconciling-unknown'])('rejects stale pushes during a %s worktree transaction', async (status) => {
+ const page = mount();
+ page.bindings.wtPreferenceTransactionRef.current = { deviceId: 'host', status, enabled: true };
+ forgetRemoteDraftDefaults('host');
+ page.push(defaults('chosen'));
+ expect(getRemoteDraftDefaults('host', 'codex')).toBeUndefined();
+ page.push({ ...defaults('chosen'), worktreeEnabled: true });
+ expect(getRemoteDraftDefaults('host', 'codex')?.worktreeEnabled).toBe(true);
+});
+
+it('isolates device, engine and account, and rejects a late response from the old account', async () => {
+ rememberRemoteDraftDefaults('host', 'codex', defaults('chosen'));
+ expect(mount('other').state.remoteDraftState.status).toBe('loading');
+ expect(mount('host', 'pi').state.remoteDraftState.status).toBe('loading');
+ const old = mount();
+ setDataOwnerGeneration('new-owner');
+ await act(async () => old.resolveRead(defaults('old-owner-late')));
+ expect(getRemoteDraftDefaults('host', 'codex')).toBeUndefined();
+ expect(mount().state.remoteDraftState.status).toBe('loading');
+});
+
+it('does not use cached defaults to acknowledge a pending worktree write', async () => {
+ rememberRemoteDraftDefaults('host', 'codex', defaults('chosen'));
+ const page = mount();
+ page.bindings.wtPreferenceTransactionRef.current = { deviceId: 'host', status: 'reconciling-success' };
+ act(() => page.state.setRemoteDraftRetryEpoch(epoch => epoch + 1));
+ expect(page.state.remoteDraftState.status).toBe('loading');
+ await act(async () => page.rejectRead(new Error('offline')));
+ expect(page.state.remoteDraftState.status).toBe('error');
+ forgetRemoteDraftDefaults('host');
+ expect(getRemoteDraftDefaults('host', 'codex')).toBeUndefined();
+});
+
+it('keeps initial errors retryable and does not remember an uninitialized host snapshot', async () => {
+ const failed = mount();
+ await act(async () => failed.rejectRead(new Error('offline')));
+ expect(failed.state.remoteDraftState.status).toBe('error');
+ const empty = mount();
+ await act(async () => empty.resolveRead({}));
+ expect(getRemoteDraftDefaults('host', 'codex')).toBeUndefined();
+ const legacy = mount();
+ await act(async () => legacy.rejectRead(new Error('[DEVICE_LINK_CHANNEL_NOT_ALLOWED] unsupported')));
+ expect(legacy.state.remoteDraftState.status).toBe('ready');
+});
+
+it('refreshes after relay reconnection without hiding the cached choice', async () => {
+ rememberRemoteDraftDefaults('host', 'codex', defaults('chosen'));
+ const page = mount();
+ await act(async () => page.rejectRead(new Error('offline')));
+ page.invoke.mockImplementation(async () => defaults('new-choice'));
+ await act(async () => page.reconnect());
+ expect(page.invoke).toHaveBeenCalledTimes(2);
+ expect(page.state.remoteDraftState.status).toBe('ready');
+ expect(page.state.dlSel?.model).toBe('new-choice');
+});
diff --git a/apps/desktop/src/renderer/features/cc-agent/deviceLinkDraftDefaults.ts b/apps/desktop/src/renderer/features/cc-agent/deviceLinkDraftDefaults.ts
index 80de96f83d..902eeaba82 100644
--- a/apps/desktop/src/renderer/features/cc-agent/deviceLinkDraftDefaults.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/deviceLinkDraftDefaults.ts
@@ -67,20 +67,21 @@ export interface DeviceLinkDraftSelection {
}
/**
- * 判断同一远程草稿是否应在 capabilities 刷新后重新校准。
- * 新设备或 Agent 始终需要 seed;同一目标只有在被控端明确从未选过模型、且控制端也尚未
- * 编辑运行配置时才允许重校准。旧端的未知状态与任一侧的显式选择都必须保守保留。
+ * 新设备或 Agent 始终需要 seed;同一目标的新默认可更新未编辑的草稿。
+ * 仅能力刷新时,仍须被控端明确从未选过模型才重新选区域默认。
*/
export function shouldReseedDeviceLinkDraftDefaults(input: {
currentSeedKey: string | null;
nextSeedKey: string;
capabilitiesChanged: boolean;
+ defaultsChanged?: boolean;
controllerTouched: boolean;
remoteModelChosenByUser: boolean | undefined;
}): boolean {
if (input.currentSeedKey !== input.nextSeedKey) return true;
return (
- input.capabilitiesChanged && !input.controllerTouched && input.remoteModelChosenByUser === false
+ !input.controllerTouched && (input.defaultsChanged === true
+ || (input.capabilitiesChanged && input.remoteModelChosenByUser === false))
);
}
diff --git a/apps/desktop/src/renderer/features/cc-agent/remoteDraftDefaultsCache.ts b/apps/desktop/src/renderer/features/cc-agent/remoteDraftDefaultsCache.ts
new file mode 100644
index 0000000000..3feafd7d15
--- /dev/null
+++ b/apps/desktop/src/renderer/features/cc-agent/remoteDraftDefaultsCache.ts
@@ -0,0 +1,39 @@
+import { getDataOwnerGeneration, isDataOwnerGenerationCurrent } from '@/contexts/dataOwnerGeneration';
+import type { RemoteDraftDefaults } from './deviceLinkDraftDefaults';
+
+// Defaults are host preferences, never inferred from running/recent sessions.
+// Keep successful reads across page mounts; changing account/runtime drops them.
+let owner = getDataOwnerGeneration();
+const cache = new Map<string, RemoteDraftDefaults | null>();
+
+function currentCache() {
+ if (!isDataOwnerGenerationCurrent(owner)) {
+ cache.clear();
+ owner = getDataOwnerGeneration();
+ }
+ return cache;
+}
+
+export function getRemoteDraftDefaults(deviceId: string, agent: string): RemoteDraftDefaults | null | undefined {
+ return currentCache().get(`${deviceId}:${agent}`);
+}
+
+export function rememberRemoteDraftDefaults(
+ deviceId: string,
+ agent: string,
+ value: RemoteDraftDefaults | null,
+ transaction?: { deviceId: string; status: string; enabled?: boolean } | null,
+): void {
+ // Pull, push and inline handoff must obey the same pending-write boundary.
+ if (transaction?.deviceId === deviceId && transaction.status !== 'committed'
+ && value?.worktreeEnabled !== transaction.enabled) return;
+ // {} means the host renderer has not published its preferences yet.
+ if (value && Object.keys(value).length === 0) return;
+ currentCache().set(`${deviceId}:${agent}`, value);
+}
+
+export function forgetRemoteDraftDefaults(deviceId: string): void {
+ for (const key of currentCache().keys()) {
+ if (key.startsWith(`${deviceId}:`)) cache.delete(key);
+ }
+}
diff --git a/apps/desktop/src/renderer/features/cc-agent/useRemoteDraftDefaults.ts b/apps/desktop/src/renderer/features/cc-agent/useRemoteDraftDefaults.ts
new file mode 100644
index 0000000000..b77ee248a0
--- /dev/null
+++ b/apps/desktop/src/renderer/features/cc-agent/useRemoteDraftDefaults.ts
@@ -0,0 +1,292 @@
+import { useEffect, useRef, useState, type MutableRefObject } from 'react';
+import { getDataOwnerGeneration, isDataOwnerGenerationCurrent } from '@/contexts/dataOwnerGeneration';
+import { isDeviceLinkRemotePushCurrent } from '@/lib/remoteDataOwnerPushFence';
+import { useDeviceLinkReconnectEpoch } from '@/features/device-link/useDeviceLinkReconnectEpoch';
+import { extractIpcError } from '@/utils/ipcError';
+import type { AgentCapabilities, AgentKind } from '@/hooks/useAgentCapabilities';
+import type { ProviderView } from '@cindy/model-providers';
+import { getRemoteDraftDefaults, rememberRemoteDraftDefaults } from './remoteDraftDefaultsCache';
+import { resolveDeviceLinkDraftDefaults, shouldReseedDeviceLinkDraftDefaults, type RemoteDraftDefaults, type DeviceLinkDraftSelection } from './deviceLinkDraftDefaults';
+
+export function useRemoteDraftDefaults({
+ isDeviceLinkDraft, effectiveDeviceLinkDeviceId, capabilityAgentKind, wtPreferenceTransactionRef, dataOwnerId, dataOwnerGeneration
+}: {
+ isDeviceLinkDraft: boolean;
+ effectiveDeviceLinkDeviceId: string | undefined;
+ capabilityAgentKind: AgentKind;
+ wtPreferenceTransactionRef: MutableRefObject<Parameters<typeof rememberRemoteDraftDefaults>[3]>;
+ dataOwnerId: string | null;
+ dataOwnerGeneration: number;
+}) {
+ const [remoteDraftState, setRemoteDraftState] = useState<{
+ status: 'idle' | 'loading' | 'ready' | 'error';
+ value: RemoteDraftDefaults | null;
+ }>(() => {
+ const cached = isDeviceLinkDraft && effectiveDeviceLinkDeviceId
+ ? getRemoteDraftDefaults(effectiveDeviceLinkDeviceId, capabilityAgentKind)
+ : undefined;
+ return cached !== undefined
+ ? { status: 'ready', value: cached }
+ : { status: 'idle', value: null };
+ });
+ const [remoteDraftRetryEpoch, setRemoteDraftRetryEpoch] = useState(0);
+ const [dlSel, setDlSel] = useState<DeviceLinkDraftSelection | null>(null);
+ const dlSeedKeyRef = useRef<string | null>(null);
+ const dlSeedCapabilitiesRef = useRef<AgentCapabilities | null>(null);
+ const dlSeedDefaultsRef = useRef<RemoteDraftDefaults | null>(null);
+ /** 控制端是否编辑过当前设备 / Agent 的远程运行配置;能力刷新不得覆盖这类显式意图。 */
+ const dlRuntimeTouchedRef = useRef(false);
+ const skipDefaultsRefetchRef = useRef(false);
+ const remoteDraftIdentityRef = useRef<string | null>(null);
+ const remoteDraftRevisionRef = useRef(0);
+ const remoteDraftRefreshEpoch = useDeviceLinkReconnectEpoch(
+ isDeviceLinkDraft ? effectiveDeviceLinkDeviceId : undefined,
+ );
+
+ // 拉被控端当前草稿值。切 device/vendor 时清旧镜像;同一目标重连时后台重拉,
+ // 但保留已知值直到新结果落下,避免一次瞬态失败把工作端拥有的 true 压成 false。
+ useEffect(() => {
+ if (!isDeviceLinkDraft || !effectiveDeviceLinkDeviceId) {
+ remoteDraftIdentityRef.current = null;
+ setRemoteDraftState({ status: 'idle', value: null });
+ return;
+ }
+ const identity = `${effectiveDeviceLinkDeviceId}:${capabilityAgentKind}`;
+ const sameIdentity = remoteDraftIdentityRef.current === identity;
+ remoteDraftIdentityRef.current = identity;
+ // handoff 路径已 inline 拉取并 set 了 remoteDraftState,跳过本次 effect 重拉。
+ if (skipDefaultsRefetchRef.current) {
+ skipDefaultsRefetchRef.current = false;
+ return;
+ }
+ let cancelled = false;
+ const owner = getDataOwnerGeneration();
+ const requestRevision = remoteDraftRevisionRef.current;
+ // A worktree write requires fresh host confirmation, never a cached acknowledgement.
+ const transaction = wtPreferenceTransactionRef.current;
+ const confirmingWrite = transaction?.deviceId === effectiveDeviceLinkDeviceId
+ && transaction.status !== 'committed';
+ const cached = confirmingWrite ? undefined
+ : getRemoteDraftDefaults(effectiveDeviceLinkDeviceId, capabilityAgentKind);
+ setRemoteDraftState((previous) => ({
+ status: cached !== undefined ? 'ready' : 'loading',
+ value: cached !== undefined ? cached : sameIdentity ? previous.value : null,
+ }));
+ window.electronAPI.deviceLink
+ .invoke(effectiveDeviceLinkDeviceId, 'maker:get-new-maker-defaults', [capabilityAgentKind])
+ .then((v) => {
+ if (!cancelled && isDataOwnerGenerationCurrent(owner) && remoteDraftRevisionRef.current === requestRevision) {
+ const received = (v as RemoteDraftDefaults | null) ?? null;
+ const value = received && Object.keys(received).length === 0 && cached !== undefined
+ ? cached : received;
+ rememberRemoteDraftDefaults(effectiveDeviceLinkDeviceId, capabilityAgentKind, value, wtPreferenceTransactionRef.current);
+ setRemoteDraftState({
+ status: 'ready',
+ value,
+ });
+ }
+ })
+ .catch((error) => {
+ if (cancelled || !isDataOwnerGenerationCurrent(owner) || remoteDraftRevisionRef.current !== requestRevision) return;
+ const unsupported = extractIpcError(error)?.code === 'DEVICE_LINK_CHANNEL_NOT_ALLOWED';
+ // A failed background refresh must not discard a previously usable default.
+ // Without one (or while confirming a write), keep the original error gate.
+ setRemoteDraftState((previous) => ({
+ status: unsupported || cached !== undefined ? 'ready' : 'error',
+ value: unsupported ? null : previous.value,
+ }));
+ });
+ return () => {
+ cancelled = true;
+ };
+ }, [
+ isDeviceLinkDraft,
+ effectiveDeviceLinkDeviceId,
+ capabilityAgentKind,
+ remoteDraftRefreshEpoch,
+ remoteDraftRetryEpoch,
+ dataOwnerId,
+ dataOwnerGeneration,
+ ]);
+
+ return {
+ remoteDraftState,
+ setRemoteDraftState,
+ setRemoteDraftRetryEpoch,
+ remoteDraftRefreshEpoch,
+ dlSel,
+ setDlSel,
+ dlSeedKeyRef,
+ dlSeedCapabilitiesRef,
+ dlSeedDefaultsRef,
+ dlRuntimeTouchedRef,
+ skipDefaultsRefetchRef,
+ remoteDraftRevisionRef,
+ };
+}
+
+export function useRemoteDraftSelection({
+ remoteDefaults,
+ usesDeviceCatalog,
+ catalogDeviceId,
+ capabilityAgentKind,
+ agentCatalogProviders,
+ capabilities,
+ capabilitiesLoading,
+ deviceProvidersLoading,
+ deviceProvidersUnsupported,
+ deviceDraftDefaultsReady,
+ deviceDraftDefaults,
+ isAgentDeviceDraft,
+}: {
+ remoteDefaults: ReturnType<typeof useRemoteDraftDefaults>;
+ usesDeviceCatalog: boolean;
+ catalogDeviceId: string | undefined;
+ capabilityAgentKind: AgentKind;
+ agentCatalogProviders: ProviderView[];
+ capabilities: AgentCapabilities | null;
+ capabilitiesLoading: boolean;
+ deviceProvidersLoading: boolean;
+ deviceProvidersUnsupported: boolean;
+ deviceDraftDefaultsReady: boolean;
+ deviceDraftDefaults: RemoteDraftDefaults | null;
+ isAgentDeviceDraft: boolean;
+}) {
+ const { dlSeedKeyRef, dlSeedCapabilitiesRef, dlSeedDefaultsRef, dlRuntimeTouchedRef, setDlSel } = remoteDefaults;
+ useEffect(() => {
+ if (!usesDeviceCatalog || !catalogDeviceId) {
+ dlSeedKeyRef.current = null;
+ dlSeedCapabilitiesRef.current = null;
+ dlSeedDefaultsRef.current = null;
+ dlRuntimeTouchedRef.current = false;
+ setDlSel(null);
+ return;
+ }
+ // provider revision 驱逐时 hook 会保留旧快照但标 loading;必须等新代际 ready,不能用 stale
+ // capabilities 把 inline handoff 或用户当前选择校准回旧目录。
+ // 现代被控端还要等 provider:list;否则 flat capabilities 先播种后不会因目录到达而重校准。
+ // 明确不支持该 channel 的旧端继续使用 capabilities fallback。
+ const deviceProviderCatalogReady = deviceProvidersUnsupported || !deviceProvidersLoading;
+ if (
+ !capabilities ||
+ capabilitiesLoading ||
+ !deviceDraftDefaultsReady ||
+ !deviceProviderCatalogReady
+ ) return;
+ const key = `${catalogDeviceId}:${capabilityAgentKind}`;
+ const newTarget = dlSeedKeyRef.current !== key;
+ const capabilitiesChanged = dlSeedCapabilitiesRef.current !== capabilities;
+ if (
+ !shouldReseedDeviceLinkDraftDefaults({
+ currentSeedKey: dlSeedKeyRef.current,
+ nextSeedKey: key,
+ capabilitiesChanged,
+ defaultsChanged: !isAgentDeviceDraft && dlSeedDefaultsRef.current !== deviceDraftDefaults,
+ controllerTouched: dlRuntimeTouchedRef.current,
+ remoteModelChosenByUser: deviceDraftDefaults?.modelChosenByUser,
+ })
+ ) {
+ if (capabilitiesChanged) {
+ dlSeedCapabilitiesRef.current = capabilities;
+ // 显式意图只禁止“换成区域默认”,不能把已从新能力清单消失的 model / effort /
+ // permission 留在草稿里。用当前控制端选择合成 active draft,只做合法性夹紧。
+ setDlSel((current) =>
+ current
+ ? resolveDeviceLinkDraftDefaults(
+ capabilities,
+ {
+ model: current.model,
+ modelChosenByUser: true,
+ effort: current.effort,
+ fastMode: current.fastMode,
+ permissionMode: current.permissionMode,
+ providerId: current.providerId,
+ },
+ current.model,
+ capabilityAgentKind,
+ agentCatalogProviders,
+ )
+ : current,
+ );
+ }
+ return;
+ }
+ dlSeedKeyRef.current = key;
+ dlSeedCapabilitiesRef.current = capabilities;
+ dlSeedDefaultsRef.current = deviceDraftDefaults;
+ if (newTarget) dlRuntimeTouchedRef.current = false;
+ setDlSel(
+ resolveDeviceLinkDraftDefaults(
+ capabilities,
+ deviceDraftDefaults,
+ undefined,
+ capabilityAgentKind,
+ agentCatalogProviders,
+ ),
+ );
+ }, [
+ usesDeviceCatalog,
+ catalogDeviceId,
+ capabilityAgentKind,
+ agentCatalogProviders,
+ capabilities,
+ capabilitiesLoading,
+ deviceProvidersLoading,
+ deviceProvidersUnsupported,
+ deviceDraftDefaultsReady,
+ deviceDraftDefaults,
+ isAgentDeviceDraft,
+ ]);
+}
+
+export function useRemoteDraftPush({
+ remoteDefaults, isDeviceLinkDraft, effectiveDeviceLinkDeviceId, effectiveAgentDeviceId, capabilityAgentKind, capabilities, agentCatalogProviders, wtPreferenceTransactionRef
+}: {
+ remoteDefaults: ReturnType<typeof useRemoteDraftDefaults>;
+ isDeviceLinkDraft: boolean;
+ effectiveDeviceLinkDeviceId: string | undefined;
+ effectiveAgentDeviceId: string | undefined;
+ capabilityAgentKind: AgentKind;
+ capabilities: AgentCapabilities | null;
+ agentCatalogProviders: ProviderView[];
+ wtPreferenceTransactionRef: MutableRefObject<Parameters<typeof rememberRemoteDraftDefaults>[3]>;
+}) {
+ const { remoteDraftRevisionRef, setRemoteDraftState, setDlSel } = remoteDefaults;
+ useEffect(() => {
+ if (!isDeviceLinkDraft || !effectiveDeviceLinkDeviceId) return;
+ const vendorSlot = capabilityAgentKind === 'claude-code' ? 'claudeCode' : capabilityAgentKind;
+ return window.electronAPI.deviceLink.onRemotePush((push, localOwnerStamp) => {
+ if (push.deviceId !== effectiveDeviceLinkDeviceId) return;
+ if (!isDeviceLinkRemotePushCurrent(push, localOwnerStamp)) return;
+ if (push.channel !== 'maker:new-maker-draft:changed') return;
+ const payload = push.payload as Record<string, RemoteDraftDefaults | undefined> | null;
+ const next = payload?.[vendorSlot] ?? null;
+ remoteDraftRevisionRef.current += 1;
+ rememberRemoteDraftDefaults(effectiveDeviceLinkDeviceId, capabilityAgentKind, next, wtPreferenceTransactionRef.current);
+ setRemoteDraftState({ status: 'ready', value: next });
+ // 选中行(dlSel)的 effort/fast 也跟被控端走:按当前 dlSel.model 重解析,但保留控制端的
+ // permission/source/model 选择(非按模型记 / 控制端 launch 意图)。被控端改选中模型 effort 即时反映。
+ // Agent 在另一台电脑运行时选中的是那台目录里的模型,档位与被控端的记忆无关,不跟。
+ if (capabilities && !effectiveAgentDeviceId) {
+ setDlSel((prev) => {
+ if (!prev) return prev;
+ const re = resolveDeviceLinkDraftDefaults(
+ capabilities,
+ next,
+ prev.model,
+ capabilityAgentKind,
+ agentCatalogProviders,
+ );
+ return { ...prev, effort: re.effort, fastMode: re.fastMode };
+ });
+ }
+ });
+ }, [
+ isDeviceLinkDraft,
+ effectiveDeviceLinkDeviceId,
+ effectiveAgentDeviceId,
+ capabilityAgentKind,
+ capabilities,
+ agentCatalogProviders,
+ ]);
+}
diff --git a/apps/mobile/app/sessions/new.tsx b/apps/mobile/app/sessions/new.tsx
index 542c175089..711066b444 100644
--- a/apps/mobile/app/sessions/new.tsx
+++ b/apps/mobile/app/sessions/new.tsx
@@ -1,3 +1,5 @@
+import { useNewSessionHostDefaults } from '@/session/useNewSessionHostDefaults';
+import { useNewSessionDefaultSelection } from '@/session/useNewSessionDefaultSelection';
import { parseGoalCommand } from '@cindy/maker-shared/goal-command';
import { mergeMobileGoalCommand, parseMobileDesktopCommand } from '@/session/desktopSlashCommands';
import { modelNeedsReselection } from '@/session/modelReselection';
@@ -195,32 +197,25 @@ import {
} from '@/session/composerPalette';
import { mobileDebugLog } from '@/debug/mobileDebugLog';
import {
- type StoredAgentRestoreState,
applyRemoteAgentPick,
assertSubmitModelResolved,
DEFAULT_NEW_SESSION_DRAFT,
NEW_SESSION_AGENT_OPTIONS,
availableNewSessionAgentOptions,
- canResolveStoredAgentRuntime,
defaultPermissionModeForNewSessionAgent,
buildRemoteCreateSessionOptions,
buildRecentWorkspaceOptions,
filterRemoteDirectoryEntries,
isCurrentRemoteBrowseRequest,
isNewSessionRuntimePending,
- isStoredAgentRestorePending,
- nextStoredAgentRestoreStep,
normalizeRemoteDirectoryDrives,
shouldRetryRemoteBrowseDrives,
normalizeCreateSessionResult,
isNewSessionDraftMissingPayloadOnly,
parseNewSessionDeviceOptions,
pickAgentDefaultRuntime,
- hostDraftRuntimeFromDefaults,
- isHostDraftDefaultsReady,
pickInitialNewSessionWorkspace,
pickNewSessionDefaultDevice,
- resolveNewSessionAutoDefault,
sessionFromCreateResult,
compensatePrecreatedWorktree,
reconcileEffortAfterFallback,
@@ -237,6 +232,7 @@ import {
} from '@/session/newSession';
import { isDefaultDraftSessionTitle } from '@cindy/maker-shared/session-title';
import { newSessionText } from '@/session/newSessionMessages';
+
import { i18n } from '@/i18n';
import {
getMobileAuthOwner,
@@ -1043,8 +1039,6 @@ export default function NewRemoteSessionScreen() {
const atLoadSeqRef = useRef(0);
const initialWorkspaceKeyRef = useRef<string | null>(null);
const appliedDefaultDeviceKeyRef = useRef<string | null>(null);
- // 上次 agent 的恢复进度(唯一写入者:下面的恢复 effect)。见 nextStoredAgentRestoreStep。
- const storedAgentRestoreRef = useRef<StoredAgentRestoreState | null>(null);
// 权限记忆只在偏好加载后恢复一次(之后由用户选择 / 切 agent 驱动),防止重复覆盖。
const appliedPermissionMemoryRef = useRef(false);
const userTouchedDeviceRef = useRef(false);
@@ -1090,107 +1084,11 @@ export default function NewRemoteSessionScreen() {
const autoDefaultDeviceRef = useRef<string | null>(null);
// 被控电脑的「新建任务默认」(与桌面远程新建同一读源 maker:get-new-maker-defaults):
// 默认模型 = 那台电脑上新建任务时用户上次选的模型,不再从任务列表推断「最近使用」。
- // 选中设备后一次读齐三个 agent,供自动默认 / 恢复上次 agent / 切 agent 同步取用。
- // 旧被控端(CHANNEL_NOT_ALLOWED)或重试后仍失败都算读完,回落目录区域默认,不无限等待。
- const [hostDraftDefaults, setHostDraftDefaults] = useState<{
- deviceId: string;
- byAgent: Partial<Record<NewSessionAgentKind, NewSessionRuntime | null>>;
- } | null>(null);
- const hostDraftDefaultsRef = useRef(hostDraftDefaults);
- hostDraftDefaultsRef.current = hostDraftDefaults;
- // 在途读取:切 agent 时等它读完再选模型,避免先落目录默认、又因已手动切换而再也补不回来。
- const hostDraftDefaultsLoadRef = useRef<{ deviceId: string; promise: Promise<void> } | null>(null);
- useEffect(() => {
- if (!selectedDeviceId || deviceLinkStatus !== 'online') return undefined;
- if (hostDraftDefaultsRef.current?.deviceId === selectedDeviceId) return undefined;
- const deviceId = selectedDeviceId;
- let cancelled = false;
- const readAgent = async (agentKind: NewSessionAgentKind) => {
- for (let attempt = 0; ; attempt += 1) {
- const defaults = await withTransientRemoteRetry(async () => {
- await openLink(deviceId);
- return maker.getNewMakerDefaults(agentKind);
- }, { maxAttempts: 2 }).catch(() => undefined);
- if (cancelled) return null;
- // 被控端刚启动、渲染进程还没推来草稿时回 {}:稍后重读,不把它当成「从未选过模型」;
- // 有限次后(含不带该字段的旧被控端)按无默认处理。读取失败不重读。
- if (defaults === undefined || isHostDraftDefaultsReady(defaults) || attempt >= 2) {
- return hostDraftRuntimeFromDefaults(defaults, agentKind);
- }
- await new Promise<void>((resolve) => setTimeout(resolve, 1_500));
- if (cancelled) return null;
- }
- };
- const promise = Promise.all(
- NEW_SESSION_AGENT_OPTIONS.map(async ({ kind }) => [kind, await readAgent(kind)] as const),
- ).then((entries) => {
- if (cancelled) return;
- const next = { deviceId, byAgent: Object.fromEntries(entries) };
- // 同步更新镜像:等待中的切 agent 回调在下一次渲染前就要读到结果。
- hostDraftDefaultsRef.current = next;
- setHostDraftDefaults(next);
- });
- hostDraftDefaultsLoadRef.current = { deviceId, promise };
- return () => {
- cancelled = true;
- };
- }, [deviceLinkStatus, maker, openLink, selectedDeviceId]);
- // 等该设备的被控电脑默认读完(读完、失败都算);没有在途读取(离线 / 未选设备)时不等,
- // 按目录默认继续。effect 重跑会换一份新的在途读取,跟着等新的那份(有限次)。
- const waitHostDraftDefaults = useCallback(async (deviceId: string) => {
- for (let attempt = 0; attempt < 3; attempt += 1) {
- if (hostDraftDefaultsRef.current?.deviceId === deviceId) return;
- const load = hostDraftDefaultsLoadRef.current;
- if (!load || load.deviceId !== deviceId) return;
- await load.promise;
- }
- }, []);
- const hostDefaultsSettled = !!selectedDeviceId && hostDraftDefaults?.deviceId === selectedDeviceId;
- // 本页已写回被控电脑的选择(按设备、agent):优先于读取结果,避免选择前发出的读取
- // 晚到后把旧模型带回来(切到别的 agent 再切回时)。
- const hostChoiceOverridesRef = useRef(new Map<string, Partial<Record<NewSessionAgentKind, NewSessionRuntime>>>());
- const hostRuntimeFor = useCallback(
- (agentKind: NewSessionAgentKind): NewSessionRuntime | null => {
- const deviceId = selectedDeviceRef.current;
- const chosen = hostChoiceOverridesRef.current.get(deviceId)?.[agentKind];
- if (chosen) return chosen;
- const current = hostDraftDefaultsRef.current;
- return current && current.deviceId === deviceId
- ? current.byAgent[agentKind] ?? null
- : null;
- },
- [],
- );
- // 在新建任务页选的模型 / 档位写回被控电脑的新建任务默认(与桌面远程新建同一写法
- // maker:apply-new-maker-draft-pref active=true),下次在这台电脑上新建任务——不论手机、
- // 桌面还是远程桌面——默认都是它。由选择入口发请求,本 effect 在草稿提交后读最终值写出;
- // 写失败不打扰,本页草稿照常生效。远程 Agent(模型属于另一台电脑)不写回被控电脑。
- const [hostChoiceRequest, setHostChoiceRequest] = useState<{ seq: number; markModelChoice: boolean } | null>(null);
- const hostChoiceSentSeqRef = useRef(0);
- const requestHostChoiceWrite = useCallback((markModelChoice: boolean) => {
- setHostChoiceRequest((current) => ({ seq: (current?.seq ?? 0) + 1, markModelChoice }));
- }, []);
- useEffect(() => {
- if (!hostChoiceRequest || hostChoiceRequest.seq === hostChoiceSentSeqRef.current) return;
- hostChoiceSentSeqRef.current = hostChoiceRequest.seq;
- if (!selectedDeviceId || remoteAgentChoice || !draft.model) return;
- const { agentKind, model, providerId, effort, fastMode } = draft;
- void maker.applyNewMakerDraftPref({
- agent: agentKind,
- providerId: providerId ?? '',
- modelId: model,
- active: true,
- markModelChoice: hostChoiceRequest.markModelChoice,
- ...(effort ? { effort } : {}),
- fast: fastMode,
- }).catch(() => undefined);
- // 记下本页选择:切到别的 agent 再切回时取到它,不被在途或更早的读取结果覆盖。
- const overrides = hostChoiceOverridesRef.current;
- overrides.set(selectedDeviceId, {
- ...overrides.get(selectedDeviceId),
- [agentKind]: { agentKind, model, effort, providerId },
- });
- }, [draft, hostChoiceRequest, maker, remoteAgentChoice, selectedDeviceId]);
+ // 同账号同设备先用跨页缓存,再后台读齐三个 agent;刷新不阻塞新建或覆盖手动选择。
+ // 无缓存时才等待首读;旧被控端或重试后仍失败也算读完,回落目录默认,不无限等待。
+ const { hostDraftDefaults, hostDefaultsSettled, hostRuntimeFor, waitHostDraftDefaults, requestHostChoiceWrite } = useNewSessionHostDefaults({
+ selectedDeviceId, deviceLinkStatus, maker, openLink, outboxOwner, remoteAgentChoice, draft
+ });
// selectedDeviceId 的渲染期镜像:异步回调(权限确认 .then)提交前比对触发时捕获的设备,
// 不一致即放弃写入 —— 防止确认弹窗期间用户切了设备,回调把旧设备的来源/配置写进草稿
// (Greptile review P1:异步切换写入旧设备来源)。
@@ -1408,228 +1306,32 @@ export default function NewRemoteSessionScreen() {
routeDeviceName,
]);
- useEffect(() => {
- const storedAgentKind = newSessionPreferences?.agentKind;
- if (!newSessionPreferencesLoaded || !storedAgentKind) return;
- if (userTouchedRuntimeRef.current) return;
- const restored = storedAgentRestoreRef.current;
- if (!isStoredAgentRestorePending({
- storedAgentKind,
- appliedStoredAgentKind: restored?.phase === 'done' ? restored.agentKind : null,
- expectedDeviceId: preferredDefaultDevice?.deviceId ?? '',
- selectedDeviceId,
- })) return;
- // agent 偏好一到就恢复;模型要等被控电脑的新建任务默认与目录,否则选不出模型。
- const step = nextStoredAgentRestoreStep({
- storedAgentKind,
- restored,
- modelReady: canResolveStoredAgentRuntime({
- deviceId: selectedDeviceId,
- hostDefaultsSettled,
- hostRuntime: hostRuntimeFor(storedAgentKind),
- catalogReady: deviceProviders.ready,
- providersUnsupported: deviceProviders.unsupported,
- }),
- });
- if (!step) return;
- mobileDebugLog('debug', 'new-session', 'stored agent restore', { step, agentKind: storedAgentKind });
- const previousRestore = restored;
- const restoreState: StoredAgentRestoreState = { agentKind: storedAgentKind, phase: step === 'agent' ? 'agent' : 'done' };
- storedAgentRestoreRef.current = restoreState;
- // 现场按最新目录算该 agent 的默认运行配置(rows 与 ready 必须同一代,codex review P2)。
- const resolveStoredRuntime = (currentEffort: string) => {
- const rowsNow = flattenProviderSections(
- buildMobileModelSections({
- providers: deviceProvidersRef.current.providers,
- agentKind: storedAgentKind,
- visibilityOverrides: deviceProvidersRef.current.modelVisibilityOverrides,
- }).sections,
- );
- const next = pickAgentDefaultRuntime({
- agentKind: storedAgentKind,
- hostRuntime: hostRuntimeFor(storedAgentKind),
- modelRows: rowsNow,
- currentEffort,
- catalogReady: catalogReadyRef.current,
- visibilityOverrides: deviceProvidersRef.current.modelVisibilityOverrides,
- flatModels: flatModelsForUnsupportedHost(selectedDeviceId, storedAgentKind, deviceProvidersRef.current.unsupported),
- });
- return {
- model: next.model,
- effort: next.effort,
- providerId: next.providerId,
- // fast 按 (agent, 来源, 模型) 记忆恢复,无记忆置 false;恢复前过与手动选行
- // 同款的 fastEditable 门控(codex review P2:目录/能力变化后不得恢复出
- // UI 显示关、实际发 true 的矛盾态)。agent 级门控只认目标 agent 的缓存
- // 能力表(codex review P1:此刻闭包里的 capabilities 属于切换前 agent 或
- // 为 null);目标 caps 未就绪 → false,由延迟恢复 effect 就绪后补评。
- fastMode: next.providerId
- && isFastRestorable(next.agentKind, next.providerId, next.model, rowsNow, targetAgentHasFast(selectedDeviceId, next.agentKind))
- ? (draftMemory.getFast(next.agentKind, next.providerId, next.model) ?? false)
- : false,
- };
- };
- if (step === 'model') {
- // agent 与权限已在第一步恢复;只补模型,不动 agent 与权限(期间用户改过权限/计划模式不被覆盖)。
- setDraft((current) => (current.agentKind === storedAgentKind
- ? { ...current, ...resolveStoredRuntime(current.effort) }
- : current));
- settleRuntime('stored-agent-model', selectedDeviceId);
- return;
- }
- // 该路径同时负责恢复 agent 权限,下面的通用权限记忆 effect 不再重复弹框。
- appliedPermissionMemoryRef.current = true;
- const previousAutoDefaultDevice = autoDefaultDeviceRef.current;
- if (selectedDeviceId) autoDefaultDeviceRef.current = selectedDeviceId;
- let applied = false;
- const storedPermissionMode = newSessionPreferences?.permissionModeByAgent[storedAgentKind];
- const nextPermissionMode =
- storedPermissionMode ??
- defaultPermissionModeForNewSessionAgent(storedAgentKind);
- let cancelled = false;
- const deviceAtTrigger = selectedDeviceId;
- const seqAtTrigger = ++runtimeActionSeqRef.current;
- void (async () => {
- const confirmed = await confirmFullAccessChange(draft.permissionMode, nextPermissionMode, {
- restoringRememberedChoice: storedPermissionMode !== undefined,
- });
- if (cancelled) return;
- // 确认期间设备已切换 → 放弃本次写入,新设备自己的恢复/自动默认 effect 会接管。
- if (deviceAtTrigger !== selectedDeviceRef.current) return;
- // 确认期间用户又切了 agent / 手动选了模型 → 旧回调不得覆盖新选择。
- if (seqAtTrigger !== runtimeActionSeqRef.current) return;
- applied = true;
- setDraft((current) => ({
- ...current,
- ...resolveStoredRuntime(current.effort),
- agentKind: storedAgentKind,
- // 上次明确选择过的权限直接沿用;内置默认若升级到 Full access 仍需确认。
- permissionMode: confirmed ? nextPermissionMode : current.permissionMode,
- }));
- // 'agent' 只恢复了 agent,模型仍是占位,等数据到了由 'model' 落定。
- if (step === 'full') settleRuntime('stored-agent', deviceAtTrigger);
- })();
- return () => {
- cancelled = true;
- // 写入前依赖已变(effect 重跑):撤回「已恢复」与设备锁,让重跑的 effect 重新恢复。
- // 否则标记已落、草稿却没写,两条默认路径都不再处理,页面停在占位模型。
- if (applied) return;
- if (storedAgentRestoreRef.current === restoreState) storedAgentRestoreRef.current = previousRestore;
- if (autoDefaultDeviceRef.current === selectedDeviceId) autoDefaultDeviceRef.current = previousAutoDefaultDevice;
- };
- }, [
- draft.permissionMode,
- deviceProviders.ready,
- deviceProviders.unsupported,
- deviceProviders.providers,
- deviceProviders.modelVisibilityOverrides,
- hostDefaultsSettled,
- hostDraftDefaults,
- hostRuntimeFor,
+ useNewSessionDefaultSelection({
newSessionPreferences,
- newSessionPreferences?.agentKind,
newSessionPreferencesLoaded,
- preferredDefaultDevice?.deviceId,
+ userTouchedRuntimeRef,
+ preferredDefaultDevice,
selectedDeviceId,
- ]);
-
- // 权限记忆恢复:偏好加载后按当前 agent 恢复上次选过的档(一次;对齐桌面 lastByVendor)。
- // storedAgentKind 路径由上面的 effect 覆盖;这里兜住「没存过 agent 但存过权限」的场景。
- useEffect(() => {
- if (!newSessionPreferencesLoaded || appliedPermissionMemoryRef.current) return;
- appliedPermissionMemoryRef.current = true;
- // 有存储的 agent 时由上面的 agent 恢复 effect 统一处理,避免同一轮出现两个确认框。
- if (newSessionPreferences?.agentKind) return;
- const remembered = newSessionPreferences?.permissionModeByAgent[draft.agentKind];
- if (!remembered || remembered === draft.permissionMode) return;
- let cancelled = false;
- const seqAtTrigger = runtimeActionSeqRef.current;
- void confirmFullAccessChange(draft.permissionMode, remembered, {
- restoringRememberedChoice: true,
- }).then((confirmed) => {
- if (cancelled || !confirmed || seqAtTrigger !== runtimeActionSeqRef.current) return;
- setDraft((current) => ({ ...current, permissionMode: remembered }));
- });
- return () => {
- cancelled = true;
- };
- }, [draft.agentKind, draft.permissionMode, newSessionPreferences, newSessionPreferencesLoaded]);
-
- // 新建任务默认运行配置 = 被控电脑记住的当前 agent 新建任务默认(model+effort+来源,与桌面远程新建同源);
- // 没有则优先区域默认、再用模型列表最上面那个。一旦用户手动选过模型即不再覆盖;切设备(未手动选过)按新设备重算。
- // 决策逻辑全在纯函数 resolveNewSessionAutoDefault 里(便于单测);此 effect 只负责"调纯函数 → setDraft + 更新 ref"。
- // 被控电脑默认与 providers 都是异步到达,任一就绪后此 effect 再触发。
- useEffect(() => {
- if (!newSessionPreferencesLoaded) return;
- const result = resolveNewSessionAutoDefault({
- userTouched: userTouchedRuntimeRef.current,
- appliedDeviceId: autoDefaultDeviceRef.current,
- selectedDeviceId,
- hostDefaultsSettled,
- hostRuntime: hostRuntimeFor(draft.agentKind),
- modelRows,
- rowsAgentKind: draft.agentKind,
- catalogReady: deviceProviders.ready,
- visibilityOverrides: deviceProviders.modelVisibilityOverrides,
- providersUnsupported: deviceProviders.unsupported,
- // provider-aware 模式只用经过可见性过滤的 rows;目录确实不可用时才回退
- // capabilities(上游 main 移植,merge 2026-08-07)。
- availableModels: deviceProviders.unsupported
- ? capabilities?.availableModels
- : undefined,
- currentEffort: draft.effort,
- });
- if (!result) return;
- const previousAutoDefaultDevice = autoDefaultDeviceRef.current;
- autoDefaultDeviceRef.current = result.appliedDeviceId;
- let applied = false;
- const nextAgentKind = result.patch.agentKind ?? draft.agentKind;
- const storedPermissionMode = appliedPermissionMemoryRef.current
- ? undefined
- : newSessionPreferences?.permissionModeByAgent[nextAgentKind];
- const nextPermissionMode = appliedPermissionMemoryRef.current
- ? draft.permissionMode
- : storedPermissionMode ?? defaultPermissionModeForNewSessionAgent(nextAgentKind);
- let cancelled = false;
- void confirmFullAccessChange(draft.permissionMode, nextPermissionMode, {
- restoringRememberedChoice: storedPermissionMode !== undefined,
- }).then((confirmed) => {
- if (cancelled || userTouchedRuntimeRef.current) return;
- applied = true;
- settleRuntime(result.source, result.appliedDeviceId);
- setDraft((current) => {
- // 自动默认重算(设备切换/最近会话变化)改了 (agent, model, providerId) 组合 →
- // fastMode 按新组合重验(Codex review P2):A 设备记忆恢复的 fastMode:true 不得
- // 随 `...current` 带进 B 的组合(若 B 的模型行不支持 Fast,终检/延迟恢复/能力
- // 协调三条路径都不会处理它)。组合变化时保守关闭,由延迟恢复 effect 在 B 的
- // 组合 + 能力就绪后按记忆重评(手动关过 → 记忆为 false,不会重新打开)。
- const nextModel = result.patch.model ?? current.model;
- // providerId 用 `!== undefined` 而非 `??`:patch 显式带 providerId:null(来源
- // 切回默认路由)是真实的组合变化,`??` 会取回旧值抹掉该变化(Codex review P2)。
- const nextProviderId = result.patch.providerId !== undefined
- ? result.patch.providerId
- : current.providerId;
- const nextAgentKind = result.patch.agentKind ?? current.agentKind;
- const comboChanged = nextModel !== current.model
- || nextProviderId !== current.providerId
- || nextAgentKind !== current.agentKind;
- return {
- ...current,
- ...result.patch,
- ...(comboChanged ? { fastMode: false } : {}),
- // 自动恢复上次明确选择的权限不再重复确认;内置默认仍按升级规则确认。
- permissionMode: confirmed ? nextPermissionMode : current.permissionMode,
- };
- });
- });
- return () => {
- cancelled = true;
- // 写入前 effect 重跑:撤回设备锁,重跑时按最新数据重新应用,不把这台设备误记为已应用。
- if (!applied && autoDefaultDeviceRef.current === result.appliedDeviceId) {
- autoDefaultDeviceRef.current = previousAutoDefaultDevice;
- }
- };
- }, [capabilities?.availableModels, deviceProviders.loading, draft.effort, draft.permissionMode, draft.agentKind, modelRows, deviceProviders.ready, deviceProviders.modelVisibilityOverrides, deviceProviders.unsupported, modelSections.connected.length, newSessionPreferences, newSessionPreferencesLoaded, selectedDeviceId, hostDefaultsSettled, hostDraftDefaults, hostRuntimeFor]);
+ hostDraftDefaults,
+ hostDefaultsSettled,
+ hostRuntimeFor,
+ deviceProviders,
+ deviceProvidersRef,
+ catalogReadyRef,
+ flatModelsForUnsupportedHost,
+ targetAgentHasFast,
+ draftMemory,
+ autoDefaultDeviceRef,
+ setDraft,
+ settleRuntime,
+ appliedPermissionMemoryRef,
+ draft,
+ runtimeActionSeqRef,
+ selectedDeviceRef,
+ capabilities,
+ modelRows,
+ modelSections,
+ });
// 目录就绪后的来源终检(codex review P1):自动默认/恢复在目录加载期信任的来源可能已失效
// (provider 被删/断开/模型下架),就绪后必须复核——联合回退整对 (model, providerId)
@@ -4393,7 +4095,7 @@ export default function NewRemoteSessionScreen() {
restoringRememberedChoice: storedPermissionMode !== undefined,
}).then(async (confirmed) => {
// 被控电脑默认还在读:等读完再选模型(切换已标记手动,之后自动默认不会再补)。
- await waitHostDraftDefaults(selectedDeviceId);
+ await waitHostDraftDefaults(selectedDeviceId, nextKind);
// 确认期间设备已切换 → 放弃本次写入,新设备自己的 effect 会接管(Greptile P1)。
if (selectedDeviceId !== selectedDeviceRef.current) return;
// 确认期间用户又切了 agent / 手动选了模型 → 旧回调不得覆盖新选择(Greptile P1)。
diff --git a/apps/mobile/src/__tests__/newSession.test.ts b/apps/mobile/src/__tests__/newSession.test.ts
index b1cbbde4f5..72bddacf92 100644
--- a/apps/mobile/src/__tests__/newSession.test.ts
+++ b/apps/mobile/src/__tests__/newSession.test.ts
@@ -53,6 +53,13 @@ import type { RemoteSession } from '@/session/types';
const readTextLf = (...args: Parameters<typeof readFileSync>): string =>
String(readFileSync(...args)).replace(/\r\n/g, '\n');
+// Existing source contracts follow the extracted hooks; load their text once.
+const newSessionSources = [
+ 'app/sessions/new.tsx',
+ 'src/session/useNewSessionDefaultSelection.ts',
+ 'src/session/useNewSessionHostDefaults.ts',
+].map(path => readTextLf(resolve(process.cwd(), path), 'utf8')).join('\n');
+
// 文案已 i18n 化;固定 zh-CN 让字面量断言与语言环境解耦(全局 mock 默认 en-US)。
beforeAll(async () => {
await i18n.changeLanguage('zh-CN');
@@ -408,7 +415,7 @@ describe('stored agent restore gating', () => {
});
it('gates the stored agent restore on real data and leaves the auto-default unblocked', () => {
- const source = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const source = newSessionSources;
const storedStart = source.indexOf('const storedAgentKind = newSessionPreferences?.agentKind;');
const autoStart = source.indexOf('const result = resolveNewSessionAutoDefault({');
const storedSource = source.slice(storedStart, source.indexOf('storedAgentRestoreRef.current = restoreState', storedStart));
@@ -426,7 +433,7 @@ describe('stored agent restore gating', () => {
});
it('reads and writes the host new-task defaults instead of inferring from task history', () => {
- const source = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const source = newSessionSources;
// 读:与桌面远程新建同一读源,三个 agent 一次读齐。
expect(source).toContain('return maker.getNewMakerDefaults(agentKind);');
expect(source).toContain('return hostDraftRuntimeFromDefaults(defaults, agentKind);');
@@ -449,7 +456,7 @@ describe('stored agent restore gating', () => {
// 切 agent 先等被控电脑默认读完再选模型,不把目录默认当成最终选择(Greptile P1)。
const switchStart = source.indexOf('const switchAgent = useCallback(');
const switchBody = source.slice(switchStart, source.indexOf('\n }, [', switchStart));
- const waitAt = switchBody.indexOf('await waitHostDraftDefaults(selectedDeviceId);');
+ const waitAt = switchBody.indexOf('await waitHostDraftDefaults(selectedDeviceId, nextKind);');
expect(waitAt).toBeGreaterThan(-1);
expect(waitAt).toBeLessThan(switchBody.indexOf('pickAgentDefaultRuntime({'));
});
@@ -472,7 +479,7 @@ describe('pickAgentDefaultRuntime on hosts without provider:list', () => {
});
it('passes capabilities models only for unsupported hosts, on both stored-agent restore and agent switch', () => {
- const source = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const source = newSessionSources;
expect(source).toContain('flatModels: flatModelsForUnsupportedHost(selectedDeviceId, storedAgentKind, deviceProvidersRef.current.unsupported),');
expect(source).toContain('flatModels: flatModelsForUnsupportedHost(selectedDeviceId, nextKind, deviceProvidersRef.current.unsupported),');
expect(source).toContain('if (!providersUnsupported || !deviceId) return undefined;');
@@ -509,7 +516,7 @@ describe('isNewSessionRuntimePending', () => {
});
it('rolls back the restore marker and device lock when an automatic write is dropped', () => {
- const source = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const source = newSessionSources;
const storedStart = source.indexOf('const storedAgentKind = newSessionPreferences?.agentKind;');
const storedEffect = source.slice(storedStart, source.indexOf('}, [', storedStart));
expect(storedEffect).toContain('if (storedAgentRestoreRef.current === restoreState) storedAgentRestoreRef.current = previousRestore;');
@@ -520,7 +527,7 @@ describe('isNewSessionRuntimePending', () => {
});
it('binds the settled model to the computer it was settled for', () => {
- const source = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const source = newSessionSources;
// 切到另一台电脑后重新等待,不能沿用上一台电脑落定的模型直接创建。
expect(source).toContain('settled: !!selectedDeviceId && runtimeSettledDeviceId === selectedDeviceId,');
expect(source).toContain("settleRuntime('stored-agent', deviceAtTrigger);");
@@ -529,7 +536,7 @@ describe('isNewSessionRuntimePending', () => {
});
it('drops the previous computer\'s auto-picked model on device switch and gates goal creation too', () => {
- const source = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const source = newSessionSources;
const selectStart = source.indexOf('const selectDevice = useCallback(');
const selectDevice = source.slice(selectStart, source.indexOf('const handleBack = useCallback(', selectStart));
// 用户没手动选过模型时清掉旧电脑的自动选择并重新等待;手动选过的保留。
@@ -548,7 +555,7 @@ describe('isNewSessionRuntimePending', () => {
expect(() => assertSubmitModelResolved({ model: '' }, 'delisted-model'))
.toThrow('delisted-model 在这台电脑上已不可用,请重新选择模型后再发送。');
// 三处提交终检(创建前两处 + 鉴权后重验)都要经过这道拦截。
- const source = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const source = newSessionSources;
expect(source.split('assertSubmitModelResolved(resolved, effectiveDraft.model);').length - 1).toBe(3);
});
});
@@ -1218,7 +1225,7 @@ describe('new session default device follows the home device filter', () => {
});
it('treats the deviceExplicit route flag as an explicit device on the new-session screen', () => {
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
expect(newSource).toContain('deviceExplicit?: string;');
expect(newSource).toContain("readRouteString(params.deviceExplicit) === '1'");
});
@@ -1275,7 +1282,7 @@ describe('new session model', () => {
{ seq: 3, deviceId: '' },
)).toBe(false);
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
expect(newSource).toContain('browseSeqRef.current += 1');
expect(newSource).toContain('selectedDeviceIdRef.current = option.deviceId');
expect(newSource).toContain('isCurrentRemoteBrowseRequest');
@@ -1288,13 +1295,13 @@ describe('new session model', () => {
expect(shouldRetryRemoteBrowseDrives(false, 0)).toBe(false);
expect(shouldRetryRemoteBrowseDrives(undefined, 0)).toBe(false);
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
expect(newSource).toContain('shouldRetryRemoteBrowseDrives');
expect(newSource).toContain('result.drivesPending');
});
it('keeps the Android drive pill at 34pt and wraps it in a 44pt hit target', () => {
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
expect(newSource).toContain('styles.browseDriveHit');
expect(newSource).toMatch(/browseDriveHit:\s*\{[^}]*minHeight:\s*44/);
expect(newSource).toMatch(/browseDriveHit:\s*\{[^}]*minWidth:\s*44/);
@@ -1430,7 +1437,7 @@ describe('new session model', () => {
});
it('wires the new-session screen to gate agents by list-available-agents and coerce off unavailable', () => {
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
// 拉被控端 runtime 注册集合,渲染按可用集过滤,选中不可用时 coerce。
expect(newSource).toContain('maker.listAvailableAgents()');
expect(newSource).toContain('onAgentsChanged');
@@ -1613,7 +1620,7 @@ describe('new session model', () => {
});
it('keeps the recent-project list nested-scrollable with a visible scroll indicator (#5013)', () => {
- const source = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const source = newSessionSources;
// Scope the guard to this list: the remote directory FlatList already has
// these props, so checking the whole page would miss the Android regression.
// Native gesture dispatch still needs Android emulator/device verification.
@@ -1958,7 +1965,7 @@ describe('new session model', () => {
describe('new session composer surface', () => {
it('keeps the controlled caret at the end after palette insertion and draft restore', () => {
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
const slashStart = newSource.indexOf('const selectSlashCommand = useCallback');
const slashEnd = newSource.indexOf('const selectAtResource = useCallback', slashStart);
const slashSource = newSource.slice(slashStart, slashEnd);
@@ -1984,7 +1991,7 @@ describe('new session composer surface', () => {
});
it('does not double-apply the Android safe-area inset to the top navigation', () => {
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
expect(newSource).toContain(
"const NEW_SESSION_SCREEN_TOP_PADDING = Platform.OS === 'android' ? 0 : spacing.xl;",
@@ -1993,7 +2000,7 @@ describe('new session composer surface', () => {
});
it('uses the shared platform keyboard avoidance rule for the new-session composer', () => {
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
const normalizedNewSource = newSource.replace(/\r\n/g, '\n');
expect(newSource).toContain("import { keyboardAvoidingBehaviorForPlatform } from '@/session/mobileNativeShellLayout';");
@@ -2004,7 +2011,7 @@ describe('new session composer surface', () => {
});
it('uses the shared mobile composer row rather than a separate input implementation', () => {
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
const sessionSource = readTextLf(resolve(process.cwd(), 'app/sessions/[sessionId].tsx'), 'utf8');
const sharedSource = readTextLf(resolve(process.cwd(), 'src/session/MobileComposerInputRow.tsx'), 'utf8');
const newComposerStart = newSource.indexOf('<MobileComposerInputRow');
@@ -2328,7 +2335,7 @@ describe('new session worktree wiring (source locks)', () => {
// - 两步共用同一预生成 sessionId(工作端 close-session 按绑定回收 worktree);
// - 成功后以 meta.path 替换 effectiveDraft.workingDir 再进管线;
// - 失败(业务 {ok:false} / invoke 抛错)早退留在表单,不建会话。
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
it('runs worktree:create before the optimistic pipeline with the same preset sessionId', () => {
const requestIdx = newSource.indexOf('const createRequest = buildWorktreeCreateRequest({');
@@ -2550,7 +2557,7 @@ describe('submit guard catalog wiring (source locks)', () => {
// deviceAtCreate 捕获 + ensureDeviceAlive/abortIfDeviceSwitched,handoff
// (startNewSessionCreation / maker.createSession / goal.set)前必复核;
// 已 precreate 后失配必须走 ledger 补偿(forgetPendingPrecreatedWorktree)。
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
it('both submit guards resolve catalog trust via the generation-safe helper', () => {
const guardCalls = newSource.match(/resolveSubmitGuardCatalog\(\{/g) ?? [];
@@ -2811,7 +2818,7 @@ describe('fast memory restore wiring (source locks)', () => {
// - 必须存在延迟恢复 effect:目标 caps 就绪后按 (agent, 来源, 模型) 记忆重评,
// 通过才打开 fastMode——「永久清除合法记忆」与「恢复出目标不支持的 fast」
// 两个故障形态都靠这对接线闭合。
- const newSource = readTextLf(resolve(process.cwd(), 'app/sessions/new.tsx'), 'utf8');
+ const newSource = newSessionSources;
it('both restore sites gate on target-agent cached capabilities, never the closure state', () => {
const gated = newSource.match(/isFastRestorable\(next\.agentKind, next\.providerId, next\.model, rowsNow, targetAgentHasFast\(selectedDeviceId, next\.agentKind\)\)/g) ?? [];
diff --git a/apps/mobile/src/__tests__/newSessionHostDefaults.test.tsx b/apps/mobile/src/__tests__/newSessionHostDefaults.test.tsx
new file mode 100644
index 0000000000..d1224664ea
--- /dev/null
+++ b/apps/mobile/src/__tests__/newSessionHostDefaults.test.tsx
@@ -0,0 +1,234 @@
+// @vitest-environment jsdom
+import { useNewSessionHostDefaults } from '@/session/useNewSessionHostDefaults';
+import { useNewSessionDefaultSelection } from '@/session/useNewSessionDefaultSelection';
+import { DEFAULT_NEW_SESSION_DRAFT, isNewSessionRuntimePending, type NewSessionAgentKind, type NewSessionStoredPreferences } from '@/session/newSession';
+import type { MobileNewMakerDefaults } from '@/device-link/mobileMakerTransport';
+import { buildMobileModelSections } from '@/session/providerModelSections';
+import { act, createElement, useRef, useState } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { getMobileAuthOwner, setMobileAuthOwner } from '@/auth/authOwnerGeneration';
+import { getNewSessionHostDefaults } from '@/session/newSessionHostDefaultsCache';
+
+// Unit regression: import the same hooks as the page. The remote transport and
+// native permission UI are boundaries; cache/selection/lifecycle code is real.
+vi.mock('@/session/fullAccessConfirmation', () => ({ confirmFullAccessChange: vi.fn(async () => true) }));
+vi.mock('@/debug/mobileDebugLog', () => ({ mobileDebugLog: vi.fn() }));
+function usePageDefaults(bindings: Parameters<typeof useNewSessionHostDefaults>[0] & {
+ preferences: NewSessionStoredPreferences | null;
+}) {
+ const [draft, setDraft] = useState(bindings.draft);
+ const [settledDeviceId, setSettledDeviceId] = useState<string | null>(null);
+ const userTouchedRuntimeRef = useRef(false);
+ const defaults = useNewSessionHostDefaults({ ...bindings, draft });
+ const selectedDeviceRef = useRef(bindings.selectedDeviceId);
+ selectedDeviceRef.current = bindings.selectedDeviceId;
+ const deviceProviders = useRef({ providers: [], ready: false, loading: true, unsupported: false, error: null }).current;
+ useNewSessionDefaultSelection({
+ ...defaults, draft, setDraft, userTouchedRuntimeRef,
+ selectedDeviceId: bindings.selectedDeviceId, selectedDeviceRef,
+ newSessionPreferencesLoaded: true, newSessionPreferences: bindings.preferences,
+ preferredDefaultDevice: { deviceId: bindings.selectedDeviceId },
+ autoDefaultDeviceRef: useRef(null),
+ appliedPermissionMemoryRef: useRef(true),
+ runtimeActionSeqRef: useRef(0), deviceProviders, deviceProvidersRef: useRef(deviceProviders),
+ catalogReadyRef: useRef(false), capabilities: null, modelRows: [],
+ modelSections: buildMobileModelSections({ providers: [], agentKind: draft.agentKind }),
+ flatModelsForUnsupportedHost: () => undefined, targetAgentHasFast: () => false,
+ draftMemory: { getFast: () => false, getEffort: () => undefined, setFast: () => {}, setEffort: () => {} },
+ settleRuntime: (_source, deviceId) => setSettledDeviceId(deviceId),
+ });
+ return {
+ settled: defaults.hostDefaultsSettled, runtime: defaults.hostRuntimeFor('codex'),
+ runtimeFor: defaults.hostRuntimeFor, draft, wait: defaults.waitHostDraftDefaults,
+ pending: isNewSessionRuntimePending({
+ settled: settledDeviceId === bindings.selectedDeviceId,
+ selectedDeviceId: bindings.selectedDeviceId, userTouched: userTouchedRuntimeRef.current,
+ remoteAgentPicked: false, catalogReady: deviceProviders.ready, catalogFailed: false, modelRowCount: 0,
+ }),
+ choose: (mark: boolean) => {
+ userTouchedRuntimeRef.current = true;
+ setDraft(bindings.draft);
+ defaults.requestHostChoiceWrite(mark);
+ },
+ };
+}
+type State = ReturnType<typeof usePageDefaults>;
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+let root: Root | undefined;
+beforeEach(() => { setMobileAuthOwner('defaults-test'); });
+afterEach(() => {
+ act(() => root?.unmount());
+ root = undefined;
+ setMobileAuthOwner(null);
+ vi.useRealTimers();
+});
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (error: Error) => void;
+ const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no; });
+ return { promise, resolve, reject };
+}
+function mount(deviceId = 'desktop', agentKind: NewSessionAgentKind = 'codex', failedAgent?: string, storedAgent: NewSessionAgentKind | null = null, pendingAgents: NewSessionAgentKind[] = []) {
+ if (root) act(() => root!.unmount());
+ const read = deferred<MobileNewMakerDefaults>();
+ const pendingReads = new Map(pendingAgents.map((agent) => [agent, deferred<MobileNewMakerDefaults>()]));
+ const bindings = {
+ selectedDeviceId: deviceId, deviceLinkStatus: 'online', selectedDeviceRef: { current: deviceId },
+ outboxOwner: getMobileAuthOwner(), remoteAgentChoice: null,
+ draft: { ...DEFAULT_NEW_SESSION_DRAFT, agentKind, model: 'chosen', providerId: 'provider', effort: 'high', fastMode: false },
+ maker: { getNewMakerDefaults: vi.fn((agent?: string) => agent === failedAgent ? Promise.reject(new Error('read failed')) : pendingReads.get(agent as NewSessionAgentKind)?.promise ?? read.promise), applyNewMakerDraftPref: vi.fn(async () => {}) },
+ openLink: vi.fn(async () => {}),
+ preferences: storedAgent ? { agentKind: storedAgent, permissionModeByAgent: {}, device: null, workspaceKind: null, workingDirByDevice: {} } : null,
+ };
+ let state!: State;
+ function Harness() { state = usePageDefaults(bindings); return null; }
+ root = createRoot(document.createElement('div'));
+ const render = () => act(() => root!.render(createElement(Harness)));
+ render();
+ return { read, pendingReads, bindings, render, get state() { return state; } };
+}
+const defaults = (model: string) => ({ worktreeEnabled: false, model, providerId: 'provider', effort: 'high' });
+
+// A new-task page can be left before optional engines finish. Its successful
+// engine and explicit model choice must already be available on the next visit.
+it.each(['codex', 'pi', 'claude-code'] as const)('settles and caches %s without waiting for unrelated engines', async (agent) => {
+ const others = (['codex', 'pi', 'claude-code'] as const).filter((kind) => kind !== agent);
+ const first = mount('desktop', agent, undefined, agent, others);
+ let waited = false;
+ await act(async () => { void first.state.wait('desktop', agent).then(() => { waited = true; }); });
+ expect(first.state.pending).toBe(true);
+ await act(async () => first.read.resolve(defaults('ready')));
+ expect(first.state.pending).toBe(false);
+ expect(first.state.draft.model).toBe('ready');
+ expect(waited).toBe(true);
+ expect(getNewSessionHostDefaults('desktop')?.byAgent[agent]?.model).toBe('ready');
+ const reopened = mount('desktop', agent, undefined, agent);
+ await act(async () => {});
+ expect(reopened.state.pending).toBe(false);
+ expect(reopened.state.draft.model).toBe('ready');
+ await act(async () => {
+ for (const pending of first.pendingReads.values()) pending.resolve(defaults('late'));
+ });
+ for (const other of others) expect(getNewSessionHostDefaults('desktop')?.byAgent[other]).toBeUndefined();
+});
+
+it.each(['codex', 'pi', 'claude-code'] as const)('keeps a first-visit manual %s choice even when all reads are pending', async (agent) => {
+ const first = mount('desktop', agent);
+ act(() => first.state.choose(true));
+ expect(getNewSessionHostDefaults('desktop')?.byAgent[agent]?.model).toBe('chosen');
+ const reopened = mount('desktop', agent, undefined, agent);
+ await act(async () => {});
+ expect(reopened.state.pending).toBe(false);
+ expect(reopened.state.draft.model).toBe('chosen');
+ await act(async () => first.read.resolve(defaults('late')));
+ expect(getNewSessionHostDefaults('desktop')?.byAgent[agent]?.model).toBe('chosen');
+});
+
+it('restores the remembered engine before applying fresh background defaults', async () => {
+ const first = mount();
+ await act(async () => first.read.resolve(defaults('cached')));
+ const page = mount('desktop', 'codex', undefined, 'pi');
+ await act(async () => {});
+ expect(page.state.draft.agentKind).toBe('pi');
+ expect(page.state.draft.model).toBe('cached');
+ await act(async () => page.read.resolve(defaults('fresh')));
+ expect(page.state.draft.agentKind).toBe('pi');
+ expect(page.state.draft.model).toBe('fresh');
+});
+
+it('reopens with cached defaults immediately and refreshes the next visit in the background', async () => {
+ const first = mount();
+ expect(first.state.settled).toBe(false);
+ await act(async () => first.read.resolve(defaults('first')));
+ expect(first.state.runtime?.model).toBe('first');
+
+ const second = mount();
+ expect(second.state.settled).toBe(true);
+ expect(second.state.runtime?.model).toBe('first');
+ let waited = false;
+ await act(async () => { void second.state.wait('desktop', 'codex').then(() => { waited = true; }); });
+ expect(waited).toBe(true);
+ await act(async () => second.read.resolve(defaults('updated-on-desktop')));
+ expect(second.state.draft.model).toBe('updated-on-desktop');
+ expect(mount().state.runtime?.model).toBe('updated-on-desktop');
+ await act(async () => {});
+});
+
+it.each(['codex', 'pi', 'claude-code'] as const)('preserves a manual %s choice while refreshing the other engines', async (agent) => {
+ const first = mount();
+ await act(async () => first.read.resolve(defaults('first')));
+ const second = mount('desktop', agent);
+ act(() => second.state.choose(true));
+ await act(async () => second.read.resolve(defaults('old-response')));
+ expect(second.state.runtimeFor(agent)?.model).toBe('chosen');
+ expect(second.state.draft.model).toBe('chosen');
+ for (const other of ['codex', 'pi', 'claude-code'] as const) {
+ if (other === agent) continue;
+ expect(second.state.runtimeFor(other)?.model).toBe('old-response');
+ expect(getNewSessionHostDefaults('desktop')?.byAgent[other]?.model).toBe('old-response');
+ }
+ expect(mount('desktop', agent).state.runtimeFor(agent)?.model).toBe('chosen');
+ await act(async () => {});
+});
+
+it('caches successful engines independently and waits for an uncached engine on reopen', async () => {
+ const first = mount('desktop', 'codex', 'pi');
+ await act(async () => first.read.resolve(defaults('first')));
+ expect(getNewSessionHostDefaults('desktop')?.byAgent.codex?.model).toBe('first');
+ expect(getNewSessionHostDefaults('desktop')?.byAgent.pi).toBeUndefined();
+ expect(mount().state.settled).toBe(true);
+ const pi = mount('desktop', 'pi');
+ expect(pi.state.settled).toBe(false);
+ await act(async () => pi.read.resolve(defaults('pi-choice')));
+ expect(pi.state.settled).toBe(true);
+});
+
+it('preserves cached defaults on refresh failure, but does not cache a failed first read', async () => {
+ const first = mount();
+ await act(async () => first.read.resolve(defaults('first')));
+ const second = mount();
+ await act(async () => second.read.reject(new Error('read failed')));
+ expect(second.state.runtime?.model).toBe('first');
+ expect(mount().state.runtime?.model).toBe('first');
+
+ const other = mount('other-desktop');
+ expect(other.state.settled).toBe(false);
+ expect(other.state.runtime).toBeNull();
+ await act(async () => other.read.reject(new Error('read failed')));
+ expect(other.state.settled).toBe(true);
+ expect(mount('other-desktop').state.settled).toBe(false);
+});
+
+it('drops cached and in-flight defaults when the account changes', async () => {
+ const first = mount();
+ await act(async () => first.read.resolve(defaults('first')));
+ const pending = mount();
+ act(() => pending.state.choose(true));
+ act(() => setMobileAuthOwner('different-account'));
+ const newAccount = deferred<MobileNewMakerDefaults>();
+ pending.bindings.outboxOwner = getMobileAuthOwner();
+ pending.bindings.maker.getNewMakerDefaults.mockImplementation(() => newAccount.promise);
+ pending.render();
+ expect(pending.state.settled).toBe(false);
+ expect(pending.state.runtime).toBeNull();
+ await act(async () => pending.read.resolve(defaults('old-account')));
+ expect(getNewSessionHostDefaults('desktop')).toBeNull();
+ await act(async () => newAccount.resolve(defaults('new-account')));
+ expect(mount().state.runtime?.model).toBe('new-account');
+ await act(async () => {});
+});
+
+it('caches a confirmed empty default but retries an unready host without discarding old defaults', async () => {
+ vi.useFakeTimers();
+ const first = mount();
+ await act(async () => first.read.resolve({ worktreeEnabled: false }));
+ const second = mount();
+ expect(second.state.settled).toBe(true);
+ expect(second.state.runtime).toBeNull();
+ await act(async () => second.read.resolve({}));
+ await act(async () => { await vi.advanceTimersByTimeAsync(3_000); });
+ expect(second.bindings.maker.getNewMakerDefaults).toHaveBeenCalledTimes(9);
+ expect(mount().state.settled).toBe(true);
+ await act(async () => {});
+});
diff --git a/apps/mobile/src/session/newSessionHostDefaultsCache.ts b/apps/mobile/src/session/newSessionHostDefaultsCache.ts
new file mode 100644
index 0000000000..f3e08617f8
--- /dev/null
+++ b/apps/mobile/src/session/newSessionHostDefaultsCache.ts
@@ -0,0 +1,44 @@
+import { subscribeMobileAuthOwner } from '@/auth/authOwnerGeneration';
+import type { NewSessionAgentKind, NewSessionRuntime } from './newSession';
+
+export interface NewSessionHostDefaults {
+ deviceId: string;
+ byAgent: Partial<Record<NewSessionAgentKind, NewSessionRuntime | null>>;
+}
+
+// Display/default-selection snapshots only. Provider availability and submission
+// still use the live catalog. Refresh on each visit without hiding cached values.
+const cache = new Map<string, NewSessionHostDefaults>();
+subscribeMobileAuthOwner(() => cache.clear());
+
+export function getNewSessionHostDefaults(deviceId: string): NewSessionHostDefaults | null {
+ return cache.get(deviceId) ?? null;
+}
+
+export function cacheNewSessionHostDefaults(
+ next: NewSessionHostDefaults,
+ expected: NewSessionHostDefaults | null,
+): NewSessionHostDefaults {
+ const current = getNewSessionHostDefaults(next.deviceId);
+ // Only the engines changed during this read outrank its response. A manual
+ // Codex choice must not discard fresh Pi/Claude defaults from the same read.
+ const byAgent = { ...next.byAgent };
+ if (current && current !== expected) {
+ for (const agent of Object.keys(current.byAgent) as NewSessionAgentKind[]) {
+ if (current.byAgent[agent] !== expected?.byAgent[agent]) {
+ byAgent[agent] = current.byAgent[agent];
+ }
+ }
+ }
+ const merged = { ...next, byAgent };
+ cache.set(next.deviceId, merged);
+ return merged;
+}
+
+export function rememberNewSessionHostRuntime(deviceId: string, runtime: NewSessionRuntime): void {
+ const current = cache.get(deviceId);
+ cache.set(deviceId, {
+ deviceId,
+ byAgent: { ...current?.byAgent, [runtime.agentKind]: runtime },
+ });
+}
diff --git a/apps/mobile/src/session/useNewSessionDefaultSelection.ts b/apps/mobile/src/session/useNewSessionDefaultSelection.ts
new file mode 100644
index 0000000000..6959a6c798
--- /dev/null
+++ b/apps/mobile/src/session/useNewSessionDefaultSelection.ts
@@ -0,0 +1,298 @@
+import { useEffect, useRef, type MutableRefObject, type Dispatch, type SetStateAction } from 'react';
+import type { UseDeviceProvidersResult } from '@/device-link/useDeviceProviders';
+import { mobileDebugLog } from '@/debug/mobileDebugLog';
+import { isStoredAgentRestorePending, nextStoredAgentRestoreStep, canResolveStoredAgentRuntime, pickAgentDefaultRuntime, defaultPermissionModeForNewSessionAgent, resolveNewSessionAutoDefault, type NewSessionStoredPreferences, type StoredAgentRestoreState, type NewSessionAgentKind, type NewSessionRuntime, type NewSessionDraft } from './newSession';
+import { buildMobileModelSections, flattenProviderSections, isFastRestorable, type ProviderModelRow } from './providerModelSections';
+import type { MobileAgentCapabilities, MobileModelOption } from './agentCapabilities';
+import type { MobileModelMemoryAccessors } from './draftModelMemory';
+import type { NewSessionHostDefaults } from './newSessionHostDefaultsCache';
+import { confirmFullAccessChange } from './fullAccessConfirmation';
+
+export function useNewSessionDefaultSelection({
+ newSessionPreferences,
+ newSessionPreferencesLoaded,
+ userTouchedRuntimeRef,
+ preferredDefaultDevice,
+ selectedDeviceId,
+ hostDraftDefaults,
+ hostDefaultsSettled,
+ hostRuntimeFor,
+ deviceProviders,
+ deviceProvidersRef,
+ catalogReadyRef,
+ flatModelsForUnsupportedHost,
+ targetAgentHasFast,
+ draftMemory,
+ autoDefaultDeviceRef,
+ setDraft,
+ settleRuntime,
+ appliedPermissionMemoryRef,
+ draft,
+ runtimeActionSeqRef,
+ selectedDeviceRef,
+ capabilities,
+ modelRows,
+ modelSections,
+}: {
+ newSessionPreferences: NewSessionStoredPreferences | null;
+ newSessionPreferencesLoaded: boolean;
+ userTouchedRuntimeRef: MutableRefObject<boolean>;
+ preferredDefaultDevice: { deviceId: string } | null | undefined;
+ selectedDeviceId: string;
+ hostDraftDefaults: NewSessionHostDefaults | null;
+ hostDefaultsSettled: boolean;
+ hostRuntimeFor: (agent: NewSessionAgentKind) => NewSessionRuntime | null;
+ deviceProviders: UseDeviceProvidersResult;
+ deviceProvidersRef: MutableRefObject<UseDeviceProvidersResult>;
+ catalogReadyRef: MutableRefObject<boolean>;
+ flatModelsForUnsupportedHost: (deviceId: string, agent: NewSessionAgentKind, unsupported: boolean) => readonly MobileModelOption[] | undefined;
+ targetAgentHasFast: (deviceId: string, agent: NewSessionAgentKind) => boolean;
+ draftMemory: MobileModelMemoryAccessors;
+ autoDefaultDeviceRef: MutableRefObject<string | null>;
+ setDraft: Dispatch<SetStateAction<NewSessionDraft>>;
+ settleRuntime: (source: string, deviceId: string) => void;
+ appliedPermissionMemoryRef: MutableRefObject<boolean>;
+ draft: NewSessionDraft;
+ runtimeActionSeqRef: MutableRefObject<number>;
+ selectedDeviceRef: MutableRefObject<string>;
+ capabilities: MobileAgentCapabilities | null;
+ modelRows: ProviderModelRow[];
+ modelSections: ReturnType<typeof buildMobileModelSections>;
+}) {
+ const storedAgentRestoreRef = useRef<StoredAgentRestoreState | null>(null);
+ const autoDefaultSnapshotRef = useRef<NewSessionHostDefaults | null | undefined>(undefined);
+ useEffect(() => {
+ const storedAgentKind = newSessionPreferences?.agentKind;
+ if (!newSessionPreferencesLoaded || !storedAgentKind) return;
+ if (userTouchedRuntimeRef.current) return;
+ const restored = storedAgentRestoreRef.current;
+ if (!isStoredAgentRestorePending({
+ storedAgentKind,
+ appliedStoredAgentKind: restored?.phase === 'done' ? restored.agentKind : null,
+ expectedDeviceId: preferredDefaultDevice?.deviceId ?? '',
+ selectedDeviceId,
+ })) return;
+ // agent 偏好一到就恢复;模型要等被控电脑的新建任务默认与目录,否则选不出模型。
+ const step = nextStoredAgentRestoreStep({
+ storedAgentKind,
+ restored,
+ modelReady: canResolveStoredAgentRuntime({
+ deviceId: selectedDeviceId,
+ hostDefaultsSettled: hostDraftDefaults?.deviceId === selectedDeviceId
+ && storedAgentKind in hostDraftDefaults.byAgent,
+ hostRuntime: hostRuntimeFor(storedAgentKind),
+ catalogReady: deviceProviders.ready,
+ providersUnsupported: deviceProviders.unsupported,
+ }),
+ });
+ if (!step) return;
+ mobileDebugLog('debug', 'new-session', 'stored agent restore', { step, agentKind: storedAgentKind });
+ const previousRestore = restored;
+ const restoreState: StoredAgentRestoreState = { agentKind: storedAgentKind, phase: step === 'agent' ? 'agent' : 'done' };
+ storedAgentRestoreRef.current = restoreState;
+ // 现场按最新目录算该 agent 的默认运行配置(rows 与 ready 必须同一代,codex review P2)。
+ const resolveStoredRuntime = (currentEffort: string) => {
+ const rowsNow = flattenProviderSections(
+ buildMobileModelSections({
+ providers: deviceProvidersRef.current.providers,
+ agentKind: storedAgentKind,
+ visibilityOverrides: deviceProvidersRef.current.modelVisibilityOverrides,
+ }).sections,
+ );
+ const next = pickAgentDefaultRuntime({
+ agentKind: storedAgentKind,
+ hostRuntime: hostRuntimeFor(storedAgentKind),
+ modelRows: rowsNow,
+ currentEffort,
+ catalogReady: catalogReadyRef.current,
+ visibilityOverrides: deviceProvidersRef.current.modelVisibilityOverrides,
+ flatModels: flatModelsForUnsupportedHost(selectedDeviceId, storedAgentKind, deviceProvidersRef.current.unsupported),
+ });
+ return {
+ model: next.model,
+ effort: next.effort,
+ providerId: next.providerId,
+ // fast 按 (agent, 来源, 模型) 记忆恢复,无记忆置 false;恢复前过与手动选行
+ // 同款的 fastEditable 门控(codex review P2:目录/能力变化后不得恢复出
+ // UI 显示关、实际发 true 的矛盾态)。agent 级门控只认目标 agent 的缓存
+ // 能力表(codex review P1:此刻闭包里的 capabilities 属于切换前 agent 或
+ // 为 null);目标 caps 未就绪 → false,由延迟恢复 effect 就绪后补评。
+ fastMode: next.providerId
+ && isFastRestorable(next.agentKind, next.providerId, next.model, rowsNow, targetAgentHasFast(selectedDeviceId, next.agentKind))
+ ? (draftMemory.getFast(next.agentKind, next.providerId, next.model) ?? false)
+ : false,
+ };
+ };
+ // Stored-engine restoration and the generic default effect consume the same
+ // snapshot; only a later host refresh may seed the untouched draft again.
+ const previousAutoDefaultSnapshot = autoDefaultSnapshotRef.current;
+ autoDefaultSnapshotRef.current = hostDraftDefaults;
+ if (step === 'model') {
+ // agent 与权限已在第一步恢复;只补模型,不动 agent 与权限(期间用户改过权限/计划模式不被覆盖)。
+ setDraft((current) => (current.agentKind === storedAgentKind
+ ? { ...current, ...resolveStoredRuntime(current.effort) }
+ : current));
+ settleRuntime('stored-agent-model', selectedDeviceId);
+ return;
+ }
+ // 该路径同时负责恢复 agent 权限,下面的通用权限记忆 effect 不再重复弹框。
+ appliedPermissionMemoryRef.current = true;
+ const previousAutoDefaultDevice = autoDefaultDeviceRef.current;
+ if (selectedDeviceId) autoDefaultDeviceRef.current = selectedDeviceId;
+ let applied = false;
+ const storedPermissionMode = newSessionPreferences?.permissionModeByAgent[storedAgentKind];
+ const nextPermissionMode =
+ storedPermissionMode ??
+ defaultPermissionModeForNewSessionAgent(storedAgentKind);
+ let cancelled = false;
+ const deviceAtTrigger = selectedDeviceId;
+ const seqAtTrigger = ++runtimeActionSeqRef.current;
+ void (async () => {
+ const confirmed = await confirmFullAccessChange(draft.permissionMode, nextPermissionMode, {
+ restoringRememberedChoice: storedPermissionMode !== undefined,
+ });
+ if (cancelled) return;
+ // 确认期间设备已切换 → 放弃本次写入,新设备自己的恢复/自动默认 effect 会接管。
+ if (deviceAtTrigger !== selectedDeviceRef.current) return;
+ // 确认期间用户又切了 agent / 手动选了模型 → 旧回调不得覆盖新选择。
+ if (seqAtTrigger !== runtimeActionSeqRef.current) return;
+ applied = true;
+ setDraft((current) => ({
+ ...current,
+ ...resolveStoredRuntime(current.effort),
+ agentKind: storedAgentKind,
+ // 上次明确选择过的权限直接沿用;内置默认若升级到 Full access 仍需确认。
+ permissionMode: confirmed ? nextPermissionMode : current.permissionMode,
+ }));
+ // 'agent' 只恢复了 agent,模型仍是占位,等数据到了由 'model' 落定。
+ if (step === 'full') settleRuntime('stored-agent', deviceAtTrigger);
+ })();
+ return () => {
+ cancelled = true;
+ // 写入前依赖已变(effect 重跑):撤回「已恢复」与设备锁,让重跑的 effect 重新恢复。
+ // 否则标记已落、草稿却没写,两条默认路径都不再处理,页面停在占位模型。
+ if (applied) return;
+ if (storedAgentRestoreRef.current === restoreState) storedAgentRestoreRef.current = previousRestore;
+ if (autoDefaultDeviceRef.current === selectedDeviceId) {
+ autoDefaultDeviceRef.current = previousAutoDefaultDevice;
+ autoDefaultSnapshotRef.current = previousAutoDefaultSnapshot;
+ }
+ };
+ }, [
+ draft.permissionMode,
+ deviceProviders.ready,
+ deviceProviders.unsupported,
+ deviceProviders.providers,
+ deviceProviders.modelVisibilityOverrides,
+ hostDefaultsSettled,
+ hostDraftDefaults,
+ hostRuntimeFor,
+ newSessionPreferences,
+ newSessionPreferences?.agentKind,
+ newSessionPreferencesLoaded,
+ preferredDefaultDevice?.deviceId,
+ selectedDeviceId,
+ ]);
+
+ // 权限记忆恢复:偏好加载后按当前 agent 恢复上次选过的档(一次;对齐桌面 lastByVendor)。
+ // storedAgentKind 路径由上面的 effect 覆盖;这里兜住「没存过 agent 但存过权限」的场景。
+ useEffect(() => {
+ if (!newSessionPreferencesLoaded || appliedPermissionMemoryRef.current) return;
+ appliedPermissionMemoryRef.current = true;
+ // 有存储的 agent 时由上面的 agent 恢复 effect 统一处理,避免同一轮出现两个确认框。
+ if (newSessionPreferences?.agentKind) return;
+ const remembered = newSessionPreferences?.permissionModeByAgent[draft.agentKind];
+ if (!remembered || remembered === draft.permissionMode) return;
+ let cancelled = false;
+ const seqAtTrigger = runtimeActionSeqRef.current;
+ void confirmFullAccessChange(draft.permissionMode, remembered, {
+ restoringRememberedChoice: true,
+ }).then((confirmed) => {
+ if (cancelled || !confirmed || seqAtTrigger !== runtimeActionSeqRef.current) return;
+ setDraft((current) => ({ ...current, permissionMode: remembered }));
+ });
+ return () => {
+ cancelled = true;
+ };
+ }, [draft.agentKind, draft.permissionMode, newSessionPreferences, newSessionPreferencesLoaded]);
+
+ // 新建任务默认运行配置 = 被控电脑记住的当前 agent 新建任务默认(model+effort+来源,与桌面远程新建同源);
+ // 没有则优先区域默认、再用模型列表最上面那个。一旦用户手动选过模型即不再覆盖;切设备(未手动选过)按新设备重算。
+ // 决策逻辑全在纯函数 resolveNewSessionAutoDefault 里(便于单测);此 effect 只负责"调纯函数 → setDraft + 更新 ref"。
+ // 被控电脑默认与 providers 都是异步到达,任一就绪后此 effect 再触发。
+ useEffect(() => {
+ if (!newSessionPreferencesLoaded) return;
+ const result = resolveNewSessionAutoDefault({
+ userTouched: userTouchedRuntimeRef.current,
+ appliedDeviceId: autoDefaultSnapshotRef.current === hostDraftDefaults ? autoDefaultDeviceRef.current : null,
+ selectedDeviceId,
+ hostDefaultsSettled,
+ hostRuntime: hostRuntimeFor(draft.agentKind),
+ modelRows,
+ rowsAgentKind: draft.agentKind,
+ catalogReady: deviceProviders.ready,
+ visibilityOverrides: deviceProviders.modelVisibilityOverrides,
+ providersUnsupported: deviceProviders.unsupported,
+ // provider-aware 模式只用经过可见性过滤的 rows;目录确实不可用时才回退
+ // capabilities(上游 main 移植,merge 2026-08-07)。
+ availableModels: deviceProviders.unsupported
+ ? capabilities?.availableModels
+ : undefined,
+ currentEffort: draft.effort,
+ });
+ if (!result) return;
+ const previousAutoDefaultDevice = autoDefaultDeviceRef.current;
+ const previousAutoDefaultSnapshot = autoDefaultSnapshotRef.current;
+ autoDefaultDeviceRef.current = result.appliedDeviceId;
+ autoDefaultSnapshotRef.current = hostDraftDefaults;
+ let applied = false;
+ const nextAgentKind = result.patch.agentKind ?? draft.agentKind;
+ const storedPermissionMode = appliedPermissionMemoryRef.current
+ ? undefined
+ : newSessionPreferences?.permissionModeByAgent[nextAgentKind];
+ const nextPermissionMode = appliedPermissionMemoryRef.current
+ ? draft.permissionMode
+ : storedPermissionMode ?? defaultPermissionModeForNewSessionAgent(nextAgentKind);
+ let cancelled = false;
+ void confirmFullAccessChange(draft.permissionMode, nextPermissionMode, {
+ restoringRememberedChoice: storedPermissionMode !== undefined,
+ }).then((confirmed) => {
+ if (cancelled || userTouchedRuntimeRef.current) return;
+ applied = true;
+ settleRuntime(result.source, result.appliedDeviceId);
+ setDraft((current) => {
+ // 自动默认重算(设备切换/最近会话变化)改了 (agent, model, providerId) 组合 →
+ // fastMode 按新组合重验(Codex review P2):A 设备记忆恢复的 fastMode:true 不得
+ // 随 `...current` 带进 B 的组合(若 B 的模型行不支持 Fast,终检/延迟恢复/能力
+ // 协调三条路径都不会处理它)。组合变化时保守关闭,由延迟恢复 effect 在 B 的
+ // 组合 + 能力就绪后按记忆重评(手动关过 → 记忆为 false,不会重新打开)。
+ const nextModel = result.patch.model ?? current.model;
+ // providerId 用 `!== undefined` 而非 `??`:patch 显式带 providerId:null(来源
+ // 切回默认路由)是真实的组合变化,`??` 会取回旧值抹掉该变化(Codex review P2)。
+ const nextProviderId = result.patch.providerId !== undefined
+ ? result.patch.providerId
+ : current.providerId;
+ const nextAgentKind = result.patch.agentKind ?? current.agentKind;
+ const comboChanged = nextModel !== current.model
+ || nextProviderId !== current.providerId
+ || nextAgentKind !== current.agentKind;
+ return {
+ ...current,
+ ...result.patch,
+ ...(comboChanged ? { fastMode: false } : {}),
+ // 自动恢复上次明确选择的权限不再重复确认;内置默认仍按升级规则确认。
+ permissionMode: confirmed ? nextPermissionMode : current.permissionMode,
+ };
+ });
+ });
+ return () => {
+ cancelled = true;
+ // 写入前 effect 重跑:撤回设备锁,重跑时按最新数据重新应用,不把这台设备误记为已应用。
+ if (!applied && autoDefaultDeviceRef.current === result.appliedDeviceId) {
+ autoDefaultDeviceRef.current = previousAutoDefaultDevice;
+ autoDefaultSnapshotRef.current = previousAutoDefaultSnapshot;
+ }
+ };
+ }, [capabilities?.availableModels, deviceProviders.loading, draft.effort, draft.permissionMode, draft.agentKind, modelRows, deviceProviders.ready, deviceProviders.modelVisibilityOverrides, deviceProviders.unsupported, modelSections.connected.length, newSessionPreferences, newSessionPreferencesLoaded, selectedDeviceId, hostDefaultsSettled, hostDraftDefaults, hostRuntimeFor]);
+
+}
diff --git a/apps/mobile/src/session/useNewSessionHostDefaults.ts b/apps/mobile/src/session/useNewSessionHostDefaults.ts
new file mode 100644
index 0000000000..d90472435d
--- /dev/null
+++ b/apps/mobile/src/session/useNewSessionHostDefaults.ts
@@ -0,0 +1,157 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { getMobileAuthOwner, isMobileAuthOwnerCurrent, type MobileAuthOwnerGeneration } from '@/auth/authOwnerGeneration';
+import type { MobileMakerTransport } from '@/device-link/mobileMakerTransport';
+import { withTransientRemoteRetry } from '@/device-link/remoteRetry';
+import { NEW_SESSION_AGENT_OPTIONS, hostDraftRuntimeFromDefaults, isHostDraftDefaultsReady, type NewSessionDraft, type NewSessionAgentKind, type NewSessionRuntime } from './newSession';
+import { cacheNewSessionHostDefaults, getNewSessionHostDefaults, rememberNewSessionHostRuntime, type NewSessionHostDefaults } from './newSessionHostDefaultsCache';
+
+export function useNewSessionHostDefaults({
+ selectedDeviceId, deviceLinkStatus, maker, openLink, outboxOwner, remoteAgentChoice, draft
+}: {
+ selectedDeviceId: string;
+ deviceLinkStatus: string;
+ maker: Pick<MobileMakerTransport, 'getNewMakerDefaults' | 'applyNewMakerDraftPref'>;
+ openLink: (deviceId: string) => Promise<unknown>;
+ outboxOwner: MobileAuthOwnerGeneration;
+ remoteAgentChoice: unknown;
+ draft: NewSessionDraft;
+}) {
+ const selectedDeviceRef = useRef(selectedDeviceId);
+ selectedDeviceRef.current = selectedDeviceId;
+ const [hostDraftDefaults, setHostDraftDefaults] = useState<NewSessionHostDefaults | null>(
+ () => getNewSessionHostDefaults(selectedDeviceId),
+ );
+ const hostDraftDefaultsRef = useRef(hostDraftDefaults);
+ hostDraftDefaultsRef.current = hostDraftDefaults;
+ // 在途读取:切 agent 时等它读完再选模型,避免先落目录默认、又因已手动切换而再也补不回来。
+ const hostDraftDefaultsLoadRef = useRef<{
+ deviceId: string;
+ byAgent: Partial<Record<NewSessionAgentKind, Promise<void>>>;
+ } | null>(null);
+ useEffect(() => {
+ const deviceId = selectedDeviceId;
+ const owner = getMobileAuthOwner();
+ const cached = getNewSessionHostDefaults(deviceId);
+ hostDraftDefaultsRef.current = cached;
+ setHostDraftDefaults(cached);
+ if (!deviceId || deviceLinkStatus !== 'online' || !owner.accountKey) return undefined;
+ let cancelled = false;
+ const successfulAgents = new Set<NewSessionAgentKind>();
+ const isCurrent = () => !cancelled && isMobileAuthOwnerCurrent(owner);
+ const readAgent = async (agentKind: NewSessionAgentKind) => {
+ for (let attempt = 0; ; attempt += 1) {
+ const defaults = await withTransientRemoteRetry(async () => {
+ await openLink(deviceId);
+ return maker.getNewMakerDefaults(agentKind);
+ }, { maxAttempts: 2 }).catch(() => undefined);
+ if (!isCurrent()) return null;
+ // 被控端刚启动、渲染进程还没推来草稿时回 {}:稍后重读,不把它当成「从未选过模型」;
+ // 有限次后(含不带该字段的旧被控端)按无默认处理。读取失败不重读。
+ if (defaults === undefined || isHostDraftDefaultsReady(defaults) || attempt >= 2) {
+ if (!isHostDraftDefaultsReady(defaults)) {
+ if (cached) return cached.byAgent[agentKind] ?? null;
+ } else {
+ successfulAgents.add(agentKind);
+ }
+ return hostDraftRuntimeFromDefaults(defaults, agentKind);
+ }
+ await new Promise<void>((resolve) => setTimeout(resolve, 1_500));
+ if (!isCurrent()) return null;
+ }
+ };
+ const byAgent = Object.fromEntries(NEW_SESSION_AGENT_OPTIONS.map(({ kind }) => [kind, readAgent(kind).then((runtime) => {
+ if (!isCurrent()) return;
+ // Publish each engine as soon as it settles. Leaving this page while an
+ // unrelated engine is slow must not discard a successful default.
+ const snapshot = {
+ deviceId,
+ byAgent: { ...hostDraftDefaultsRef.current?.byAgent, [kind]: runtime, ...hostChoiceOverridesRef.current.get(deviceId) },
+ };
+ // A failed optional engine must not discard another engine's successful read.
+ // Unknown engines stay absent from the cross-page cache; this visit may still
+ // fall back after the read has failed, as before.
+ const cacheable = {
+ deviceId,
+ byAgent: {
+ ...cached?.byAgent,
+ [kind]: runtime,
+ ...hostChoiceOverridesRef.current.get(deviceId),
+ },
+ };
+ const remembered = successfulAgents.has(kind) ? cacheNewSessionHostDefaults(cacheable, cached) : getNewSessionHostDefaults(deviceId);
+ const next = { ...snapshot, byAgent: { ...snapshot.byAgent, ...remembered?.byAgent, ...hostChoiceOverridesRef.current.get(deviceId) } };
+ // 同步更新镜像:等待中的切 agent 回调在下一次渲染前就要读到结果。
+ hostDraftDefaultsRef.current = next;
+ setHostDraftDefaults(next);
+ })]));
+ hostDraftDefaultsLoadRef.current = { deviceId, byAgent };
+ return () => {
+ cancelled = true;
+ };
+ }, [deviceLinkStatus, maker, openLink, selectedDeviceId, outboxOwner]);
+ // 只等目标 agent 的默认读完(读完、失败都算);没有在途读取(离线 / 未选设备)时不等,
+ // 按目录默认继续。effect 重跑会换一份新的在途读取,跟着等新的那份(有限次)。
+ const waitHostDraftDefaults = useCallback(async (deviceId: string, agentKind: NewSessionAgentKind) => {
+ for (let attempt = 0; attempt < 3; attempt += 1) {
+ if (hostDraftDefaultsRef.current?.deviceId === deviceId
+ && agentKind in hostDraftDefaultsRef.current.byAgent) return;
+ const load = hostDraftDefaultsLoadRef.current;
+ if (!load || load.deviceId !== deviceId) return;
+ await load.byAgent[agentKind];
+ }
+ }, []);
+ const hostDefaultsSettled = !!selectedDeviceId && hostDraftDefaults?.deviceId === selectedDeviceId
+ && draft.agentKind in hostDraftDefaults.byAgent;
+ // 本页已写回被控电脑的选择(按设备、agent):优先于读取结果,避免选择前发出的读取
+ // 晚到后把旧模型带回来(切到别的 agent 再切回时)。
+ const hostChoiceOverridesRef = useRef(new Map<string, Partial<Record<NewSessionAgentKind, NewSessionRuntime>>>());
+ const hostChoiceOwnerRef = useRef(outboxOwner);
+ if (hostChoiceOwnerRef.current !== outboxOwner) {
+ hostChoiceOwnerRef.current = outboxOwner;
+ hostChoiceOverridesRef.current.clear();
+ }
+ const hostRuntimeFor = useCallback(
+ (agentKind: NewSessionAgentKind): NewSessionRuntime | null => {
+ const deviceId = selectedDeviceRef.current;
+ const chosen = hostChoiceOverridesRef.current.get(deviceId)?.[agentKind];
+ if (chosen) return chosen;
+ const current = hostDraftDefaultsRef.current;
+ return current && current.deviceId === deviceId
+ ? current.byAgent[agentKind] ?? null
+ : null;
+ },
+ [],
+ );
+ // 在新建任务页选的模型 / 档位写回被控电脑的新建任务默认(与桌面远程新建同一写法
+ // maker:apply-new-maker-draft-pref active=true),下次在这台电脑上新建任务——不论手机、
+ // 桌面还是远程桌面——默认都是它。由选择入口发请求,本 effect 在草稿提交后读最终值写出;
+ // 写失败不打扰,本页草稿照常生效。远程 Agent(模型属于另一台电脑)不写回被控电脑。
+ const [hostChoiceRequest, setHostChoiceRequest] = useState<{ seq: number; markModelChoice: boolean } | null>(null);
+ const hostChoiceSentSeqRef = useRef(0);
+ const requestHostChoiceWrite = useCallback((markModelChoice: boolean) => {
+ setHostChoiceRequest((current) => ({ seq: (current?.seq ?? 0) + 1, markModelChoice }));
+ }, []);
+ useEffect(() => {
+ if (!hostChoiceRequest || hostChoiceRequest.seq === hostChoiceSentSeqRef.current) return;
+ hostChoiceSentSeqRef.current = hostChoiceRequest.seq;
+ if (!selectedDeviceId || remoteAgentChoice || !draft.model) return;
+ const { agentKind, model, providerId, effort, fastMode } = draft;
+ void maker.applyNewMakerDraftPref({
+ agent: agentKind,
+ providerId: providerId ?? '',
+ modelId: model,
+ active: true,
+ markModelChoice: hostChoiceRequest.markModelChoice,
+ ...(effort ? { effort } : {}),
+ fast: fastMode,
+ }).catch(() => undefined);
+ // 记下本页选择:切到别的 agent 再切回时取到它,不被在途或更早的读取结果覆盖。
+ const overrides = hostChoiceOverridesRef.current;
+ overrides.set(selectedDeviceId, {
+ ...overrides.get(selectedDeviceId),
+ [agentKind]: { agentKind, model, effort, providerId },
+ });
+ rememberNewSessionHostRuntime(selectedDeviceId, { agentKind, model, effort, providerId });
+ }, [draft, hostChoiceRequest, maker, remoteAgentChoice, selectedDeviceId]);
+ return { hostDraftDefaults, hostDefaultsSettled, hostRuntimeFor, waitHostDraftDefaults, requestHostChoiceWrite };
+}