dsh-subagent-profile 0.3.3 → 0.3.4

package/lib/core/cost-evidence.mjs

@@ -0,0 +1,145 @@
+// lib/core/cost-evidence.mjs — 省 token 证据（反事实对照，纯函数）。
+// 判定读 trace.requested.model（不能读 effective.model：buildMeta 会把继承的父
+// 模型名写进 effective，无法区分「继承父」与「显式选 pro」）。未指定 model 时
+// saving=0 并打标「未指定模型（继承父）」，让根因①可见。
+//
+// 成本口径：B 级五段单价可用时按 usage 逐段计价（元/千 token）；否则回退 A 级
+// 单次均价（docs/cost-closed-loop-design.md L14 实测）。无价格/无 usage/无模型
+// 一律 fail-soft 返回 undefined，不显示不猜数。
+
+import { MODEL_AVG_COST, MODEL_USAGE_PRICES, priceKeyFor } from './prices.mjs';
+
+function costFromUsage(model, usage) {
+  const key = priceKeyFor(model);
+  if (key === undefined) return undefined;
+  const prices = MODEL_USAGE_PRICES[key];
+  if (prices === undefined) return undefined;
+  let total = 0;
+  let any = false;
+  for (const seg of ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens']) {
+    const unit = prices[seg];
+    const amount = usage?.[seg];
+    if (typeof unit === 'number' && Number.isFinite(unit) && typeof amount === 'number' && Number.isFinite(amount) && amount >= 0) {
+      total += (unit * amount) / 1000;
+      any = true;
+    }
+  }
+  return any ? Number(total.toFixed(6)) : undefined;
+}
+
+// 单条派发的估算成本（元）。优先五段计价，其次 A 级单次均价。
+export function dispatchCost({ model, usage } = {}) {
+  const key = priceKeyFor(model);
+  if (key === undefined) return undefined;
+  const byUsage = costFromUsage(model, usage);
+  if (byUsage !== undefined) return byUsage;
+  const avg = MODEL_AVG_COST[key];
+  return typeof avg === 'number' ? avg : undefined;
+}
+
+// 反事实对照结果。record 为 dispatch.jsonl 行；显式指定 model 才有「继承父 vs
+// 指定 model」价差，未指定（继承父）saving 恒 0 并打 inherit 标。
+export function counterfactualFor(record) {
+  if (record === null || typeof record !== 'object') return undefined;
+  const requestedModel = record.requested?.model;
+  const usage = record.outcome?.usage;
+  const parentModel = record.parent_model;
+  if (typeof requestedModel !== 'string' || requestedModel === '') {
+    const parentCost = dispatchCost({ model: parentModel, usage });
+    return {
+      inherit: true,
+      model: parentModel ?? null,
+      actual: parentCost,
+      counterfactual: parentCost,
+      saving: 0,
+      ratio: null,
+    };
+  }
+  const actual = dispatchCost({ model: requestedModel, usage });
+  const counterfactual = dispatchCost({ model: parentModel, usage });
+  if (actual === undefined || counterfactual === undefined) return undefined;
+  const saving = Number((counterfactual - actual).toFixed(6));
+  return {
+    inherit: false,
+    model: requestedModel,
+    parentModel: parentModel ?? null,
+    actual,
+    counterfactual,
+    saving,
+    ratio: actual > 0 ? Number((counterfactual / actual).toFixed(2)) : null,
+  };
+}
+
+// 聚合一组 record 的估算成本与继承占比。只统计可计价（actual 非 undefined）记录。
+export function summarizeCosts(records) {
+  let actualSum = 0;
+  let counterfactualSum = 0;
+  let savingSum = 0;
+  let priced = 0;
+  let inheritCount = 0;
+  for (const record of records) {
+    if (record === null || typeof record !== 'object') continue;
+    const c = counterfactualFor(record);
+    if (c === undefined) continue;
+    if (c.actual === undefined) continue;
+    actualSum += c.actual;
+    if (c.counterfactual !== undefined) counterfactualSum += c.counterfactual;
+    savingSum += c.saving;
+    priced += 1;
+    if (c.inherit) inheritCount += 1;
+  }
+  return {
+    estimated_cost: Number(actualSum.toFixed(4)),
+    estimated_inherit_cost: Number(counterfactualSum.toFixed(4)),
+    estimated_saving: Number(savingSum.toFixed(4)),
+    priced,
+    inherit_count: inheritCount,
+    inherit_ratio: priced > 0 ? Number((inheritCount / priced).toFixed(3)) : 0,
+  };
+}
+
+// 从 summaries.json 的 l1/l2 聚合成本汇总：全局（所有 L1 组求和）与按模型轴
+// （l2 的 :model: 键，同一模型多组归并）。同一记录只属一个 L1 组与一个 model 轴键，
+// 故全局与模型轴各自无重复。无数据返回空汇总（调用方省略显示）。
+export function costSummaryFromSummaries(summaries) {
+  const root = summaries !== null && typeof summaries === 'object' ? summaries : {};
+  const l1 = root.l1 !== null && typeof root.l1 === 'object' ? root.l1 : {};
+  const l2 = root.l2 !== null && typeof root.l2 === 'object' ? root.l2 : {};
+  const global = { estimated_cost: 0, estimated_inherit_cost: 0, estimated_saving: 0, priced: 0, inherit_count: 0 };
+  for (const group of Object.values(l1)) {
+    const c = group !== null && typeof group === 'object' ? group.cost : null;
+    if (c === null || typeof c !== 'object') continue;
+    if (typeof c.estimated_cost === 'number') global.estimated_cost += c.estimated_cost;
+    if (typeof c.estimated_inherit_cost === 'number') global.estimated_inherit_cost += c.estimated_inherit_cost;
+    if (typeof c.estimated_saving === 'number') global.estimated_saving += c.estimated_saving;
+    if (typeof c.priced === 'number') global.priced += c.priced;
+    if (typeof c.inherit_count === 'number') global.inherit_count += c.inherit_count;
+  }
+  global.estimated_cost = Number(global.estimated_cost.toFixed(4));
+  global.estimated_inherit_cost = Number(global.estimated_inherit_cost.toFixed(4));
+  global.estimated_saving = Number(global.estimated_saving.toFixed(4));
+  global.inherit_ratio = global.priced > 0 ? Number((global.inherit_count / global.priced).toFixed(3)) : 0;
+  const byModel = new Map();
+  for (const [key, group] of Object.entries(l2)) {
+    if (group === null || typeof group !== 'object') continue;
+    const match = /:model:([^|]+)$/.exec(key);
+    if (match === null) continue;
+    const model = match[1];
+    const cur = byModel.get(model) ?? { model, estimated_cost: 0, priced: 0, deployments: 0 };
+    const c = group.cost;
+    if (c !== null && typeof c === 'object') {
+      if (typeof c.estimated_cost === 'number') cur.estimated_cost += c.estimated_cost;
+      if (typeof c.priced === 'number') cur.priced += c.priced;
+    }
+    if (typeof group.deployments_total === 'number') cur.deployments += group.deployments_total;
+    byModel.set(model, cur);
+  }
+  const modelRows = [...byModel.values()].map((m) => ({
+    model: m.model,
+    deployments: m.deployments,
+    estimated_cost: Number(m.estimated_cost.toFixed(4)),
+    priced: m.priced,
+    avg_cost: m.priced > 0 ? Number((m.estimated_cost / m.priced).toFixed(4)) : null,
+  })).sort((a, b) => (a.model < b.model ? -1 : a.model > b.model ? 1 : 0));
+  return { global, byModel: modelRows };
+}

