dsh-subagent-profile 0.3.3 → 0.4.0

package/lib/core/dispatch-tool.mjs

@@ -5,33 +5,31 @@
 // 注入：所有 apply 闭包 / ctx 依赖都是显式参数——
 //   register    ctx.tools.register（工具由 syncTool 注册/注销，设置开关可运行时移除），
 //   store       profile store（resolveProfile 取基方案、getAllowFailOpen 供 cost guard），
-//   getEnabled  读取 apply 闭包 `enabled` 标志（continuable fail-loud 门 +
-//               syncTool 注册条件），
+//   getEnabled  读取 apply 闭包 `enabled` 标志（continuable fail-loud 门 + syncTool 注册条件），
 //   getService  请求时服务 getter（ctx.get('toolResultPruner') / ctx.get('jobs')
 //               按次读取，绝不在 apply 时读），
 //   logger      ctx.logger（决策级派发日志 + continuable 告警），
 //   subagents   ctx.subagents（start / startContinuable 驱动子 Agent），
-//   guard       dispatch guard（execute 入口 acquire / 结算 release+记账 /
-//               syncTool 禁用时 cancelAll+reset）。
-// 工厂返回 { syncTool, dispose }：syncTool 交给 HTTP 路由（/set-enabled），
-// dispose 在插件卸载时运行。
+//   guard       dispatch guard（execute 入口 acquire / 结算 release+记账 / syncTool 禁用时 cancelAll+reset）。
+// 工厂返回 { syncTool, dispose }：syncTool 交给 HTTP 路由（/set-enabled），dispose 在插件卸载时运行。
 //
-// execute 按预检段 + 三分支拆为模块级私有函数；parameters / output schema 拆至
-// dispatch-schema.mjs，预检闸应用拆至 dispatch-gates.mjs（守文件行门），零漂移。
+// execute 按预检段 + 三分支拆为模块级私有函数；parameters/output schema 拆至 dispatch-schema.mjs，预检闸拆至 dispatch-gates.mjs（守文件行门），零漂移。
 
 import { defineTool } from './shims.mjs';
-import { textFrom, stopReasonError, withPartialText, pruneBlocks, assertResultSchemaConsistency, trustLabel, trustAudit, dispatchLabel, tierSortKey } from './pure.mjs';
+import { textFrom, stopReasonError, withPartialText, pruneBlocks, assertResultSchemaConsistency, trustLabel, trustAudit, dispatchLabel } from './pure.mjs';
 import { resolveWhitelist } from './whitelist.mjs';
 import { recordEscapeAllow } from './escape.mjs';
 import { settleStart, collectChildUsage, collectChildCalls } from './delegation.mjs';
 import { DISPATCH_OUTPUT_SCHEMA, DISPATCH_PARAMETERS, DISPATCH_RENDER } from './dispatch-schema.mjs';
 import { createDecisionTrace, finalizeTrace, assertTraceSize, parentContextOf, requestedOf, effectiveMeta, recordApprovalGate, recordFailure, profileSnapshotOf } from './decision-trace.mjs';
+import { profileDirectoryRows } from './profile-directory.mjs';
 import { applyWhitelistGate, applyCostGuardGate, applyIntersectionGate, assertContinuableEnabled, readParentToolNames, applyBudgetGate } from './dispatch-gates.mjs';
 import { trackForegroundInflight, trackBackgroundInflight, trackContinuableInflight } from './dispatch-guard.mjs';
 import { finishForegroundLedger, finishBackgroundLedger, finishContinuableLedger } from './evolution-ledger.mjs';
+import { profileKeyOf } from './evolution-summary.mjs';
+import { promptExcerptOf } from './adoption-reminder.mjs';
 
