Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* newMakerDraft —— "/cc-agent/new" 草稿状态 + vendor 偏好的 localStorage 持久化。
*
* 设计:
* - sidebar 顶部 "+ New Maker" 不再立即 createSession;改为 navigate('/cc-agent/new')
* 并由 NewMakerDraftRoute 消费此 store 的状态。
* - vendor 当前选择 + 每个 vendor 上次的 model/effort/permissionMode 都存这里。
* Fast Mode 按模型记忆;workingDir 也存这里(初次为 null,Project 行内 + 会预填到此)。
* - 文本内容仍由 ChatInput 自己的 composerDraftStore 按 sessionId='new' 持久化,本 store 不掺和。
* - 附件不持久化(useAttachments 内存为主)。
* - localStorage key 带 v1 后缀便于将来 schema 升级时静默回退。
*
* 跨 app 重启行为(冒险者明确要求):
* - vendor / lastByVendor / fastModeByModel / workingDir → 保留
* - 文本(composerDraftStore) → 保留
* - 附件 → 丢失(产品决策)
* - extraDirs → 丢失(2026-07-25 用户定稿:引用目录是单次草稿的临时授权范围,
* 不是偏好记忆;静默还原会让旧目录无感知地带进新会话)
*/
import { useSyncExternalStore } from 'react';
import { isDataOwnerPushStampCurrent } from '@/contexts/dataOwnerGeneration';
import { sameModelRoute, type AppDefaultModelSelection } from '../../shared/appDefaultModelSelection';
import type { BotModelRoute } from '../../shared/botModelChain';
import type { MakerVendor } from '@/lib/ccAgent.types';
import { isSelectableVendor } from '@/lib/agentVendors';
import type { Effort, PermissionMode } from '@/lib/userPreferences.types';
import { getDefaultModelForVendor } from '@/lib/modelDefinitions';
import { isKnownProductDefaultTupleIdentity } from '@/lib/newMakerDefaultTuple';
import type { OrcaWorkerPermissionMode } from '../../shared/orca-worker-permission-mode';
import { normalizeWorkingDirForStorage } from '../../shared/workingDir';
import { getManagedWorktreeBasePath } from '../../shared/managedWorktreePaths';
const STORAGE_KEY = 'xdt:newMakerDraft:v1';
let activeDataOwnerId: string | null = null;
function storageKey(): string {
return activeDataOwnerId ? `${STORAGE_KEY}:${encodeURIComponent(activeDataOwnerId)}` : STORAGE_KEY;
}
export interface VendorPrefs {
model: string;
effort: Effort;
permissionMode: PermissionMode;
/** Explicit picker choice; absent legacy non-auto values are preserved. */
permissionModeCustomized?: boolean;
/**
* 计划模式一级开关(与 permissionMode 正交)。草稿开着时,发送建会话透传
* planModeEnabled 落库 + createOpts.planMode 生效。老 localStorage 缺字段 → false。
*/
planMode: boolean;
/**
* per-vendor 记忆的「来源(供应商)」显式选择。null = 跟随该 agent 原生默认路由。
* 与 model/effort 同口径:切 vendor / 重启后由 ChatInput 的 initialProviderId seed 回填,
* 发送建会话时透传给 createSession,使草稿选定的来源在新会话里生效(与会话内切来源一致)。
*/
providerId?: string | null;
}
/**
* 草稿阶段的协同(Lead+Worker)开关状态。
*
* 之前是 NewMakerDraftRoute 内部的 useState(纯内存),和 workingDir 的 localStorage
* 持久化不一致——重启 / 切走再回 /cc-agent/new 都会丢。
* 现在并入 draft store: 协同 + workdir 都从 newMakerDraft 这一个 store 读写,
* 行为统一,重启也能恢复上次选择。
*
* 协同与工作区形态正交:项目和对话草稿都能开启;只有真正开始一次新草稿时才把
* enabled 复位为 false,避免把上一次发送的协同选择静默带到下一次。
*/
/**
* 「开启协同」弹窗(CreateWorkerPopover)收集的 Worker 详细配置。
* 草稿态没有 sessionId 无法立刻起 worker,故把富配置存进 draft,createSession 后透传给 enableOrca
* (与会话内 requestEnableCollab 同口径)。老 draft / 未配置时为 undefined,createSession 回退默认。
*/
export interface CollabWorkerConfig {
role: string;
model: string;
effort?: Effort;
fast?: boolean | 'ultrafast';
/** 显式选定的模型来源;null/缺省 = 未显式(main 侧按默认路由解析)。 */
providerId?: string | null;
/** 首条派工任务。一次性,故意不跨重启持久化(sanitize 加载时丢弃,见下方解析)。 */
initialTask?: string;
/** 当前协同 Team 后续新 Worker 共用的默认权限。 */
workerPermissionMode?: OrcaWorkerPermissionMode;
/**
* 首个 Worker 的运行设备与那台上的目录。与 initialTask 一样不跨重启持久化:设备在线与
* 版本随时会变,重启后回到这台电脑,由用户重新选择。
*/
executionDeviceId?: string;
executionWorkingDir?: string;
/**
* 首个 Worker 的 Agent 所在电脑(远程供应商):string = 那台电脑或分享,null = 任务所在电脑,
* 缺省 = 跟 Lead。模型与来源是按这个位置的目录选的;与草稿自己的 agentDeviceId 一样不跨重启
* 保留,带着它的整份配置在加载时丢弃(只丢位置会让模型落到别的目录上)。
*/
agentDeviceId?: string | null;
}
export interface CollabDraft {
enabled: boolean;
worker: 'cc' | 'codex' | 'pi';
workerConfig?: CollabWorkerConfig;
}
export interface NewMakerDraft {
/** 当前选中的 vendor。默认 'cc',用户切换后写回 + 持久化。 */
vendor: MakerVendor;
/** 选中的 workingDir;初次 null,Project 行内 + 会预填到此。 */
workingDir: string | null;
/** 远程项目所属 host。null = 本地项目或对话。 */
remoteHostId: string | null;
/**
* device-link 跨设备远程控制:本草稿目标被控设备 deviceId(非 null = 这是"在远程设备
* 项目里新建对话")。**故意不跨重启持久化**——deviceId 绑定的是一台可能离线的活动设备,
* sanitize 从 localStorage 加载时一律置 null(见 sanitize),只在单次会话内有效。
*/
deviceLinkDeviceId: string | null;
/** device-link 目标设备友好名(草稿页横幅展示),与 deviceLinkDeviceId 同源。 */
deviceLinkDeviceName: string | null;
/**
* Agent 在同账号另一台电脑上运行(任务、项目文件与命令仍在任务所在电脑:本机,或 deviceLinkDeviceId
* 那台被控电脑):运行 Agent 的那台电脑的 deviceId。模型目录、Agent 登录与供应商都来自那台。
* 与 remoteHostId 互斥;换任务所在电脑即清空。与 deviceLinkDeviceId 同理**不跨重启持久化**
* (绑的是一台可能离线的活动设备)。
*/
agentDeviceId: string | null;
/** agentDeviceId 那台电脑的友好名(展示用)。 */
agentDeviceName: string | null;
/** 协同模式开关 + Worker 类型(草稿期持久化,Send 时由 enableOrca 消费)。 */
collab: CollabDraft;
/**
* 「新建会话默认启用 worktree」勾选记忆。vendor 无关的根级布尔(同 collab 先例),
* 语义是「这台工作端上新建会话时 worktree 开关的默认状态」——桌面本机草稿与手机 /
* 桌面控制端远程草稿读写同一份(读经 maker:get-new-maker-defaults 镜像,写经
* maker:apply-new-maker-worktree-pref 写穿)。
* 只在用户**显式**切换开关时写入;切项目、选分支、资格探测、重连等其它操作
* 一律保持原值,避免环境因素抹掉用户偏好。
* 直接复用 Cindy 现有 newMakerDraft 配置命名空间,不另建 worktree 专用配置。
* 有效值由系统默认 + worktreePreferenceCustomized override 合成。
*/
worktreeEnabled: boolean;
/**
* worktreeEnabled 是否来自用户显式选择。false 时持久化快照里的布尔只是一份
* 旧系统默认缓存,加载时必须按当前系统默认重新合成,不能把默认永久固化。
*/
worktreePreferenceCustomized: boolean;
/**
* New Maker 的 Fast Mode 记忆,按模型分开。
* 缺省 false;实际是否可用还要由 UI 结合 capabilities 判定。
*/
fastModeByModel: Record<string, boolean | 'ultrafast'>;
/**
* 每个 modelId 上一次显式选过的 effort,跨 ChatInput 实例 / 跨 New Maker
* 创建持久化。场景:在 Opus 4.7 选了 high → 切到 Haiku (强制落到 low) →
* 发送 → + New Maker → 再切回 Opus 4.7,应该恢复 high 而不是停在 low。
* (在此字段加入之前,ChatInput 内的 effortByModelRef 只在单个实例生命周期里有效,
* 新 ChatInput 一 mount 这份记忆就丢了,导致每个 model 默认沿用 lastByVendor.effort,
* 而那个 effort 又被切到无 effort 的 Haiku 时硬塞成了 low。)
*/
effortByModel: Record<string, Effort>;
/**
* 草稿期间用户加的附加只读引用目录列表(绝对路径)。draft-wide,不分 vendor。
* Claude 与 Codex session 都会透传,并支持会话中途覆盖。
* 生命周期是"单次草稿":发送后清空(resetDraftWorkspaceAfterSend)、进入草稿页
* 清空(NewMakerDraftRoute mount)、**不跨重启还原**(sanitize 一律置空)。
*/
extraDirs: string[];
/** 单次草稿内用户明确授予的附加可读写目录;不跨重启。 */
writableDirs: string[];
/** 每个 vendor 的"上次使用配置"——切回该 vendor 时自动恢复。 */
lastByVendor: Record<MakerVendor, VendorPrefs>;
/**
* 用户是否**显式**选过该 vendor 的模型(新建页 picker,或已有任务里换模)。
* lastByVendor 整个快照随任意 draft 写入落盘,model 即使从没被用户碰过也会带上
* sanitize 的种子默认值 —— 仅凭 lastByVendor 无法区分"真选过"和"默认回填"。
* 调度任务默认模型的三级回退(getPersistedVendorModel 消费)只认这里标记过的
* vendor,否则全新 / 没用过该 vendor 的用户会拿到未经供应商清单校准的种子默认。
* patchVendorPrefs 收到显式 model 时置 true;只改思考档 / Fast
* 的会话回写走 patchVendorPrefsPreservingModelChoice:不得打标、不得清标,
* 也不得在已打标后改写 lastByVendor.model / providerId / effort。
*/
modelChosenByVendor: Partial<Record<MakerVendor, boolean>>;
/**
* 用户是否明确改过新任务的模型组合(Harness / 来源 / 模型 / 思考深度 / Fast)。
* false 才允许连接态为新任务下放产品默认;目录热更与登录变化不得覆盖 true。
*/
defaultTupleCustomized: boolean;
/** Local new-task default. null follows the product default (auto). */
newChatDefaultPermissionMode?: PermissionMode | null;
/**
* 自定义里是否包含 Harness / 来源 / 模型选择。与只调 effort / Fast 分开记,
* 这样「恢复推荐」只能撤销调档意图,不会顺手清掉真正的路由选择。
*/
defaultTupleSelectionCustomized: boolean;
}
/**
* 种子默认偏好。模型 id **一律经 getDefaultModelForVendor 从目录推荐位取**,不在这里写死:
* 这里曾写死 codex → 'gpt-5.4',与 modelDefinitions 里写死的 'gpt-5.5' 漂移成两个值,而两者
* 在目录里都是默认隐藏的模型 —— 种子默认模型压根不在用户看到的清单里。
*/
function defaultVendorPrefs(vendor: MakerVendor): VendorPrefs {
if (vendor === 'pi') {
return {
// pi 走 XD 网关(anthropic-messages 可达面),默认给网关中档模型;
// 目录未含该 id 时由 ChatInput 的 vendor 回退逻辑纠正。
model: 'claude-sonnet-5',
effort: 'high',
// 新 Pi 草稿默认走 Auto Review;完全访问只能由用户显式选择并持久化。
permissionMode: 'auto',
permissionModeCustomized: false,
planMode: false,
providerId: null,
};
}
if (vendor === 'codex') {
return {
model: getDefaultModelForVendor('codex').id,
effort: 'high',
permissionMode: 'auto',
permissionModeCustomized: false,
planMode: false,
providerId: null,
};
}
return {
model: getDefaultModelForVendor('cc').id,
effort: 'medium',
// 三种 vendor 都保留 Auto-review 种子默认;已有用户落盘的
// lastByVendor 记忆不受影响(sanitize 只在缺失 / 脏值时回落本默认)。
permissionMode: 'auto',
permissionModeCustomized: false,
planMode: false,
providerId: null,
};
}
function defaultCollab(): CollabDraft {
return { enabled: false, worker: 'codex' };
}
const DEFAULT_WORKTREE_ENABLED = false;
function makeDefault(): NewMakerDraft {
return {
vendor: 'cc',
workingDir: null,
remoteHostId: null,
deviceLinkDeviceId: null,
deviceLinkDeviceName: null,
agentDeviceId: null,
agentDeviceName: null,
collab: defaultCollab(),
worktreeEnabled: DEFAULT_WORKTREE_ENABLED,
worktreePreferenceCustomized: false,
fastModeByModel: {},
effortByModel: {},
extraDirs: [],
writableDirs: [],
lastByVendor: {
cc: defaultVendorPrefs('cc'),
pi: defaultVendorPrefs('pi'),
orca: defaultVendorPrefs('orca'),
codex: defaultVendorPrefs('codex'),
},
modelChosenByVendor: {},
defaultTupleCustomized: false,
newChatDefaultPermissionMode: null,
defaultTupleSelectionCustomized: false,
};
}
/**
* New Maker 的默认工作目录表示"项目入口",不是某次会话的隔离运行目录。
* Cindy 自己创建的 worktree 固定在 `<repo>/.cindy-worktrees/<name>` 下;品牌
* 迁移前的 `<repo>/.xdt-worktrees/<name>` 也继续识别。如果历史 localStorage
* 或未来调用方误把它写进 draft,这里折回项目根目录,避免再次新建 Maker 时
* 默认落到 worktree 里并触发"已在 worktree 中"。
*
* 这里故意只处理 Cindy 自己托管的目录:New Maker 草稿默认值不应折叠用户
* 手选的 `.worktrees` / `.claude/worktrees`。侧边栏会话分组需要识别更多
* worktree 形态,两边的职责不同,不要合并成同一套规则。
*/
function normalizeDraftWorkingDir(raw: unknown): string | null {
if (typeof raw !== 'string') return null;
const normalized = normalizeWorkingDirForStorage(raw);
if (normalized == null) return null;
return getManagedWorktreeBasePath(normalized) ?? normalized;
}
/** 严格校验 + 缺字段补齐——schema 损坏(老版本 / 手改 localStorage)时静默回退默认。 */
function sanitize(raw: unknown): NewMakerDraft {
const def = makeDefault();
if (!raw || typeof raw !== 'object') return def;
const r = raw as Partial<NewMakerDraft>;
// 引擎白名单按 SELECTABLE_VENDORS(选择器同一张表的来源)校验 —— 新增引擎时这里零改动。
// 曾经是逐个写死的三元(`r.vendor === 'codex' || r.vendor === 'pi' ? … : 'cc'`),
// 每上线一个引擎都得手工补一次;漏补则用户选中新引擎、重启后被静默重置回 Claude。
// F-COLLAB (2026-05): 'orca' 不在表内,历史 localStorage 残留会走同一条回退路径
// 迁到 'cc'(它已被 ChatInput 底部的协同 toggle 取代),避免空白入口。
const vendor: MakerVendor = isSelectableVendor(r.vendor) ? r.vendor : def.vendor;
const workingDir = normalizeDraftWorkingDir(r.workingDir);
const remoteHostId =
typeof r.remoteHostId === 'string' && r.remoteHostId.trim().length > 0
? r.remoteHostId.trim()
: null;
const lastByVendorRaw = (r.lastByVendor ?? {}) as Partial<NewMakerDraft['lastByVendor']>;
const fastModeByModelRaw =
r.fastModeByModel && typeof r.fastModeByModel === 'object'
? (r.fastModeByModel as Record<string, unknown>)
: {};
const fastModeByModel = Object.fromEntries(
Object.entries(fastModeByModelRaw)
.filter(([modelId]) => modelId.length > 0)
.map(([modelId, enabled]) => [modelId, enabled === 'ultrafast' ? 'ultrafast' as const : enabled === true]),
);
// effortByModel: 接受任何 string 值 (Effort 枚举校验交给消费方按当前模型 capabilities 过滤)。
// 老版本 localStorage 没有这个字段 → 空对象兜底。
const effortByModelRaw =
r.effortByModel && typeof r.effortByModel === 'object'
? (r.effortByModel as Record<string, unknown>)
: {};
const effortByModel = Object.fromEntries(
Object.entries(effortByModelRaw)
.filter(
([modelId, effort]) =>
modelId.length > 0 && typeof effort === 'string' && effort.length > 0,
)
.map(([modelId, effort]) => [modelId, effort as Effort]),
);
// extraDirs **故意不跨重启持久化**(同 deviceLinkDeviceId 先例):引用目录是
// 单次草稿的临时授权范围,静默还原会让用户无感知地把旧目录带进新会话。
// NewMakerDraftRoute mount 时也会清空(同一决定的双保险)。
const extraDirs: string[] = [];
const writableDirs: string[] = [];
// collab 校验: 老版本无此字段 → 默认 OFF + codex worker。
const collabRaw = (r as { collab?: Partial<CollabDraft> }).collab;
const collabWorker: CollabDraft['worker'] =
collabRaw?.worker === 'cc' ? 'cc' : collabRaw?.worker === 'pi' ? 'pi' : 'codex';
// remote 项目的协同 codex / cc draft 均放行:worker 创建已继承 remoteHostId
// (在同一台远端主机 spawn,见 OrcaLeadSessionSnapshot.remoteHostId),两端
// 远端 MCP 注入均已落地 (codex daemon config + cc per-query http 注入)。
// 本地项目(remoteHostId==null)不受影响。
const collabEnabled = collabRaw?.enabled === true;
// workerConfig 防御性解析:model 缺失/为空则整块丢弃(不存半截配置),createSession 回退默认。
const workerConfig: CollabWorkerConfig | undefined = (() => {
const wc = collabRaw?.workerConfig;
if (!wc || typeof wc !== 'object') return undefined;
// 按另一台电脑(远程供应商)目录选的配置不跨重启保留,见 CollabWorkerConfig.agentDeviceId。
if (typeof wc.agentDeviceId === 'string') return undefined;
const model = typeof wc.model === 'string' && wc.model.trim() ? wc.model : undefined;
if (!model) return undefined;
const role = typeof wc.role === 'string' && wc.role.trim() ? wc.role.trim() : 'developer';
return {
role,
model,
effort: typeof wc.effort === 'string' ? (wc.effort as Effort) : undefined,
fast: (typeof wc.fast === 'boolean' || wc.fast === 'ultrafast') ? wc.fast : undefined,
// 来源与模型是同一次选择的两个维度,随 model 一起耐久保留;与 role 同样 trim,
// 空白串回落未显式 —— IPC 侧把非空 string 当显式来源,漏 trim 会把无效 id
// 一路带到 PROVIDER_ROUTE_UNAVAILABLE(copilot review)。
providerId:
typeof wc.providerId === 'string' && wc.providerId.trim()
? wc.providerId.trim()
: undefined,
workerPermissionMode:
wc.workerPermissionMode === 'bypassPermissions' ? 'bypassPermissions' : 'auto',
// initialTask 是一次性任务,**故意不跨重启持久化**(同 deviceLinkDeviceId 先例):
// 重启后 Send/New Goal 会静默把过期任务当 delegateTask 发出去,而收起态 pill
// 无从看见/编辑(codex P2)。其余 Worker 配置(含 Team 默认权限)可耐久保留。
};
})();
const collab: CollabDraft = { enabled: collabEnabled, worker: collabWorker, workerConfig };
const newChatDefaultPermissionMode =
r.newChatDefaultPermissionMode === 'auto' || r.newChatDefaultPermissionMode === 'bypassPermissions'
? r.newChatDefaultPermissionMode : null;
const sanitizeVendorPrefs = (p: Partial<VendorPrefs> | undefined, v: MakerVendor): VendorPrefs => {
const fallback = { ...defaultVendorPrefs(v), permissionMode: newChatDefaultPermissionMode ?? 'auto' };
const permissionModeCustomized = p?.permissionModeCustomized === true ||
(p?.permissionModeCustomized === undefined && typeof p?.permissionMode === 'string' &&
p.permissionMode !== 'auto' && p.permissionMode !== 'plan');
if (!p || typeof p !== 'object') return fallback;
// 计划模式独立成一级开关后, 历史草稿里 permissionMode='plan' 迁移为
// planMode=true + 该 vendor 默认权限档(与 DB 迁移同语义)。
const legacyPlanPermission = p.permissionMode === 'plan';
return {
model: typeof p.model === 'string' && p.model.length > 0 ? p.model : fallback.model,
effort: typeof p.effort === 'string' ? (p.effort as Effort) : fallback.effort,
permissionMode:
permissionModeCustomized && typeof p.permissionMode === 'string' && !legacyPlanPermission
? (p.permissionMode as PermissionMode)
: fallback.permissionMode,
permissionModeCustomized,
planMode: p.planMode === true || legacyPlanPermission,
// providerId: 接受非空 string 或 null;脏数据 / 缺字段一律落 null(跟随默认路由)。
providerId:
typeof p.providerId === 'string' && p.providerId.length > 0 ? p.providerId : null,
};
};
// modelChosenByVendor: 老版本 localStorage 没有这个字段 → 空对象兜底
//(语义上等于"全部 vendor 都没显式选过",调度三级回退会落到新建任务默认)。
const modelChosenRaw =
r.modelChosenByVendor && typeof r.modelChosenByVendor === 'object'
? (r.modelChosenByVendor as Record<string, unknown>)
: {};
const modelChosenByVendor: Partial<Record<MakerVendor, boolean>> = {};
for (const v of ['cc', 'orca', 'codex', 'pi'] as const) {
if (modelChosenRaw[v] === true) modelChosenByVendor[v] = true;
}
// 老版本没有独立的组合标记:显式选过模型/来源/思考深度/Fast 都是足够强的
// 用户意图证据。preserving 写回会保留完整 vendor 快照与空 marker,所以不能再用
// 「只有 cc 单槽单字段」识别;cc 模型偏离当时同源的 seed 才是可保护的旧选择。
// 反过来,仅 vendor=codex/pi 不能算用户选择:旧版会在 cc 不可用时由系统自动 fallback。
const legacyCcPrefs = lastByVendorRaw.cc;
// 已经随旧版完整草稿自然落盘过的 cc seed。它们不是用户选择,不能因为新版目录换了
// seed 就反过来把系统快照认成自定义;这里只服务一次性迁移,不参与新会话默认决策。
const legacyCcSeedModels = new Set([def.lastByVendor.cc.model, 'claude-sonnet-4-6']);
const isKnownProductTuple = (slotVendor: MakerVendor, prefs: Partial<VendorPrefs>): boolean =>
typeof prefs.providerId === 'string' &&
prefs.providerId.length > 0 &&
typeof prefs.model === 'string' &&
prefs.model.length > 0 &&
isKnownProductDefaultTupleIdentity({
vendor: slotVendor,
providerId: prefs.providerId,
model: prefs.model,
});
const legacyCcModelCandidate =
vendor === 'cc' &&
legacyCcPrefs &&
typeof legacyCcPrefs === 'object' &&
typeof legacyCcPrefs.model === 'string' &&
legacyCcPrefs.model.length > 0 &&
!legacyCcSeedModels.has(legacyCcPrefs.model);
const legacyCcModel =
legacyCcModelCandidate &&
(r.defaultTupleCustomized === undefined || !isKnownProductTuple('cc', legacyCcPrefs));
const legacySourceSelection = (['cc', 'orca', 'codex', 'pi'] as const).some((slotVendor) => {
const prefs = lastByVendorRaw[slotVendor];
if (
!prefs ||
typeof prefs !== 'object' ||
typeof prefs.providerId !== 'string' ||
prefs.providerId.length === 0
) {
return false;
}
// 老版本完全没有组合标记时,来源是唯一可用的显式证据;已有单一 boolean 的过渡
// 版本则只排除产品策略能够自动写出的精确 tuple,保住“只换来源”的真实选择。
return r.defaultTupleCustomized === undefined || !isKnownProductTuple(slotVendor, prefs);
});
const legacySelectionCustomized =
Object.values(modelChosenByVendor).some(Boolean) || legacyCcModel || legacySourceSelection;
const legacyTuningCustomized =
Object.keys(effortByModel).length > 0 || Object.keys(fastModeByModel).length > 0;
const defaultTupleSelectionCustomized =
r.defaultTupleSelectionCustomized === true ||
(r.defaultTupleSelectionCustomized === undefined &&
r.defaultTupleCustomized !== false &&
legacySelectionCustomized);
const defaultTupleCustomized =
r.defaultTupleCustomized === true ||
defaultTupleSelectionCustomized ||
(r.defaultTupleCustomized === undefined && legacyTuningCustomized);
// 2026-07 已落盘但尚无显式标记的 true,只可能来自用户把当时默认 false 切到 true,
// 可安全迁移为 override;旧 false 无法区分“默认快照”与“明确关闭”,按未自定义处理。
const worktreePreferenceCustomized =
(
r.worktreePreferenceCustomized === true
&& typeof r.worktreeEnabled === 'boolean'
)
|| (
r.worktreePreferenceCustomized === undefined
&& r.worktreeEnabled === true
);
const worktreeEnabled = worktreePreferenceCustomized
? r.worktreeEnabled === true
: DEFAULT_WORKTREE_ENABLED;
return {
vendor,
workingDir,
remoteHostId: workingDir == null ? null : remoteHostId,
// device-link 目标**不跨重启恢复**:绑定的是活动设备,重启后可能已离线 → 一律置 null。
deviceLinkDeviceId: null,
deviceLinkDeviceName: null,
agentDeviceId: null,
agentDeviceName: null,
collab,
// worktree 勾选记忆:系统默认 + 显式 override 合成。注意历史残留的
// wtEnabled/wtName/wtSourceBranch/wtBaseRepo 根字段(2026-07 前的短暂持久化实验)
// 仍被忽略丢弃——本字段是新契约,不做旧值迁移(不猜测用户意图)。
worktreeEnabled,
worktreePreferenceCustomized,
fastModeByModel,
effortByModel,
extraDirs,
writableDirs,
lastByVendor: {
cc: sanitizeVendorPrefs(lastByVendorRaw.cc, 'cc'),
pi: sanitizeVendorPrefs(lastByVendorRaw.pi, 'pi'),
orca: sanitizeVendorPrefs(lastByVendorRaw.orca, 'orca'),
codex: sanitizeVendorPrefs(lastByVendorRaw.codex, 'codex'),
},
modelChosenByVendor,
defaultTupleCustomized,
newChatDefaultPermissionMode,
defaultTupleSelectionCustomized,
};
}
function loadFromStorage(): NewMakerDraft {
if (typeof window === 'undefined') return makeDefault();
try {
const raw = window.localStorage.getItem(storageKey());
if (!raw) return makeDefault();
return sanitize(JSON.parse(raw));
} catch {
return makeDefault();
}
}
// 同步写: prefs 写入频率极低 (用户点击 dropdown 才触发), 不需要 batch。
// 之前的 100ms debounce 在 release 的"热更新→relaunch"路径上会丢失最近一次
// 改动 (lifecycle 走 app.exit() 强退, 来不及 fire 这个 setTimeout), 直接同步
// 落盘最稳。
type StoredDraftRecord = Record<string, unknown>;
function parseStoredDraftRecord(raw: string | null): StoredDraftRecord | undefined {
if (raw == null) return undefined;
try {
const parsed = JSON.parse(raw) as unknown;
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined;
return parsed as StoredDraftRecord;
} catch {
return undefined;
}
}
interface StoredWorktreePreference {
worktreeEnabled: boolean;
worktreePreferenceCustomized: boolean;
}
type StoredDefaultTuplePreference = Pick<
NewMakerDraft,
| 'vendor'
| 'fastModeByModel'
| 'effortByModel'
| 'lastByVendor'
| 'modelChosenByVendor'
| 'newChatDefaultPermissionMode'
| 'defaultTupleCustomized'
| 'defaultTupleSelectionCustomized'
>;
function defaultTuplePreferenceOf(draft: NewMakerDraft): StoredDefaultTuplePreference {
return {
vendor: draft.vendor,
fastModeByModel: draft.fastModeByModel,
effortByModel: draft.effortByModel,
lastByVendor: draft.lastByVendor,
modelChosenByVendor: draft.modelChosenByVendor,
newChatDefaultPermissionMode: draft.newChatDefaultPermissionMode ?? null,
defaultTupleCustomized: draft.defaultTupleCustomized,
defaultTupleSelectionCustomized: draft.defaultTupleSelectionCustomized,
};
}
function parseStoredWorktreePreference(
raw: string | null,
): StoredWorktreePreference | undefined {
const parsed = parseStoredDraftRecord(raw);
if (
!parsed
|| (
!('worktreeEnabled' in parsed)
&& !('worktreePreferenceCustomized' in parsed)
)
) {
return undefined;
}
const sanitized = sanitize(parsed);
return {
worktreeEnabled: sanitized.worktreeEnabled,
worktreePreferenceCustomized: sanitized.worktreePreferenceCustomized,
};
}
function parseStoredDefaultTuplePreference(
raw: string | null,
): StoredDefaultTuplePreference | undefined {
const parsed = parseStoredDraftRecord(raw);
if (!parsed) return undefined;
return defaultTuplePreferenceOf(sanitize(parsed));
}
function readStoredDraftRecord(): StoredDraftRecord | undefined {
if (typeof window === 'undefined') return undefined;
try {
return parseStoredDraftRecord(window.localStorage.getItem(storageKey()));
} catch {
return undefined;
}
}
function readStoredWorktreePreference(): StoredWorktreePreference | undefined {
if (typeof window === 'undefined') return undefined;
try {
return parseStoredWorktreePreference(window.localStorage.getItem(storageKey()));
} catch {
return undefined;
}
}
function readStoredDefaultTuplePreference(): StoredDefaultTuplePreference | undefined {
if (typeof window === 'undefined') return undefined;
try {
return parseStoredDefaultTuplePreference(window.localStorage.getItem(storageKey()));
} catch {
return undefined;
}
}
function hasSameDefaultTuplePreference(
left: StoredDefaultTuplePreference,
right: StoredDefaultTuplePreference,
): boolean {
return JSON.stringify(left) === JSON.stringify(right);
}
type PreferenceSyncFallback = 'full-draft' | 'worktree-only' | null;
let preferenceSyncFallback: PreferenceSyncFallback = null;
/**
* 显式 tuple 操作先采用跨窗口持久真相,再只施加自己的字段变更。
* 这样既不会带着旧整表复活已恢复的 override,也不会吞掉本窗口刚发生的真实选模意图。
*/
function rebaseStoredDefaultTuplePreference(): void {
const stored = readStoredDefaultTuplePreference();
if (
stored !== undefined &&
!hasSameDefaultTuplePreference(stored, defaultTuplePreferenceOf(currentDraft))
) {
currentDraft = { ...currentDraft, ...stored };
// 等价于 storage event 已到达:即使后续显式操作因同值短路,订阅者也必须看到这次收敛。
emit();
}
}
/**
* Persist a complete draft snapshot without letting another renderer's stale in-memory copy
* overwrite workstation-wide worktree or user-customized default-tuple preferences.
*
* Electron windows do not share this module instance. A storage event normally refreshes the
* other windows below, but that event is asynchronous; rebasing shared preferences at write
* time also closes the race where a secondary/sidebar window mutates another draft field before
* it has received the event.
*/
function scheduleWrite(
options: {
preserveStoredWorktreePreference?: boolean;
preserveStoredDefaultTuplePreference?: boolean;
} = {},
): void {
if (typeof window === 'undefined') return;
const storedWorktreePreference = options.preserveStoredWorktreePreference !== false
? readStoredWorktreePreference()
: undefined;
if (
storedWorktreePreference !== undefined &&
(
storedWorktreePreference.worktreeEnabled !== currentDraft.worktreeEnabled
|| storedWorktreePreference.worktreePreferenceCustomized
!== currentDraft.worktreePreferenceCustomized
)
) {
currentDraft = { ...currentDraft, ...storedWorktreePreference };
}
const storedDefaultTuplePreference =
options.preserveStoredDefaultTuplePreference !== false
? readStoredDefaultTuplePreference()
: undefined;
// 无关字段写入必须无条件采用最新完整 tuple,方向不能只保护 false → true:恢复推荐刚把
// true 清成 false 后,旧窗口的 workdir/collab 写入同样不能把旧 tuple/true 整体复活。
// 显式 tuple 操作已在变更前调用 rebaseStoredDefaultTuplePreference,再通过 option 跳过此处。
if (
storedDefaultTuplePreference !== undefined &&
!hasSameDefaultTuplePreference(
storedDefaultTuplePreference,
defaultTuplePreferenceOf(currentDraft),
)
) {
currentDraft = { ...currentDraft, ...storedDefaultTuplePreference };
}
try {
window.localStorage.setItem(storageKey(), JSON.stringify(currentDraft));
preferenceSyncFallback = null;
} catch {
// localStorage 满 / 私密窗口禁写——忽略,不影响内存状态。
preferenceSyncFallback = 'full-draft';
}
}
let currentDraft: NewMakerDraft = loadFromStorage();
const listeners = new Set<() => void>();
function emit() {
for (const l of listeners) l();
}
const removeStorageListener = (() => {
if (typeof window === 'undefined' || typeof window.addEventListener !== 'function') return null;
const onStorage = (event: StorageEvent) => {
if (event.key !== storageKey()) return;
if (event.storageArea && event.storageArea !== window.localStorage) return;
// A queued storage event can arrive after this window has already written a newer value.
// Re-read the shared storage truth first so the event payload itself cannot roll state back.
const liveWorktreePreference = readStoredWorktreePreference();
const nextWorktreePreference =
liveWorktreePreference ??
(
event.newValue == null
? {
worktreeEnabled: DEFAULT_WORKTREE_ENABLED,
worktreePreferenceCustomized: false,
}
: parseStoredWorktreePreference(event.newValue)
);
const liveDefaultTuplePreference = readStoredDefaultTuplePreference();
const nextDefaultTuplePreference =
liveDefaultTuplePreference ??
(
event.newValue == null
? defaultTuplePreferenceOf(makeDefault())
: parseStoredDefaultTuplePreference(event.newValue)
);
const worktreeChanged =
nextWorktreePreference !== undefined
&& (
nextWorktreePreference.worktreeEnabled !== currentDraft.worktreeEnabled
|| nextWorktreePreference.worktreePreferenceCustomized
!== currentDraft.worktreePreferenceCustomized
);
const defaultTupleChanged =
nextDefaultTuplePreference !== undefined
&& !hasSameDefaultTuplePreference(
nextDefaultTuplePreference,
defaultTuplePreferenceOf(currentDraft),
);
if (!worktreeChanged && !defaultTupleChanged) return;
// 只有工作端级偏好跨窗口同步;deviceLinkDeviceId / extraDirs 等单窗口临时目标保持不动。
currentDraft = {
...currentDraft,
...(worktreeChanged ? nextWorktreePreference : {}),
...(defaultTupleChanged ? nextDefaultTuplePreference : {}),
};
emit();
};
window.addEventListener('storage', onStorage);
return () => window.removeEventListener('storage', onStorage);
})();
if (import.meta.hot) {
import.meta.hot.dispose(() => {
removeStorageListener?.();
});
}
export function getDraft(): NewMakerDraft {
return currentDraft;
}
/**
* App 向 main 镜像偏好时读取的共享快照。
*
* 每个 Electron 窗口都有独立 currentDraft;跨窗口事件触发 emit 后,直接读本窗口内存会把
* 旧 model / workingDir 等字段覆盖进 main 缓存。localStorage 是这些持久偏好的跨窗口真相,
* 因此同步时优先读并 sanitize 它;完整草稿落盘失败才回退整份内存,单字段 worktree 写失败
* 只覆盖该布尔,避免失败路径重新带回其它旧字段。
*/
export function getDraftForPreferenceSync(): NewMakerDraft {
const stored = readStoredDraftRecord();
if (!stored || preferenceSyncFallback === 'full-draft') return currentDraft;
const persistedDraft = sanitize(stored);
return preferenceSyncFallback === 'worktree-only'
? {
...persistedDraft,
worktreeEnabled: currentDraft.worktreeEnabled,
worktreePreferenceCustomized: currentDraft.worktreePreferenceCustomized,
}
: persistedDraft;
}
/** Do not stamp a previous owner's draft during the auth namespace handoff. */
export function getDraftForOwnerPreferenceSync(ownerId: string | null): NewMakerDraft | null {
return activeDataOwnerId === ownerId ? getDraftForPreferenceSync() : null;
}
/** Switch the persistent draft namespace together with the active data owner. */
export function setNewMakerDraftOwner(ownerId: string | null): void {
const normalized = typeof ownerId === 'string' && ownerId.trim().length > 0 ? ownerId : null;
if (activeDataOwnerId === normalized) return;
activeDataOwnerId = normalized;
currentDraft = loadFromStorage();
preferenceSyncFallback = null;
emit();
}
/**
* 按字段更新工作端级 worktree 偏好。
*
* main 会把远程写穿广播给所有 renderer。这里必须从共享 localStorage 的最新对象合并目标
* 字段,而不能让每个窗口用各自完整 currentDraft 回写;否则最后响应的旧窗口会回滚其它偏好。
* 当前窗口内存也只更新该字段,保留 device-link / extraDirs 等窗口内临时草稿。
*/
export function setWorktreePreference(enabled: boolean): void {
const worktreeEnabled = enabled === true;
const worktreePreferenceCustomized = true;
if (typeof window !== 'undefined') {
const stored = readStoredDraftRecord();
const base = stored ?? currentDraft;
if (
stored?.worktreeEnabled !== worktreeEnabled
|| stored?.worktreePreferenceCustomized !== worktreePreferenceCustomized
) {
try {
window.localStorage.setItem(
storageKey(),
JSON.stringify({
...base,
worktreeEnabled,
worktreePreferenceCustomized,
}),
);
preferenceSyncFallback = null;
} catch {
// 单字段落盘失败时仅让 main 从本窗口内存取 worktree 布尔;其它偏好继续使用共享
// 持久快照,避免旧窗口借失败兜底重新带回整份旧草稿。
preferenceSyncFallback = 'worktree-only';
}
} else {
preferenceSyncFallback = null;
}
}
currentDraft = {
...currentDraft,
worktreeEnabled,
worktreePreferenceCustomized,
};
emit();
}
/** Only explicit settings changes update the default; preserve independent picker choices. */
export function setNewChatDefaultPermissionMode(mode: PermissionMode | null): void {
if (mode !== null && mode !== 'auto' && mode !== 'bypassPermissions') return;
rebaseStoredDefaultTuplePreference();
const lastByVendor = { ...currentDraft.lastByVendor };
for (const vendor of ['cc', 'pi', 'codex', 'orca'] as const) {
if (!lastByVendor[vendor].permissionModeCustomized) {
lastByVendor[vendor] = { ...lastByVendor[vendor], permissionMode: mode ?? 'auto', permissionModeCustomized: false };
}
}
currentDraft = { ...currentDraft, newChatDefaultPermissionMode: mode, lastByVendor };
scheduleWrite({ preserveStoredDefaultTuplePreference: false });
emit();
}
export function patchDraft(patch: Partial<NewMakerDraft>): void {
const normalizedPatch: Partial<NewMakerDraft> = { ...patch };
// worktree 偏好只能经 setWorktreePreference 写入。把这条约束放在 store 边界,
// 避免项目切换、草稿恢复或未来的通用 patch 调用方绕过「仅 checkbox 修改」契约。
delete normalizedPatch.newChatDefaultPermissionMode;
delete normalizedPatch.worktreeEnabled;
delete normalizedPatch.worktreePreferenceCustomized;
if ('workingDir' in normalizedPatch) {
normalizedPatch.workingDir = normalizeDraftWorkingDir(normalizedPatch.workingDir);
}
if ('remoteHostId' in normalizedPatch) {
const remoteHostId = normalizedPatch.remoteHostId;
normalizedPatch.remoteHostId =
typeof remoteHostId === 'string' && remoteHostId.trim().length > 0
? remoteHostId.trim()
: null;
}
const next: NewMakerDraft = { ...currentDraft, ...normalizedPatch };
if ('workingDir' in patch && next.workingDir == null) {
next.remoteHostId = null;
} else if ('workingDir' in patch && !('remoteHostId' in patch)) {
next.remoteHostId = null;
}
// 改 workingDir 但**没有显式带** deviceLink 字段 → 清除远程目标,避免把本地项目误当成
// 远程设备项目。
//
// #807:原来这里还有一条「workingDir 变 null 就无条件清设备」的分支(即使同一个 patch
// 显式提供了 deviceLinkDeviceId 也清)。那是「远程草稿必带项目目录」时代的不变量;设备
// 提成一级维度后它直接把新流程打死 —— 选设备时传的正是
// `{ deviceLinkDeviceId, workingDir: null }`,设备刚设上就被清成 null,选设备完全不生效。
// 现在只保留「未显式带设备字段」这一条:显式指定设备的 patch 一律尊重,
// 而 resetDraftWorkspaceAfterSend 之类不带设备字段的清空路径行为不变。
if ('workingDir' in patch && !('deviceLinkDeviceId' in patch)) {
next.deviceLinkDeviceId = null;
next.deviceLinkDeviceName = null;
}
// 「Agent 在另一台电脑运行」:本机任务,或远程控制下建到被控电脑的任务(被控电脑是否支持由草稿页
// 判定)。任务建到 SSH 主机时不成立;换了任务所在电脑(本机 ↔ 被控电脑、被控电脑之间)时上一台的
// 选择不再适用,除非同一个 patch 显式给了新值。运行 Agent 的电脑不能就是任务所在电脑。
if (next.remoteHostId != null) {
next.agentDeviceId = null;
next.agentDeviceName = null;
} else if ('agentDeviceId' in normalizedPatch) {
const agentDeviceId = normalizedPatch.agentDeviceId;
next.agentDeviceId =
typeof agentDeviceId === 'string' && agentDeviceId.trim().length > 0 ? agentDeviceId.trim() : null;
if (next.agentDeviceId == null) next.agentDeviceName = null;
} else if (currentDraft.deviceLinkDeviceId !== next.deviceLinkDeviceId) {
next.agentDeviceId = null;
next.agentDeviceName = null;
}
if (next.agentDeviceId != null && next.agentDeviceId === next.deviceLinkDeviceId) {
next.agentDeviceId = null;
next.agentDeviceName = null;
}
// 换目标设备(含本机 ↔ 被控设备、被控设备 A ↔ B)→ 丢掉 Worker 富配置,只留
// enabled + worker。model / providerId / effort / fast 都是**设备作用域**的:被控端
// 装的模型目录、连的供应商都是它自己那一套,原样透传过去会撞被控端 main 的精确
// preflight(INVALID_PARAMS / PROVIDER_ROUTE_UNAVAILABLE),协同静默降级成单会话 ——
// 正是 issue #1170 抱怨的「入口能点但走不完」。清掉后由被控端按自己的默认值起
// Worker,与草稿里模型 pill 换设备重新校准的既有行为一致。
//
// 放在 store 层而不是 applyDraftTarget:换设备有四条路径(设备 pill、设备域浏览器、
// 工作区 picker、所选设备失效后的自动回落),挂在这里全部自动覆盖,新增第五条也不用
// 再对齐一格(与 NewMakerDraftRoute.applyDraftTarget 的「按什么变了而不是走了哪条
// 路径」同一思路)。
if (currentDraft.deviceLinkDeviceId !== next.deviceLinkDeviceId && next.collab.workerConfig) {
next.collab = { ...next.collab, workerConfig: undefined };
}
// 协同与项目/对话形态正交,切 workingDir 不再改 enabled。device-link 与 SSH 的 Worker
// 创建和团队读写都在对应执行端完成;Worker 子会话不能嵌套协同,由会话侧入口判定兜住。
currentDraft = next;
scheduleWrite({ preserveStoredWorktreePreference: true });
emit();
}
/**
* 把草稿的「这次要跑在哪」复位成干净的本机对话态。
*
* workingDir=null 经 patchDraft 级联清掉 remoteHostId / deviceLink*;extraDirs 与
* collab.enabled 是本次草稿的一次性选择,这里显式清掉。vendor / lastByVendor /
* fastModeByModel 等模型偏好保持不变(那是「我常用哪个」的记忆,与「这次跑在哪」正交)。
*
* **任何「另起一段干净对话」的入口都必须走这里,不要各自手写字段清单。**
* extraDirs 是单次草稿的**目录读取授权**,漏掉它会让新会话悄悄继承对无关本地目录的
* 访问权(#1103 review 实例:两个预填入口都手写了清单,把级联已经处理的三个字段
* 抄了一遍,却都漏了真正需要清的这一个)。新增工作区字段时只改这一处。
*/
export function resetDraftWorkspaceTargets(): void {
patchDraft({
workingDir: null,
extraDirs: [],
writableDirs: [],
collab: { ...currentDraft.collab, enabled: false },
});
}
/** 单字段写入 collab(便捷 setter,语义比 patchDraft({ collab: ... }) 更直接)。 */
export function patchCollab(patch: Partial<CollabDraft>): void {
patchDraft({ collab: { ...currentDraft.collab, ...patch } });
}
/**
* 切 vendor 的便捷入口:
* 1. 保留当前 vendor 已同步进草稿的 (model/effort/permissionMode)
* 2. 切到新 vendor
* NewMakerDraftRoute 的 VendorSegmentedSwitcher 切换时调本函数;切回某 vendor 时 ChatInput 通过 lastByVendor[vendor] 取上次值。
*/
export function switchVendor(next: MakerVendor): void {
rebaseStoredDefaultTuplePreference();
if (currentDraft.vendor === next) return;
currentDraft = {
...currentDraft,
vendor: next,
};
scheduleWrite({ preserveStoredDefaultTuplePreference: false });
emit();
}
/** Explicit Bot-requested default uses the same persisted tuple, with owner/CAS and no partial writes. */
export function applyAppDefaultModelSelection(selection: AppDefaultModelSelection): boolean {
if (!isDataOwnerPushStampCurrent(selection.ownerStamp)
|| activeDataOwnerId !== selection.ownerStamp.dataOwnerId
|| Date.now() > selection.expiresAt) return false;
const stored = readStoredDraftRecord();
const base = stored ? sanitize(stored) : currentDraft;
const prefs = base.lastByVendor[base.vendor];
const current: BotModelRoute | null = prefs.model ? {
harness: base.vendor === 'cc' || base.vendor === 'orca' ? 'claude' : base.vendor,
model: prefs.model, providerId: prefs.providerId ?? null, effort: prefs.effort ?? '',
fastMode: (base.fastModeByModel[prefs.model] ?? false),
} : null;
if (!sameModelRoute(current, selection.expectedRoute) && !sameModelRoute(current, selection.route)) return false;
const route = selection.route;
const vendor = route.harness === 'claude' ? 'cc' : route.harness;
const next: NewMakerDraft = { ...base, vendor,
defaultTupleCustomized: true, defaultTupleSelectionCustomized: true,
modelChosenByVendor: { ...base.modelChosenByVendor, [vendor]: true },
lastByVendor: { ...base.lastByVendor, [vendor]: { ...base.lastByVendor[vendor],
model: route.model, providerId: route.providerId, effort: route.effort as Effort } },
effortByModel: { ...base.effortByModel, [route.model]: route.effort as Effort },
fastModeByModel: { ...base.fastModeByModel, [route.model]: route.fastMode },
};
try {
window.localStorage.setItem(storageKey(), JSON.stringify(next));
} catch { return false; }
currentDraft = { ...currentDraft, ...defaultTuplePreferenceOf(next),
effortByModel: next.effortByModel, fastModeByModel: next.fastModeByModel };
preferenceSyncFallback = null;
emit();
return true;
}
/**
* 当前草稿 Harness 不可用时按系统顺序回退。
*
* 必须在调用瞬间读取模块级 currentDraft:产品默认 effect 可能刚把 cc 改成 Pi,若这里继续
* 使用 React 上一轮 closure 的 cc/currentPrefs,会把 xAI→Pi 又覆盖成 Codex。系统回退不标记
* defaultTupleCustomized,因为它不是用户选择。
*/
export function fallbackUnavailableVendor(availableVendors: ReadonlySet<MakerVendor>): boolean {
rebaseStoredDefaultTuplePreference();
const currentVendor = currentDraft.vendor;
if (availableVendors.has(currentVendor)) return false;
const fallback = (['cc', 'codex', 'pi'] as const).find((vendor) =>
availableVendors.has(vendor),
);
if (!fallback) return false;
switchVendor(fallback);
return true;
}
export interface SuggestedDefaultTuple {
vendor: Extract<MakerVendor, 'cc' | 'codex' | 'pi'>;
providerId: string;
model: string;
effort?: Effort | null;
}
/** 原子应用产品默认;只改未自定义草稿,不把默认伪装成用户显式选模。 */
export function applySuggestedDefaultTuple(tuple: SuggestedDefaultTuple): boolean {
rebaseStoredDefaultTuplePreference();
if (currentDraft.defaultTupleCustomized) return false;
const previous = currentDraft.lastByVendor[tuple.vendor];
const nextPrefs: VendorPrefs = {
...previous,
model: tuple.model,
providerId: tuple.providerId,
...(tuple.effort ? { effort: tuple.effort } : {}),
};
if (
currentDraft.vendor === tuple.vendor &&
previous.model === nextPrefs.model &&
previous.providerId === nextPrefs.providerId &&
previous.effort === nextPrefs.effort
) {
return false;
}
currentDraft = {
...currentDraft,
vendor: tuple.vendor,
lastByVendor: { ...currentDraft.lastByVendor, [tuple.vendor]: nextPrefs },
};
scheduleWrite({ preserveStoredDefaultTuplePreference: false });
emit();
return true;
}
/** 用户开始调整默认组合后立刻封住后续自动下放。 */
export function markDefaultTupleCustomized(selectionCustomized = true): void {
rebaseStoredDefaultTuplePreference();
if (
currentDraft.defaultTupleCustomized &&
(!selectionCustomized || currentDraft.defaultTupleSelectionCustomized)
) {
return;
}
currentDraft = {
...currentDraft,
defaultTupleCustomized: true,
defaultTupleSelectionCustomized:
currentDraft.defaultTupleSelectionCustomized || selectionCustomized,
};
scheduleWrite({ preserveStoredDefaultTuplePreference: false });
emit();
}
/**
* 「恢复推荐」删除当前模型的旧草稿调档,并在所有 override 都已清空时撤销组合封锁。
*
* providerModelMemory / modelEnginePrefs 是独立 store,由调用方先删当前项、再把同步重读后的
* 汇总结果传进来。草稿内仍需在同一次写入里删除 legacy effort / Fast 键;否则 marker 虽清,
* 重启后残留记忆仍会把旧档顶回来。任一模型选择、其它模型调档或外部 override 仍存在时,
* defaultTupleCustomized 必须继续保护用户意图。
*/
export function clearDefaultTupleTuningCustomization(args: {
modelId: string;
hasExternalOverrides: boolean;
}): void {
rebaseStoredDefaultTuplePreference();
const nextEffortByModel = { ...currentDraft.effortByModel };
const nextFastModeByModel = { ...currentDraft.fastModeByModel };
const hadEffortOverride = args.modelId in nextEffortByModel;
const hadFastOverride = args.modelId in nextFastModeByModel;
delete nextEffortByModel[args.modelId];
delete nextFastModeByModel[args.modelId];
const hasSelectionOverride =
currentDraft.defaultTupleSelectionCustomized ||
Object.values(currentDraft.modelChosenByVendor).some(Boolean);
const hasRemainingDraftTuning =
Object.keys(nextEffortByModel).length > 0 || Object.keys(nextFastModeByModel).length > 0;
const shouldUnlock =
currentDraft.defaultTupleCustomized &&
!hasSelectionOverride &&
!hasRemainingDraftTuning &&
!args.hasExternalOverrides;
if (!hadEffortOverride && !hadFastOverride && !shouldUnlock) return;
currentDraft = {
...currentDraft,
effortByModel: nextEffortByModel,
fastModeByModel: nextFastModeByModel,
...(shouldUnlock ? { defaultTupleCustomized: false } : {}),
};
scheduleWrite({ preserveStoredDefaultTuplePreference: false });
emit();
}
/**
* 显式指定 vendor 的 pref 写入入口。读模块级 currentDraft (而非调用方 closure
* 捕获的 draft), 避免连续调用之间相互覆盖 —— ChatInput 切 model 时会同步连发
* onModelDidChange + onEffortDidChange, closure 模式下第二次调用拿到的是第一次
* 未生效前的 lastByVendor, 会把 model 改动覆盖掉。
*/
function patchVendorPrefsInternal(
vendor: MakerVendor,
patch: Partial<VendorPrefs>,
opts: { markModelChoice: boolean },
): void {
rebaseStoredDefaultTuplePreference();
const marksSelection = opts.markModelChoice && ('model' in patch || 'providerId' in patch);
const marksDefaultTuple = marksSelection || (opts.markModelChoice && 'effort' in patch);
const modelChosen = { ...currentDraft.modelChosenByVendor };
const nextPatch = { ...patch };
delete nextPatch.permissionModeCustomized;
if (opts.markModelChoice && typeof nextPatch.permissionMode === 'string') {
nextPatch.permissionModeCustomized = true;
}
if (typeof nextPatch.model === 'string' && nextPatch.model.length > 0) {
if (opts.markModelChoice) {
// 新建页 picker 或已有任务换模 → 打标记,下次新建跟随这次选择,不再回落区域默认。
modelChosen[vendor] = true;
}
// markModelChoice=false 仍可写回当前活动模型(远程草稿 / 旧控制端 wire
// 会带 modelId),但不得打标,也不得清掉已有标记。
}
if (!opts.markModelChoice && modelChosen[vendor] === true) {
const savedModel = currentDraft.lastByVendor[vendor].model;
const incomingModel =
typeof nextPatch.model === 'string' && nextPatch.model.length > 0
? nextPatch.model
: savedModel;
// 已显式选过时,不得替换那次选择的模型或来源。没带 model 视为仍在已保存
// 模型上改档;带了不同 model 则丢掉这次 effort,避免 A/B 错配。
delete nextPatch.model;
delete nextPatch.providerId;
if (incomingModel !== savedModel) {
delete nextPatch.effort;
}
}
currentDraft = {
...currentDraft,
defaultTupleCustomized: currentDraft.defaultTupleCustomized || marksDefaultTuple,
defaultTupleSelectionCustomized:
currentDraft.defaultTupleSelectionCustomized || marksSelection,
modelChosenByVendor: modelChosen,
lastByVendor: {
...currentDraft.lastByVendor,
[vendor]: { ...currentDraft.lastByVendor[vendor], ...nextPatch },
},
};
scheduleWrite({ preserveStoredDefaultTuplePreference: false });
emit();
}
export function patchVendorPrefs(vendor: MakerVendor, patch: Partial<VendorPrefs>): void {
patchVendorPrefsInternal(vendor, patch, { markModelChoice: true });
}
/**
* 已创建任务把思考档、以及 wire 上的当前活动模型同步回新建草稿时使用。
* 未打标时可以更新 lastByVendor.model / providerId / effort,方便远程草稿 /
* 旧控制端把活动值写回,但不把这次当成显式选模。已打标后不得替换那次选择的
* 模型、来源或思考档;只有活动模型与已保存模型一致时才更新 effort。
* 本机已有任务里换模型应走 patchVendorPrefs。
*/
export function patchVendorPrefsPreservingModelChoice(
vendor: MakerVendor,
patch: Partial<VendorPrefs>,
): void {
patchVendorPrefsInternal(vendor, patch, { markModelChoice: false });
}
/**
* 已有任务里只换模型(来源沿用任务自己的)时写回新建默认。
*
* 任务的来源不是这次选择的一部分:新建默认落在另一个来源上时整次不写,否则以后的新建
* 任务会被悄悄搬到这个任务的来源(例:在 Cindy AI 任务里换个模型,新建默认就从 Anthropic
* 变成 Cindy AI)。只有确认来源一致才照常写回并打标;来源无法确定时不写。换来源、跨引擎等
* 显式选择仍走 patchVendorPrefs。
*
* `taskProviderId` 是任务实际生效的来源(null = 任务来源未知,照常写回),只用于比较;`resolveDraftProviderId` 给跟随默认
* 路由(providerId=null)的新建默认解析生效来源。返回是否写入。
*/
export function patchVendorPrefsFromTaskModelSwitch(
vendor: MakerVendor,
patch: Pick<VendorPrefs, 'model' | 'providerId'> & { effort?: Effort },
taskProviderId: string | null,
resolveDraftProviderId?: (prefs: VendorPrefs) => string | null,
): boolean {
// 先吸收另一窗口刚保存的默认,再比较来源,避免用过期的内存值放行后覆盖它。
rebaseStoredDefaultTuplePreference();
const saved = currentDraft.lastByVendor[vendor];
if (taskProviderId) {
// 存着的来源可能已被服务端搬走(例如企业号池 Auto 搬到 XD),先按实际路由解析,
// 解析不出再用存的值。
const draftProviderId = resolveDraftProviderId?.(saved) ?? saved.providerId ?? null;
// 只有确认新建默认就在任务的来源上才写回;来源不明(目录未就绪、账号切换中、没有来源提供该
// 模型)按保守处理,宁可这次不写,也不把默认搬到任务的来源。
if (draftProviderId !== taskProviderId) return false;
}
// 走到这里说明新建默认的实际来源已确认等于任务来源(或任务来源未知的旧行为)。草稿本来跟随默认
// 路由(providerId=null)就保持跟随,不因为任务显式用了某来源就把它固化成 override;草稿显式存着
// 来源时写入已确认的任务来源(不信任 patch 里可能过期的值)——存着的旧来源可能已被搬走,不能复活。
patchVendorPrefs(vendor, {
...patch,
providerId: saved.providerId ? (taskProviderId ?? patch.providerId ?? saved.providerId) : null,
});
return true;
}
/** 单字段写入当前 vendor 的某个 pref(用户在 ChatInput 改 model 等时同步落地)。 */
export function patchCurrentVendorPrefs(patch: Partial<VendorPrefs>): void {
patchVendorPrefs(currentDraft.vendor, patch);
}
export function getEffortForModel(modelId: string | null | undefined): Effort | undefined {
if (!modelId) return undefined;
return currentDraft.effortByModel[modelId];
}
export function setEffortForModel(modelId: string, effort: Effort): void {
if (!modelId) return;
rebaseStoredDefaultTuplePreference();
// 同值短路,避免无意义的 emit / write。
if (currentDraft.effortByModel[modelId] === effort) return;
currentDraft = {
...currentDraft,
effortByModel: {
...currentDraft.effortByModel,
[modelId]: effort,
},
};
scheduleWrite({ preserveStoredDefaultTuplePreference: false });
emit();
}
export function getFastModeForModel(modelId: string | null | undefined): boolean | 'ultrafast' {
if (!modelId) return false;
return (currentDraft.fastModeByModel[modelId] ?? false);
}
export function setFastModeForModel(modelId: string, enabled: boolean | 'ultrafast'): void {
if (!modelId) return;
rebaseStoredDefaultTuplePreference();
currentDraft = {
...currentDraft,
fastModeByModel: {
...currentDraft.fastModeByModel,
[modelId]: enabled,
},
};
scheduleWrite({ preserveStoredDefaultTuplePreference: false });
emit();
}
export function clearDraft(): void {
currentDraft = makeDefault();
scheduleWrite({
preserveStoredWorktreePreference: false,
preserveStoredDefaultTuplePreference: false,
});
emit();
}
function subscribe(listener: () => void): () => void {
listeners.add(listener);
return () => listeners.delete(listener);
}
export function subscribeDraft(listener: () => void): () => void {
return subscribe(listener);
}
/** React hook —— useSyncExternalStore 保证多组件订阅一致 + StrictMode 双 render 安全。 */
export function useNewMakerDraft(): NewMakerDraft {
return useSyncExternalStore(subscribe, getDraft, getDraft);
}
/** 当前 vendor 的有效 prefs(读出来的快照)。 */
export function getCurrentVendorPrefs(): VendorPrefs {
return currentDraft.lastByVendor[currentDraft.vendor];
}
/**
* 读用户在 New Maker 界面**显式选择过**的 vendor model。
*
* 与 getDraft().lastByVendor[v].model 的区别:后者永远非空 —— sanitize 会用
* getDefaultModelForVendor 兜底填充,且 lastByVendor 整个快照随任意 draft 写入
* 落盘,即使用户从没碰过该 vendor 的模型,持久化里也躺着种子默认值。
* 所以这里要求 modelChosenByVendor[vendor] === true(新建页 picker 或已有
* 任务换模经 patchVendorPrefs 打的标)才返回,否则一律 ''。
* 调度任务的默认模型三级回退(useScheduleForm getScheduleDefaultModel)依赖这个
* 区分:没显式选过的用户应落到按供应商清单校准后的新建任务默认,而不是未经校准的
* 种子默认。读 raw localStorage 而非 getDraft(),解析失败 → ''。
*/
export function getPersistedVendorModel(vendor: MakerVendor): string {
if (typeof window === 'undefined') return '';
try {
const raw = window.localStorage.getItem(storageKey());
if (!raw) return '';
const parsed = JSON.parse(raw) as Partial<NewMakerDraft> | null;
if (parsed?.modelChosenByVendor?.[vendor] !== true) return '';
const model = parsed?.lastByVendor?.[vendor]?.model;
return typeof model === 'string' ? model : '';
} catch {
return '';
}
}
/** 测试用 —— 重置 store + 清 localStorage(其它代码不应调用)。 */
export function __resetForTest(): void {
currentDraft = makeDefault();
activeDataOwnerId = null;
if (typeof window !== 'undefined') {
try {
window.localStorage.removeItem(STORAGE_KEY);
} catch {
// ignore
}
}
emit();
}
export const __STORAGE_KEY = STORAGE_KEY;