package/lib/core/cost-guard.mjs

@@ -130,7 +130,7 @@ export async function assertCostGuard(parent, profile, allowFailOpen, logger, ca
 
   // llm 存在：目录读取走共享 catalog 快照（缓存只提速目录解析，校验逻辑不变）。
   const snapshot = await catalog.getSnapshot(llm);
-  // M10：快照形状守卫——畸形快照（llm 缺失 / providers 非数组）不得被静默放行，
+  // 快照形状守卫——畸形快照（llm 缺失 / providers 非数组）不得被静默放行，
   // 归一为「目录为空」走同一 fail-loud / fail-open 门。
   const dir = (snapshot !== null && typeof snapshot === 'object' && snapshot.llm !== null && typeof snapshot.llm === 'object') ? snapshot.llm : {};
   const providers = Array.isArray(dir.providers) ? dir.providers : [];

package/lib/core/decision-trace.mjs

@@ -1,8 +1,10 @@
 import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { DISPATCH_PARAMETER_KEYS } from './dispatch-schema.mjs';
+export { profileSnapshotOf } from './profile-directory.mjs';
 
 // lib/core/decision-trace.mjs — dispatch 决策轨迹（decisionTrace）的纯组装与
 // 失败台账。纯记录层：只「记录」不参与任何派发行为；轨迹经
-// output.presentationMeta 投影进会话块 meta 供客户端账本展示，绝不进模型可见面
+// output.presentationMeta 投影进会话块 meta 供客户端台账展示，绝不进模型可见面
 // （render 行 / 结果文本）。
 //
 // 边界（后来开发者须知）：
@@ -25,11 +27,6 @@ const MAX_TEXT_CHARS = 200;
 const MAX_CHECKS = 6;
 const MAX_CALLS = 4;
 
-// 决策输入快照阈值：profiles_snapshot 条目数与 description 截断长度（体积受
-// assertTraceSize 兜底）。
-const MAX_PROFILE_SNAPSHOT_ENTRIES = 6;
-const PROFILE_DESC_CHARS = 120;
-
 // 名单类数组截断：长度超过 MAX_LIST_ITEMS 且元素全为字符串的数组（工具/预设名
 // 单）替换为 { values: 前 8 项, truncated: true }。数值类数组（如 usage）元素非
 // 字符串，不截断，避免误伤。
@@ -90,13 +87,18 @@ export function parentContextOf({ parentPreset, parentProvider, parentModel, par
 
 // 请求参数快照。requested.prompt 原文绝不进 trace（体积 + 隐私），只记
 // persona / toolFilter 的存在性布尔与 prompt 摘要（前 200 字符 + 截断标记，
-// 供账本展示「这次派发让子 Agent 干什么」，不泄漏全文）。
+// 供台账展示「这次派发让子 Agent 干什么」，不泄漏全文）。
 // opts.profiles：模型可见的 profile 目录快照（调用方按 dispatch:profiles section
 // 同源同序传入，见 profileSnapshotOf）——「模型为什么选这个方案」的决策输入记录面。
 export function requestedOf(args, opts = {}) {
   const rawPrompt = typeof args.prompt === 'string' ? args.prompt : '';
   const truncated = rawPrompt.length > 200;
   const profiles = Array.isArray(opts.profiles) ? opts.profiles : [];
+  // 未知 per-call 字段不再静默吞——与 DISPATCH_PARAMETER_KEYS（单一事实来源）
+  // 对照后记入 requested 快照，台账「请求值」区可见（fail-visible，不改派发行为）。
+  const unknownKeys = args !== null && typeof args === 'object' && !Array.isArray(args)
+    ? Object.keys(args).filter((key) => args[key] !== undefined && !DISPATCH_PARAMETER_KEYS.includes(key))
+    : [];
   return {
     profile: args.profile,
     preset: args.preset,
@@ -109,33 +111,11 @@ export function requestedOf(args, opts = {}) {
     maxTokens: args.maxTokens,
     maxDepth: args.maxDepth,
     envelope: args.envelope === true,
+    advice_present: opts.advicePresent === true,
     prompt_excerpt: rawPrompt.slice(0, 200),
     ...(truncated ? { prompt_truncated: true } : {}),
     ...(profiles.length > 0 ? { profiles_snapshot: profiles } : {}),
-  };
-}
-
-// 模型可见 profile 目录快照（纯函数）：enabled 且按调用方顺序（应传 cheap-first
-// 排序，与 dispatch:profiles section 同源同序）。description 截断、条目数截到
-// maxEntries 并打 truncated 标记。统一返回 { entries, truncated, total }。
-export function profileSnapshotOf(profiles, { maxEntries = MAX_PROFILE_SNAPSHOT_ENTRIES, maxDesc = PROFILE_DESC_CHARS } = {}) {
-  const list = Array.isArray(profiles) ? profiles : [];
-  const enabled = [];
-  for (const p of list) {
-    if (p === null || typeof p !== 'object' || typeof p.id !== 'string' || p.id === '') continue;
-    if (p.enabled === false) continue;
-    const description = typeof p.description === 'string' ? p.description : '';
-    enabled.push({
-      id: p.id,
-      ...(description !== '' ? { description: description.length > maxDesc ? `${description.slice(0, maxDesc)}…` : description } : {}),
-      ...(typeof p.preset === 'string' && p.preset !== '' ? { preset: p.preset } : {}),
-      ...(typeof p.tokenTier === 'string' && p.tokenTier !== '' ? { tokenTier: p.tokenTier } : {}),
-    });
-  }
-  return {
-    entries: enabled.slice(0, maxEntries),
-    truncated: enabled.length > maxEntries,
-    total: enabled.length,
+    ...(unknownKeys.length > 0 ? { unknown_keys: unknownKeys } : {}),
   };
 }
 

package/lib/core/delegation.mjs

@@ -55,7 +55,7 @@ export function collectChildUsage(session) {
 // 产出单步五段 usage（inputTokens/outputTokens 恒在、缺报按 0；可选字段缓存读/写/
 // 推理仅该条报告时携带）。返回前 maxCalls 条 + truncated（总数 > maxCalls）+
 // totalCalls（总数）；无任何 usage 事件返回 undefined。与 collectChildUsage 并存：
-// 前者是逐次明细（账本展开区），后者是会话总量（结算 meta），互不替代。非 object /
+// 前者是逐次明细（台账展开区），后者是会话总量（结算 meta），互不替代。非 object /
 // 非 number 一律忽略（fail-soft），使逐条收集绝不阻断派发结算。
 //
 // maxCalls 默认 6（非 12）：单条 calls 的五段 JSON 键名主导体积（约 100 字节/条），
@@ -112,7 +112,8 @@ async function settleRun(run, meta, prune, measureChild, t0, logger) {
       detail: withPartialText(failure, result.output),
       ...meta,
       elapsedMs: Date.now() - t0,
-      stopReason: result.stopReason
+      stopReason: result.stopReason,
+      childSessionId: run.id
     };
   }
   // 仅 completed 结算时测量（非 completed 走上方失败分支，不测）；在 dispose
@@ -137,7 +138,7 @@ async function settleRun(run, meta, prune, measureChild, t0, logger) {
   if (logger !== undefined && typeof logger.info === 'function') {
     logger.info('[dsh-subagent-profile] trusted-output: ' + trustAudit(metaOut));
   }
-  return { status: 'completed', output, ...metaOut };
+  return { status: 'completed', output, childSessionId: run.id, ...metaOut };
 }
 
 export async function settleStart(start, signal, meta, prune = (blocks) => blocks, measureChild = () => undefined, t0 = Date.now(), logger = undefined, onSettled = undefined) {
@@ -148,9 +149,11 @@ export async function settleStart(start, signal, meta, prune = (blocks) => block
     settled = await settleRun(run, meta, prune, measureChild, t0, logger);
     return settled;
   } catch (error) {
+    // run 可能已创建（start resolve 后 result reject），此时仍可回填子会话 id；
+    // start 自身 reject 时 run 为 undefined，childSessionId 缺省（调用方降级处理）。
     settled = signal.aborted
-      ? { status: 'killed', ...meta, elapsedMs: Date.now() - t0, stopReason: 'aborted' }
-      : { status: 'failed', detail: String(error), ...meta, elapsedMs: Date.now() - t0, stopReason: 'error' };
+      ? { status: 'killed', ...meta, elapsedMs: Date.now() - t0, stopReason: 'aborted', ...(run !== undefined && typeof run.id === 'string' ? { childSessionId: run.id } : {}) }
+      : { status: 'failed', detail: String(error), ...meta, elapsedMs: Date.now() - t0, stopReason: 'error', ...(run !== undefined && typeof run.id === 'string' ? { childSessionId: run.id } : {}) };
     return settled;
   } finally {
     // 无论结果如何结算都要释放子句柄——run.result reject 不得泄漏子 agent

package/lib/core/dispatch-gates.mjs

@@ -43,7 +43,7 @@ export async function applyCostGuardGate(trace, merged, parent, deps) {
   const allowFailOpen = deps.store.getAllowFailOpen();
   const input = { provider: merged.provider, model: merged.model, reasoningEffort: merged.reasoningEffort, maxTokens: merged.maxTokens, maxDepth: merged.maxDepth, allowFailOpen };
   // 决策输入快照补充：请求 model 的 reasoning-effort 支持档位（catalog 快照，
-  // 有缓存；拿不到 fail-soft 省略）——账本可见「该模型当时可选哪些档位」。
+  // 有缓存；拿不到 fail-soft 省略）——台账可见「该模型当时可选哪些档位」。
   if (typeof merged.model === 'string' && merged.model !== '') {
     try {
       const snapshot = await deps.catalog.getSnapshot(parent.ctx.get('llm'));
@@ -84,7 +84,13 @@ export function applyIntersectionGate(trace, mode, intersectionInput, merged, pa
   }
   try {
     const effectiveAllow = computeContinuableAllow(parentToolNames, merged.toolFilter);
-    recordGate(trace, { name: 'intersection', input: intersectionInput, output: { effectiveAllowCount: effectiveAllow.length }, verdict: 'pass' });
+    // 工具集子节数据（continuable 可计算闭集与移除清单）。名单类数组超 8 项由
+    // recordGate 的 truncateLists 自动截断为 { values, truncated }（台账展示时认标记）。
+    const removedRaw = parentToolNames
+      .filter((name) => !effectiveAllow.includes(name))
+      .map((name) => ({ name, reason: name === 'run_code' ? '安全策略：子代理不执行代码' : '不在白名单' }));
+    const removedTools = removedRaw.length > 8 ? { values: removedRaw.slice(0, 8), truncated: true } : removedRaw;
+    recordGate(trace, { name: 'intersection', input: intersectionInput, output: { effectiveAllowCount: effectiveAllow.length, effectiveAllowNames: effectiveAllow, removedTools }, verdict: 'pass' });
     return effectiveAllow;
   } catch (error) {
     recordGate(trace, { name: 'intersection', input: intersectionInput, output: {}, verdict: 'fail', reason: error.message });
@@ -100,6 +106,7 @@ export function applyIntersectionGate(trace, mode, intersectionInput, merged, pa
 export function applyBudgetGate(deps, parent, args, trace) {
   if (args.continuable === true) return { parentSessionId: undefined, finish: () => {}, release: () => {} };
   const parentSessionId = parent.session?.header?.id;
+  const budget = deps.guard.snapshot(parentSessionId);
   const acquired = deps.guard.acquire(parentSessionId);
   if (!acquired.ok) {
     const message = acquired.reason === 'concurrency'
@@ -107,7 +114,7 @@ export function applyBudgetGate(deps, parent, args, trace) {
       : `dispatch: 本会话累计派发 token 已达上限 ${acquired.limit}，请等待在途任务完成或开启新会话`;
     recordGate(trace, {
       name: 'budget',
-      input: { parentSessionId, reason: acquired.reason, limit: acquired.limit },
+      input: { parentSessionId, current: budget, reason: acquired.reason, limit: acquired.limit },
       output: { allowed: false },
       verdict: 'fail',
       reason: message,
@@ -115,11 +122,11 @@ export function applyBudgetGate(deps, parent, args, trace) {
     deps.logger.warn(`[dsh-subagent-profile] ${message}`);
     throw new Error(message);
   }
-  // 通过也记闸（与 whitelist/cost/intersection 同口径：pass/fail 均记，账本时间线可
+  // 通过也记闸（与 whitelist/cost/intersection 同口径：pass/fail 均记，台账时间线可
   // 见预算检查项；无父 sessionId 时 acquire 跳过守卫，同样记 pass 并注明 skipped）。
   recordGate(trace, {
     name: 'budget',
-    input: { parentSessionId },
+    input: { parentSessionId, current: budget },
     output: { allowed: true, skipped: acquired.skipped === true },
     verdict: 'pass',
   });

package/lib/core/dispatch-guard.mjs

@@ -117,6 +117,12 @@ export function createDispatchGuard({ maxConcurrent = 8, maxParentTokens = 20000
       concurrency.delete(parentSessionId);
       tokenTotals.delete(parentSessionId);
     },
+    snapshot: (parentSessionId) => ({
+      concurrency: typeof parentSessionId === 'string' && parentSessionId !== '' ? (concurrency.get(parentSessionId) ?? 0) : 0,
+      tokens: typeof parentSessionId === 'string' && parentSessionId !== '' ? (tokenTotals.get(parentSessionId) ?? 0) : 0,
+      maxConcurrent,
+      maxParentTokens,
+    }),
     reset: () => {
       concurrency.clear();
       tokenTotals.clear();

package/lib/core/dispatch-schema.mjs

@@ -7,7 +7,7 @@
 // assertResultSchemaConsistency 在 apply 时锁定——任一分支漏补共享字段即 throw。
 // decisionTrace 是共享键：三分支都必须携带，但只锁「存在性」（深层结构由
 // lib/core/decision-trace.mjs 的纯函数与单测保证），它经 output.presentationMeta
-// 投影进会话块 meta 供客户端账本展示，不进模型可见面。
+// 投影进会话块 meta 供客户端台账展示，不进模型可见面。
 
 // 输入参数 schema（从 dispatch-tool.mjs 逐字移入；defineTool 只读不改）。
 export const DISPATCH_PARAMETERS = {
@@ -19,7 +19,7 @@ export const DISPATCH_PARAMETERS = {
   //   防护 maxDepth→MAX_DEPTH 硬上限。
   //   模式字段（run_in_background/continuable/envelope）是派发方式选择，不入配置覆盖。
   // 新增字段时须按上列轴归类，并同步键集测试（percall-spec）的 WHITELIST_KEYS。
-  // per-call 规范化清单闭合（spec §11.1）：宿主 dsh-tools 的 DSL 参数解析**默认拒绝
+  // per-call 规范化清单闭合：宿主 dsh-tools 的 DSL 参数解析**默认拒绝
   // 未知键**（2026-08 实测：参数级 additionalProperties 只接受 value schema 对象、
   // 不接受 boolean，故无法显式声明；键集闭合由 percall-spec 测试「键集恰为 14 键」
   // 锁定，mergeProfileArgs 只透传白名单 9 键，未知字段到不了子请求）。
@@ -53,6 +53,11 @@ export const DISPATCH_PARAMETERS = {
   prompt: { type: 'string', required: true, description: '任务文本·该 subagent 完成的自包含任务（它看不到当前对话）。' }
 };
 
+// 已知 per-call 参数键集（单一事实来源）：decisionTrace 的 requested 快照据此把
+// 未知字段记录为 unknown_keys（fail-visible，不静默吞）。宿主 dsh-tools DSL 对
+// 参数默认拒绝未知键，此处是插件侧决策轨迹的可观测兜底。
+export const DISPATCH_PARAMETER_KEYS = Object.freeze(Object.keys(DISPATCH_PARAMETERS));
+
 export const DISPATCH_OUTPUT_SCHEMA = {
   // 每个结果上的可观测元数据。oneOf 覆盖 background 变体（kind/jobId）与
   // foreground 变体（output），两者闭合且都携带生效的委派值。`ignored` 必须
@@ -89,7 +94,7 @@ export const DISPATCH_OUTPUT_SCHEMA = {
         elapsedMs: { type: 'number', description: '派发耗时（毫秒，execute 入口到结算时刻）；后台结算经 job 结果携带，dispatch 结果不带。' },
         stopReason: { type: 'string', enum: ['completed', 'max-tokens', 'aborted', 'refusal', 'error'], description: '子 Agent 结束原因；后台结算经 job 结果携带，dispatch 结果不带。' },
         ignored: { type: 'array', items: { type: 'string' } },
-        decisionTrace: { type: 'object', additionalProperties: true, description: '派发决策轨迹（供客户端账本展示，不进模型可见面）' }
+        decisionTrace: { type: 'object', additionalProperties: true, description: '派发决策轨迹（供客户端台账展示，不进模型可见面）' }
       }
     },
     {
@@ -120,7 +125,7 @@ export const DISPATCH_OUTPUT_SCHEMA = {
         elapsedMs: { type: 'number', description: '派发耗时（毫秒，execute 入口到结算时刻）；continuable 不结算，实际省略。' },
         stopReason: { type: 'string', enum: ['completed', 'max-tokens', 'aborted', 'refusal', 'error'], description: '子 Agent 结束原因；continuable 不结算，实际省略。' },
         ignored: { type: 'array', items: { type: 'string' } },
-        decisionTrace: { type: 'object', additionalProperties: true, description: '派发决策轨迹（供客户端账本展示，不进模型可见面）' }
+        decisionTrace: { type: 'object', additionalProperties: true, description: '派发决策轨迹（供客户端台账展示，不进模型可见面）' }
       }
     },
     {
@@ -150,7 +155,7 @@ export const DISPATCH_OUTPUT_SCHEMA = {
         elapsedMs: { type: 'number', description: '派发耗时（毫秒，execute 入口到结算时刻）；前台 completed 结算时携带。' },
         stopReason: { type: 'string', enum: ['completed', 'max-tokens', 'aborted', 'refusal', 'error'], description: '子 Agent 结束原因；前台 completed 结算时携带。' },
         ignored: { type: 'array', items: { type: 'string' } },
-        decisionTrace: { type: 'object', additionalProperties: true, description: '派发决策轨迹（供客户端账本展示，不进模型可见面）' }
+        decisionTrace: { type: 'object', additionalProperties: true, description: '派发决策轨迹（供客户端台账展示，不进模型可见面）' }
       }
     }
   ]