-// 信封骨架：envelope:true 时追加进子 persona 的结构化汇报契约（三分支共享）；骨架
-// 只进 persona（systemPrompt 影子段、模型可见），不进 descriptor（model-hidden，仅 session 记录）。
+// 信封骨架：envelope:true 时追加进子 persona 的结构化汇报契约（三分支共享）；只进 persona（模型可见），不进 descriptor（仅 session 记录）。
 const ENVELOPE_SKELETON = '完成前按以下骨架输出：## 结论（1-2 句）\n## 结构分项（逐项）\n## 关键发现落点（文件路径/数据位置）';
 
 // --- execute 预检段（从 execute 拆出；行为逐字不变）-----------------------------
@@ -126,7 +124,7 @@ async function runContinuable(args, merged, meta, parent, exec, deps, trace, eff
   if (args.run_in_background === true) {
     deps.logger.warn('[dsh-subagent-profile] dispatch: both continuable and run_in_background are true; continuable takes precedence');
   }
-  // 已知降级：continuable 标准路径不支持 preset swap 和 reasoningEffort（subagent 包的 SubagentStartRequest 无 preset 字段、AgentOptions 无 reasoningEffort 字段）
+  // 已知降级：continuable 标准路径不支持 preset swap 和 reasoningEffort（宿主请求面无对应字段）。
   if (merged.preset !== undefined && merged.preset !== 'inherit') {
     deps.logger.warn(`[dsh-subagent-profile] continuable mode cannot swap preset; ignoring "${merged.preset}" (child inherits the parent preset)`);
   }
@@ -141,10 +139,10 @@ async function runContinuable(args, merged, meta, parent, exec, deps, trace, eff
     signal: exec.signal
   });
   trackContinuableInflight(deps.guard, deps.subagents, childId, parent.session?.header?.id);
