dsh-subagent-profile 0.3.3 → 0.3.4

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 };

package/lib/core/evolution-advice.mjs

@@ -0,0 +1,224 @@
+// lib/core/evolution-advice.mjs — evolution:advice 派发优化建议链（从 evolution-summary.mjs
+// 拆出以守文件行门）：suggestAdvice（纯函数四条件 + 升/降轴硬规则）、readSummaries /
+// refreshSummaries / computeAdvice / buildAdviceText（生产聚合触发与注入文本）。
+// 聚合本体（computeSummaries/writeSummaries）仍驻 evolution-summary.mjs；本模块只读
+// 台账并调度聚合，绝无写回台账路径。fail-soft 纪律与 evolution-summary 同源。
+//
+// 依赖方向：本模块 → evolution-summary.mjs（单向，无环）。
+
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { computeSummaries, parseDispatchRecords, writeSummaries, confidenceLevel } from './evolution-summary.mjs';
+
+// --- 派发优化建议（suggestAdvice）-----------------------------------------------
+// 从单条 L1 聚合（l1Entry）产出「一项确定性建议」或 null。四条件齐备才产出：
+//   N>=minN、weighted_success 低于阈值（表现不佳才建议）、置信度达标、cooldown
+//   未过期。方向按升/降轴硬规则：能力轴（preset/model/provider/persona/
+//   toolFilter）只建议降；预算轴（effort）可建议升；无法定位安全轴的键保守维持
+//   （平）。阈值 successThreshold / confidenceMinLevel / cooldownMs 为建议初值，
+//   待实测后校准。
+const CONFIDENCE_RANK = { low: 0, medium: 1, high: 2 };
+
+function hasCapabilityAxis(profileKey) {
+  return /(^|\|)(preset|provider|model|persona|toolFilter):/.test(String(profileKey ?? ''));
+}
+
+function hasBudgetAxis(profileKey) {
+  return /(^|\|)effort:/.test(String(profileKey ?? ''));
+}
+
+// 从 profileKey 提取 preset 候选值（无 preset 段返回 null，如 inline / 纯预算键）。
+export function presetFromKey(profileKey) {
+  if (typeof profileKey !== 'string' || profileKey === '' || profileKey === '(inline)') return null;
+  for (const part of profileKey.split('|')) {
+    if (part.startsWith('preset:')) return part.slice('preset:'.length);
+  }
+  return null;
+}
+
+// 建议候选校验：preset 候选非 system-trust 白名单即 fail-loud 抛错（与派发守卫
+// whitelist 闸一致，不静默滤掉）。whitelist 接受 Set 或数组。
+export function assertSystemCandidate(whitelist, preset) {
+  if (preset === null || preset === undefined || preset === '' || preset === 'inherit') return;
+  const inList = whitelist instanceof Set ? whitelist.has(preset) : Array.isArray(whitelist) && whitelist.includes(preset);
+  if (!inList) {
+    throw new Error(`evolution:advice: 候选预设 "${preset}" 不在 system-trust 白名单（拒绝非 system 候选）`);
+  }
+}
+
+function performanceText(entry) {
+  const outcome = entry?.outcome ?? {};
+  const perf = entry?.perf ?? {};
+  const parts = [
+    `过去 ${entry?.deployments_total ?? 0} 次：完成 ${outcome.completed ?? 0}、失败 ${outcome.failed ?? 0}、终止 ${outcome.killed ?? 0}`,
+    `加权成功分 ${entry?.score?.weighted_success ?? 0}`,
+  ];
+  if (perf.avg_elapsed_ms !== null && perf.avg_elapsed_ms !== undefined) parts.push(`平均耗时 ${perf.avg_elapsed_ms}ms`);
+  if (perf.avg_output_len !== null && perf.avg_output_len !== undefined) parts.push(`平均输出 ${perf.avg_output_len} 字符`);
+  return parts.join('，');
+}
+
+function directionFor(profileKey, capability, budget) {
+  if (budget && !capability) return '升';
+  if (capability) return '降';
+  return '平';
+}
+
+export function suggestAdvice({
+  l1Entry,
+  profileKey = '',
+  minN = 3,
+  cooldownMs = 600000,
+  now = Date.now(),
+  successThreshold = 0.6,
+  confidenceMinLevel = 'medium',
+} = {}) {
+  const entry = l1Entry !== null && typeof l1Entry === 'object' ? l1Entry : {};
+  const key = typeof profileKey === 'string' ? profileKey : (typeof entry.profileKey === 'string' ? entry.profileKey : '');
+  const n = Number.isFinite(entry.confidence?.n) ? entry.confidence.n : 0;
+  const level = typeof entry.confidence?.level === 'string' ? entry.confidence.level : confidenceLevel(n, minN);
+  const score = Number.isFinite(entry.score?.weighted_success) ? entry.score.weighted_success : 0;
+  const until = entry.cooldown?.until_ts;
+
+  // 四条件齐备才产出（任一不满足返回 null）。
+  if (n < minN) return null;
+  if ((CONFIDENCE_RANK[level] ?? -1) < (CONFIDENCE_RANK[confidenceMinLevel] ?? 0)) return null;
+  if (until !== null && until !== undefined && now < until) return null;
+  if (!(score < successThreshold)) return null;
+
+  // 方向判定：优先读组内轴存在性（L1 键去 effort 后由聚合写入）；legacy summaries
+  // 无 axes 字段时回退键文本正则判定（保持旧 summaries.json 可读）。
+  const axes = entry.axes !== null && typeof entry.axes === 'object' ? entry.axes : null;
+  const capability = axes !== null && typeof axes.capability === 'boolean' ? axes.capability : hasCapabilityAxis(key);
+  const budget = axes !== null && typeof axes.budget === 'boolean' ? axes.budget : hasBudgetAxis(key);
+
+  return {
+    profileKey: key,
+    performanceText: performanceText(entry),
+    suggestion: directionFor(key, capability, budget),
+    confidence: level,
+    cooldownUntil: now + cooldownMs,
+  };
+}
+
+// --- 派发优化建议（evolution:advice 注入段，默认关）----------------------------
+
+// 读 summaries.json（存在才读；损坏/形状不符 → null，fail-soft）。
+// 版本化：只接受 v:1；未知/超前版本 fail-soft 跳过（v1 无前驱，迁移表空）。
+export function readSummaries(file, logger) {
+  try {
+    if (!existsSync(file)) return null;
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    if (parsed === null || typeof parsed !== 'object' || parsed.l1 === null || typeof parsed.l1 !== 'object') return null;
+    if (parsed.v !== 1) {
+      if (logger !== undefined && typeof logger.warn === 'function') {
+        logger.warn(`[dsh-subagent-profile] summaries.json 版本 ${String(parsed.v)} 未知，跳过该资产（fail-soft）`);
+      }
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+// 生产聚合触发点（T1 修复）：读 dispatch.jsonl → parseDispatchRecords → computeSummaries
+// → writeSummaries。opts 可注入 parentAdoptedConfirmedFalse join（adoption-tracker 的
+// 「已确认未采纳」计数，惰性 join 进 weighted_success）。缺失台账返回 skipped:'no-ledger'。
+export function refreshSummaries({ dispatchFile, summariesFile, logger, opts = {} } = {}) {
+  if (!existsSync(dispatchFile)) return { persisted: false, skipped: 'no-ledger' };
+  let lines;
+  try {
+    lines = readFileSync(dispatchFile, 'utf8').split('\n');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (logger !== undefined && typeof logger.warn === 'function') {
+      logger.warn(`[dsh-subagent-profile] evolution:advice 读派发台账失败：${message}`);
+    }
+    return { persisted: false, error: message };
+  }
+  const { records, skipped } = parseDispatchRecords(lines);
+  const summaries = computeSummaries(records, opts);
+  const res = writeSummaries(summariesFile, summaries);
+  return { ...res, records: records.length, skippedLines: skipped };
+}
+
+// summaries.json 是否过期（缺失但台账存在，或台账 mtime 更新）——惰性重算判据。
+function summariesStale(dispatchFile, summariesFile) {
+  if (!existsSync(summariesFile)) return existsSync(dispatchFile);
+  try {
+    return statSync(dispatchFile).mtimeMs > statSync(summariesFile).mtimeMs;
+  } catch {
+    return false;
+  }
+}
+
+// 注入段文本：全局聚合摘要 + 各 profile 一条确定性建议（人类读、非指令）。
+export function renderAdviceText(advice, global) {
+  const direction = (value) => (value === '升' ? '可上调预算' : value === '降' ? '建议降级' : '维持现状');
+  const lines = advice.map((a) => {
+    const untilText = Number.isFinite(a.cooldownUntil)
+      ? `（冷却至 ${new Date(a.cooldownUntil).toLocaleTimeString('zh-CN', { hour12: false })}）`
+      : '';
+    return `- ${a.profileKey}：${a.performanceText}；${direction(a.suggestion)}（置信度 ${a.confidence}）${untilText}`;
+  });
+  const total = global.completed + global.failed + global.killed;
+  return `以下为过去派发的只读统计与确定性建议（仅供人类参考，不改变派发行为）：\n` +
+    `全局：累计 ${total} 次（完成 ${global.completed}、失败 ${global.failed}、终止 ${global.killed}）。\n${lines.join('\n')}`;
+}
+
+// 建议产出后把各 profile 的新 cooldown.until_ts 写回 summaries.json（原子写、
+// fail-soft）。写前重读磁盘再合并：并发注入各自基于最新磁盘态写回，把互相覆盖
+// 窗口压到最小（残余竞态：读-写间隙，彻底解决需进程内锁，成本不值）。
+function writeBackCooldowns(file, data, produced, logger) {
+  const fresh = readSummaries(file, logger);
+  const base = fresh !== null && typeof fresh === 'object' ? fresh : data;
+  const l1 = { ...(base.l1 ?? {}) };
+  for (const [profileKey, until] of produced) {
+    const group = l1[profileKey];
+    l1[profileKey] = { ...group, cooldown: { ...(group?.cooldown ?? {}), until_ts: until } };
+  }
+  const res = writeSummaries(file, { l1, l2: base.l2 ?? {} });
+  if (res.persisted !== true) {
+    logger.warn(`[dsh-subagent-profile] evolution:advice cooldown 写回失败：${res.error ?? '未知错误'}`);
+  }
+}
+
+// 结构化建议（读+算，不写回 cooldown、不渲染文本）：供注入段与只读面板共用。
+export function computeAdvice({ summariesFile, dispatchFile, whitelist, logger }) {
+  if (dispatchFile !== undefined && summariesStale(dispatchFile, summariesFile)) refreshSummaries({ dispatchFile, summariesFile, logger });
+  let data = readSummaries(summariesFile, logger);
+  // summaries.json 存在但不可读（损坏/版本不符）→ fail-soft 重建（幂等可复算），
+  // 损坏资产不阻断建议产出；台账缺失时维持空建议（refreshSummaries 的 no-ledger 语义）。
+  if (data === null && dispatchFile !== undefined && existsSync(summariesFile)) {
+    refreshSummaries({ dispatchFile, summariesFile, logger });
+    data = readSummaries(summariesFile, logger);
+  }
+  if (data === null) return { advice: [], global: { completed: 0, failed: 0, killed: 0, total: 0 }, produced: [], summaries: null };
+  const l1 = data.l1 ?? {};
+  const keys = Object.keys(l1).sort();
+  const advice = [];
+  const produced = [];
+  const global = { completed: 0, failed: 0, killed: 0 };
+  for (const profileKey of keys) {
+    const group = l1[profileKey];
+    if (group === null || typeof group !== 'object') continue;
+    global.completed += group.outcome?.completed ?? 0;
+    global.failed += group.outcome?.failed ?? 0;
+    global.killed += group.outcome?.killed ?? 0;
+    const suggestion = suggestAdvice({ l1Entry: group, profileKey });
+    if (suggestion === null) continue;
+    // 只对实际产出的建议键校验候选（N 不足不产出建议的组不要求 system-trust）。
+    assertSystemCandidate(whitelist, presetFromKey(profileKey));
+    advice.push(suggestion);
+    produced.push([profileKey, suggestion.cooldownUntil]);
+  }
+  return { advice, global: { ...global, total: global.completed + global.failed + global.killed }, produced, summaries: data };
+}
+
+// 派发优化建议段文本生成：computeAdvice → 写回 cooldown（防每请求重复注入）→ 渲染；空建议返回空串。
+export function buildAdviceText({ summariesFile, dispatchFile, whitelist, logger }) {
+  const { advice, global, produced, summaries } = computeAdvice({ summariesFile, dispatchFile, whitelist, logger });
+  if (advice.length === 0) return '';
+  writeBackCooldowns(summariesFile, summaries, produced, logger);
+  return renderAdviceText(advice, global);
+}