-  // Continuable 丢弃方案的 preset swap 与 reasoningEffort（子继承父预设），
-  // 故可观测 meta 必须报告实际生效值，而非被忽略的请求值。
-  // 可见性修复：`reasoningEffort` 回显**请求值**（经 meta.reasoningEffort），
-  // `preset:'inherit'` 是真实生效值；`ignored` 明确列出被丢弃项。
+  deps.adoptionTracker?.register({ parentSessionId: parent.session?.header?.id, id: childId, ledgerKey: profileKeyOf(base.effective), mode: 'continuable', dispatchedAt: Date.now(), promptExcerpt: promptExcerptOf(args?.prompt), requestedModel: merged.model, parentModel: parent.options?.model });
+  // Continuable 丢弃方案的 preset swap 与 reasoningEffort（子继承父预设），故可观测
+  // meta 必须报告实际生效值：reasoningEffort 回显请求值，preset:'inherit' 是生效值，
+  // ignored 明确列出被丢弃项。
   // 信任标注不适用：continuable 只回 subagentId、无文本 output（后续经宿主的
   // send_message 流转），没有可加前缀的回收文本，故此处不加 trustLabel。
   const out = {
@@ -171,7 +169,7 @@ async function runContinuable(args, merged, meta, parent, exec, deps, trace, eff
 
 // 后台 one-shot（job）路径：jobs.start 包 start() 并提供原生
 // AbortController；仍是一轮即弃，非 continuable。
-async function runBackground(args, merged, meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base) {
+async function runBackground(args, merged, meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base, exec) {
   const jobs = deps.getService('jobs');
   if (jobs === undefined) {
     throw new Error('dispatch: 后台派发不可用：缺少 jobs 服务（请安装 @deepseek-ai/dsh-jobs 与 @deepseek-ai/dsh-tool-jobs，或改用前台派发）');
@@ -181,6 +179,9 @@ async function runBackground(args, merged, meta, request, parent, deps, pruneRes
   const onSettled = (settled) => {
     guardHandle.finish(jobId, settled.childTotalTokens);
     finishBackgroundLedger(deps.evoLedger, base, jobId, settled);
+    if (deps.backgroundLedger !== undefined) deps.backgroundLedger.record(base.session_id, jobId, settled, exec?.callId);
+    deps.adoptionTracker?.updateOutput(base.session_id, jobId, typeof settled.output === 'string' ? settled.output : '');
+    deps.adoptionTracker?.updateSettled?.(base.session_id, jobId, settled);
   };
   jobId = jobs.start({
     kind: 'subagent',
@@ -188,10 +189,12 @@ async function runBackground(args, merged, meta, request, parent, deps, pruneRes
     owner: parent,
     run: () => {
       const controller = new AbortController();
+      const startPromise = deps.subagents.start('profile', { ...request, signal: controller.signal });
+      startPromise.then((run) => { if (run !== null && run !== undefined && typeof run.id === 'string') deps.backgroundLedger?.recordChild?.(base.session_id, jobId, run.id); }).catch(() => {}); // 结算前补记 jobId → childSessionId，供页头识别后台派发。
       return {
         cancel: (reason) => controller.abort(reason ?? 'dispatch: background subagent task killed'),
         done: settleStart(
-          deps.subagents.start('profile', { ...request, signal: controller.signal }),
+          startPromise,
           controller.signal,
           meta,
           pruneResultOutput,
@@ -204,15 +207,15 @@ async function runBackground(args, merged, meta, request, parent, deps, pruneRes
     }
   });
   trackBackgroundInflight(deps.guard, jobs, jobId, parent);
-  // 后台：execute 返回时 start 尚未 resolve，无 settled（结算经 job 结果携带，不入会话块）。
+  deps.adoptionTracker?.register({ parentSessionId: parent.session?.header?.id, id: jobId, ledgerKey: profileKeyOf(base.effective), mode: 'background', dispatchedAt: t0, promptExcerpt: promptExcerptOf(args?.prompt), requestedModel: merged.model, parentModel: parent.options?.model }); // 后台结算经 job 结果携带，不入会话块。
   const out = { kind: 'background', jobId, ...meta };
   finalizeTrace(trace, { effective: effectiveMeta(meta, []), execution: { kind: 'background', parentSessionId: parent.session?.header?.id, jobId, mode: 'one-shot' } });
   out.decisionTrace = assertTraceSize(trace);
   return out;
 }
 
-// childTotalTokens：宿主 tokenMeter 启发式估算（surface 口径，非计费 usage）。
-// 仅 completed 结算时测量；服务缺失/非函数/抛错均返回 undefined（fail-soft）。
+// childTotalTokens：宿主 tokenMeter 启发式估算（surface 口径，非计费 usage）；仅
+// completed 结算时测量，服务缺失/非函数/抛错均返回 undefined（fail-soft）。
 function measureChildTokens(getService, session) {
   if (session === undefined || session === null) return undefined;
   const meter = getService('tokenMeter');
@@ -239,13 +242,13 @@ function measureForegroundRun(deps, run) {
 }
 
 // 前台：收集结果，无论 reject 与否都释放句柄，非 completed 停因 fail-loud；
-// run.result reject（undefined）也写失败 outcome（M9）。
-async function runForeground(meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base) {
+// run.result reject（undefined）也写失败 outcome。
+async function runForeground(meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base, adoptionBase) {
   const run = await deps.subagents.start('profile', request);
   finalizeTrace(trace, { execution: { kind: 'foreground', parentSessionId: parent.session?.header?.id, childSessionId: run.id, mode: 'one-shot' } });
   trackForegroundInflight(deps.guard, run);
-  let result;
-  let measurement;
+  deps.adoptionTracker?.register({ parentSessionId: parent.session?.header?.id, id: run.id, ledgerKey: profileKeyOf(base.effective), mode: 'foreground', dispatchedAt: t0, ...adoptionBase }); // 前台派发登记 parent_adopted 待判定。
+  let result, measurement;
   try {
     result = await run.result;
     if (result.stopReason === 'completed') measurement = measureForegroundRun(deps, run);
@@ -254,13 +257,13 @@ async function runForeground(meta, request, parent, deps, pruneResultOutput, t0,
     await run.dispose().catch(() => {});
     guardHandle.finish(run.id, measurement?.childTotalTokens); // untrack + recordTokens + release
   }
-  const childTotalTokens = measurement?.childTotalTokens;
-  const childUsage = measurement?.childUsage;
-  const childCalls = measurement?.childCalls;
+  const { childTotalTokens, childUsage, childCalls } = measurement ?? {};
   // 台账：completed 与非 completed 都写 outcome（对照 settleStart 语义），随后非 completed 仍 throw。
   const pruned = pruneResultOutput(result.output);
   const elapsedMs = Date.now() - t0;
-  finishForegroundLedger(deps.evoLedger, base, run.id, result, pruned, elapsedMs, childCalls);
+  finishForegroundLedger(deps.evoLedger, base, run.id, result, pruned, elapsedMs, childCalls, childTotalTokens, childUsage);
+  deps.adoptionTracker?.updateOutput(parent.session?.header?.id, run.id, textFrom(pruned));
+  deps.adoptionTracker?.updateSettled?.(parent.session?.header?.id, run.id, { stopReason: result.stopReason, elapsedMs, ...(childTotalTokens !== undefined ? { childTotalTokens } : {}), ...(childUsage !== undefined ? { childUsage } : {}), childSessionId: run.id }); // 结算摘要回填供未采纳提醒结果行，已拒/未完成同样登记。
   const failure = stopReasonError(result);
   if (failure !== undefined) throw new Error(withPartialText(failure, result.output));
   const metaOut = {
@@ -281,8 +284,7 @@ async function runForeground(meta, request, parent, deps, pruneResultOutput, t0,
     },
   });
   // 信任标注：completed 子结果回灌父上下文前加结构化前缀（profile/preset 元数据、
-  // 无 prompt 原文），审计同字段 JSON 只进 logger、不进结果字符串。render 行首部
-  // 格式不变——前缀只进 output 文本（模型看到的正文带头）。
+  // 无 prompt 原文），审计同字段 JSON 只进 logger、不进结果字符串；前缀只进 output 文本。
   const output = `${trustLabel(metaOut)}${textFrom(pruned)}`;
   deps.logger.info('[dsh-subagent-profile] trusted-output: ' + trustAudit(metaOut));
   return { output, ...metaOut, decisionTrace: assertTraceSize(trace) };
@@ -292,13 +294,17 @@ async function runForeground(meta, request, parent, deps, pruneResultOutput, t0,
 // 与轨迹（避免重复 list() / schemas()），并组装 trace 骨架与交集闸 input。
 async function prepareTrace(args, parent, deps) {
   const agentPresets = parent.ctx.get('agentPresets');
-  const whitelist = new Set(await resolveWhitelist(agentPresets, deps.getEscapeSet()));
+  const baseWhitelist = new Set(await resolveWhitelist(agentPresets));
+  const escapeSet = new Set(deps.getEscapeSet());
+  const whitelist = new Set([...baseWhitelist, ...escapeSet]);
   const parentComposed = agentPresets !== undefined ? agentPresets.composedPreset(parent.ctx) : undefined;
   const parentToolNames = readParentToolNames(parent);
   const parentToolCount = parentToolNames.length;
-  // 决策输入快照：与 dispatch:profiles section 同源同序（enabled、cheap-first）——
-  // 「模型当时看到哪些候选」是回答「为什么这么选」的记录面（P5 补偿）。
-  const snapshot = profileSnapshotOf([...deps.store.profiles.values()].filter((p) => p.enabled !== false).sort((a, b) => tierSortKey(a.tokenTier) - tierSortKey(b.tokenTier)));
+  // 决策输入快照：与 dispatch:profiles section 同源同序（profileDirectoryRows，
+  // enabled、cheap-first）——「模型当时看到哪些候选」是回答「为什么这么选」的记录面。
+  const rows = profileDirectoryRows(deps.store);
+  const snapshot = profileSnapshotOf(rows, { chosenId: args.profile });
+  const advicePresent = typeof deps.getEvolutionAdvice === 'function' && deps.getEvolutionAdvice() === true && parentComposed === 'orchestrator';
   const trace = createDecisionTrace(
     parentContextOf({
       parentPreset: parentComposed,
@@ -307,11 +313,11 @@ async function prepareTrace(args, parent, deps) {
       parentToolCount,
       allowFailOpen: deps.store.getAllowFailOpen(),
     }),
-    requestedOf(args, { profiles: snapshot.entries })
+    requestedOf(args, { profiles: snapshot.entries, advicePresent })
   );
   const mode = args.continuable === true ? 'continuable' : (args.run_in_background === true ? 'background' : 'foreground');
   const intersectionInput = { parentToolCount, requestedToolFilter: args.toolFilter, mode };
-  return { whitelist, parentComposed, parentToolNames, trace, mode, intersectionInput };
+  return { whitelist, baseWhitelist, escapeSet, parentComposed, parentToolNames, trace, mode, intersectionInput };
 }
 
 // execute 主体：预检段 + 三分支分派。任一闸 fail 先记 fail 闸再 rethrow 原错误
@@ -321,7 +327,7 @@ async function runDispatch(args, exec, deps) {
   if (!parent) throw new Error('dispatch: 缺少调用 Agent（值需来自模型/编排者会话，请勿直接调用本工具）');
   // 派发耗时基准：execute 入口记 t0，前台/后台各自在结算处算 elapsedMs。
   const t0 = Date.now();
-  const { whitelist, parentComposed, parentToolNames, trace, mode, intersectionInput } = await prepareTrace(args, parent, deps);
+  const { whitelist, baseWhitelist, escapeSet, parentComposed, parentToolNames, trace, mode, intersectionInput } = await prepareTrace(args, parent, deps);
   // 预算闸句柄提至 try 外：任何分支 throw（前台 start reject / 后台 jobs 缺失等）
   // 都在 catch 里幂等 release 并发槽——防错误路径把父会话的并发额度永久耗尽
   // （正常路径 finish 已 release，catch 再调为 no-op）。
@@ -335,7 +341,7 @@ async function runDispatch(args, exec, deps) {
       merged.persona = hasPersona ? `${merged.persona}\n\n${ENVELOPE_SKELETON}` : ENVELOPE_SKELETON;
     }
     assertContinuableEnabled(deps, args);
-    applyWhitelistGate(trace, merged, whitelist, parentComposed);
+    applyWhitelistGate(trace, merged, whitelist, parentComposed, escapeSet, baseWhitelist);
     // Cost guard（运行时推导；硬上限始终生效，llm 能力核验由 allowFailOpen 门控）。
     await applyCostGuardGate(trace, merged, parent, deps);
     // 交集闸（三分支统一闸序，见 dispatch-gates.mjs）；continuable 的 effectiveAllow
@@ -344,6 +350,7 @@ async function runDispatch(args, exec, deps) {
     recordApprovalGate(trace);
     const meta = buildMeta(args, merged, parent);
     const request = buildRequest(args, merged, parent, exec.signal);
+    const adoptionBase = { promptExcerpt: promptExcerptOf(args?.prompt), requestedModel: merged.model, parentModel: parent.options?.model };
     // 结果回收默认剪枝：在 textFrom 前复用宿主 toolResultPruner.pruneContent 预剪；
     // pruner 缺失时 pruneBlocks 回退为不剪（剪枝是增强、非硬依赖）。
     const pruneResultOutput = (blocks) => pruneBlocks(blocks, deps.getService('toolResultPruner'));
@@ -355,8 +362,8 @@ async function runDispatch(args, exec, deps) {
     const base = deps.evoLedger.baseEntry({ parent, args, merged, mode });
     recordEscapeAllow(deps, parent, merged, trace);
     if (args.continuable === true) return await runContinuable(args, merged, meta, parent, exec, deps, trace, effectiveAllow, base);
-    if (args.run_in_background === true) return await runBackground(args, merged, meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base);
-    return await runForeground(meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base);
+    if (args.run_in_background === true) return await runBackground(args, merged, meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base, exec);
+    return await runForeground(meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base, adoptionBase);
   } catch (error) {
     guardHandle.release();
     recordFailure(deps.ledger, parent, trace);
@@ -364,16 +371,16 @@ async function runDispatch(args, exec, deps) {
   }
 }
 
-export function createDispatchTool({ register, store, getEnabled, getService, logger, subagents, catalog, ledger, guard, evoLedger, getEscapeSet }) {
-  const deps = { store, getEnabled, getService, logger, subagents, catalog, ledger, guard, evoLedger, getEscapeSet };
+export function createDispatchTool({ register, store, getEnabled, getService, logger, subagents, catalog, ledger, guard, evoLedger, backgroundLedger, adoptionTracker, getEscapeSet, getEvolutionAdvice }) {
+  const deps = { store, getEnabled, getService, logger, subagents, catalog, ledger, guard, evoLedger, backgroundLedger, adoptionTracker, getEscapeSet, getEvolutionAdvice };
   const dispatchTool = defineTool({
     name: 'dispatch',
-    description: '派发子任务给派生子 Agent，可逐个覆盖其 preset、model、provider、推理档位、persona、工具白名单、token 预算或递归深度。前台等待结果；run_in_background: true 启动后台任务（单轮即弃）；continuable: true 启动持久子 Agent，后续轮次经 send_message 工具延续对话。前瞻：continuable 模式忽略 preset 换用与 reasoningEffort（结果以 ignored 提示）。',
+    description: '派发子任务给派生子 Agent，可逐个覆盖其 preset、model、provider、推理档位、persona、工具白名单、token 预算或递归深度。优先使用已保存的 profile，仅少数字段需要临时覆盖时才传 per-call 参数；未指定 model 时子代理继承父模型，查资料/汇总/读文件等轻任务请优先考虑 cheap 方案或显式 model=flash。前台等待结果；run_in_background: true 启动后台任务（单轮即弃）；continuable: true 启动持久子 Agent，后续轮次经 send_message 工具延续对话。前瞻：continuable 模式忽略 preset 换用与 reasoningEffort（结果以 ignored 提示）。',
     parameters: DISPATCH_PARAMETERS,
     output: {
       schema: DISPATCH_OUTPUT_SCHEMA,
       render: DISPATCH_RENDER,
-      // 决策轨迹经 presentationMeta 投影进会话块 meta（客户端账本数据源），不进 render 行。
+      // 决策轨迹经 presentationMeta 投影进会话块 meta（客户端台账数据源），不进 render 行。
       presentationMeta: (_args, value) => value.decisionTrace,
     },
     isConcurrencySafe: () => true,

package/lib/core/draft-gates.mjs

@@ -0,0 +1,45 @@
+// lib/core/draft-gates.mjs — auto-profile S1 draft 落库前的闸评估。
+// 与派发守卫闸同源（形状/白名单/目录），但不落库、不 throw——只产出结构化 checks
+// 供 /draft/preview 与应用复用。依赖注入：ctx / catalog 由调用方传入；store 只读
+// profiles Map 判断 id 冲突。
+
+import { sanitizeProfile } from './pure.mjs';
+import { resolveWhitelist } from './whitelist.mjs';
+
+// 评估一个 draft：sanitize（形状/硬上限）→ id 冲突 → 白名单 → 目录。checks 每项
+// 为 { name, verdict: 'pass'|'fail', reason? }；ok = 全部 pass。任一闸 fail 时 clean
+// 仍返回（sanitize 归一后的形态），调用方可用其展示「将被写入的生效值」。
+export async function assessDraftProfile({ ctx, store, catalog, getEscapeSet, draft }) {
+  if (draft === null || typeof draft !== 'object') {
+    return { ok: false, checks: [{ name: 'draft', verdict: 'fail', reason: 'draft 不存在' }], clean: null };
+  }
+  const config = draft.config !== null && typeof draft.config === 'object' ? draft.config : {};
+  const profile = { ...config, name: draft.name, description: draft.description };
+  const { clean, warnings } = sanitizeProfile(profile, { strict: true });
+  const checks = [];
+  checks.push(warnings.length > 0
+    ? { name: 'sanitize', verdict: 'fail', reason: warnings.map((w) => w.field + '：' + w.reason).join('；') }
+    : { name: 'sanitize', verdict: 'pass' });
+  if (typeof clean.id !== 'string' || clean.id === '') {
+    checks.push({ name: 'id', verdict: 'fail', reason: 'draft 缺少 profile id' });
+  } else if (store.profiles.has(clean.id)) {
+    checks.push({ name: 'id', verdict: 'fail', reason: 'profile ' + clean.id + ' 已存在（请先删除或改名）' });
+  } else {
+    checks.push({ name: 'id', verdict: 'pass' });
+  }
+  const whitelist = new Set(await resolveWhitelist(ctx.get('agentPresets'), getEscapeSet()));
+  if (typeof clean.preset === 'string' && clean.preset !== '' && clean.preset !== 'inherit' && !whitelist.has(clean.preset)) {
+    checks.push({ name: 'whitelist', verdict: 'fail', reason: '目标预设 ' + clean.preset + ' 不在 system-trust 白名单（可开启逃生舱并添加该预设后重试）' });
+  } else {
+    checks.push({ name: 'whitelist', verdict: 'pass' });
+  }
+  const snapshot = await catalog.getSnapshot();
+  if (typeof clean.model === 'string' && clean.model !== '' && !snapshot.models.some((m) => m && m.id === clean.model)) {
+    checks.push({ name: 'catalog', verdict: 'fail', reason: '模型 ' + clean.model + ' 不在当前模型目录' });
+  } else if (typeof clean.provider === 'string' && clean.provider !== '' && !snapshot.models.some((m) => m && m.provider === clean.provider)) {
+    checks.push({ name: 'catalog', verdict: 'fail', reason: '提供方 ' + clean.provider + ' 不在当前模型目录' });
+  } else {
+    checks.push({ name: 'catalog', verdict: 'pass' });
+  }
+  return { ok: checks.every((c) => c.verdict === 'pass'), checks, clean };
+}

package/lib/core/drafts-store.mjs

@@ -0,0 +1,45 @@
+// lib/core/drafts-store.mjs — auto-profile draft 容器。
+// 与生产注册表 subagent-profiles.json 隔离：draft 只写 subagent-evolution/drafts.json，
+// 未经人确认并过闸不得进入 profiles Map。原子写（tmp+rename），损坏 fail-soft 从空。
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+function loadDrafts(file) {
+  if (!existsSync(file)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    if (parsed !== null && typeof parsed === 'object' && Array.isArray(parsed.drafts)) {
+      return parsed.drafts.filter((d) => d !== null && typeof d === 'object' && typeof d.id === 'string');
+    }
+  } catch { /* fail-soft 从空 */ }
+  return [];
+}
+
+function createDraftsStore({ dshHome, onGovernanceFailure = () => {} } = {}) {
+  const dir = join(dshHome, 'subagent-evolution');
+  const file = join(dir, 'drafts.json');
+  const drafts = loadDrafts(file);
+  const persist = () => {
+    const tmp = file + '.tmp';
+    try {
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(tmp, JSON.stringify({ v: 1, drafts }, null, 2), 'utf8');
+      renameSync(tmp, file);
+      return { persisted: true };
+    } catch (error) {
+      try { rmSync(tmp, { force: true }); } catch { /* best effort */ }
+      onGovernanceFailure();
+      return { persisted: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  };
+  return {
+    list: () => drafts.map((d) => ({ ...d })),
+    get: (id) => { const d = drafts.find((x) => x.id === id); return d === undefined ? undefined : { ...d }; },
+    add: (draft) => { drafts.push(draft); return persist(); },
+    remove: (id) => { const i = drafts.findIndex((x) => x.id === id); if (i < 0) return { persisted: true, removed: false }; drafts.splice(i, 1); return { ...persist(), removed: true }; },
+    clear: () => { drafts.length = 0; },
+  };
+}
+
+export { createDraftsStore };