dsh-subagent-profile 0.3.3 → 0.3.4

package/lib/core/evolution-ledger.mjs

@@ -88,6 +88,8 @@ function buildBase({ parent, args, merged, mode, pluginVersion }) {
     // session_id 空值归一 null：它是未来聚合层惰性 join 的键，静默缺失会破坏
     // join 且难察觉，显式 null 至少保持 JSONL 行形状稳定。
     session_id: parent?.session?.header?.id ?? null,
+    parent_model: parent?.options?.model ?? null,
+    parent_provider: parent?.options?.provider ?? null,
     mode,
     origin: ORIGIN,
     requested: cfgOf(merged),
@@ -107,7 +109,7 @@ function buildBase({ parent, args, merged, mode, pluginVersion }) {
 // tool_count 为「携带 usage 的 assistant/message 事件数」（collectChildCalls 的
 // totalCalls），是工具调用次数的可测代理而非字面计数值——宿主会话面无更直接的
 // 工具调用计数字段；拿不到记 null。
-function foregroundOutcome({ result, elapsedMs, prunedOutputLen, toolCount }) {
+function foregroundOutcome({ result, elapsedMs, prunedOutputLen, toolCount, childTotalTokens, childUsage }) {
   const stopReason = result?.stopReason ?? 'completed';
   const completed = stopReason === 'completed';
   return {
@@ -116,6 +118,8 @@ function foregroundOutcome({ result, elapsedMs, prunedOutputLen, toolCount }) {
     elapsed_ms: elapsedMs,
     output_len: prunedOutputLen,
     tool_count: completed ? toolCount : null,
+    ...(typeof childTotalTokens === 'number' && Number.isFinite(childTotalTokens) ? { tokens: childTotalTokens } : {}),
+    ...(childUsage !== null && typeof childUsage === 'object' ? { usage: childUsage } : {}),
   };
 }
 
@@ -130,12 +134,14 @@ function backgroundOutcome(settled) {
     elapsed_ms: s.elapsedMs,
     output_len: typeof s.output === 'string' ? s.output.length : 0,
     tool_count: totalCalls,
+    ...(typeof s.childTotalTokens === 'number' && Number.isFinite(s.childTotalTokens) ? { tokens: s.childTotalTokens } : {}),
+    ...(s.childUsage !== null && typeof s.childUsage === 'object' ? { usage: s.childUsage } : {}),
   };
 }
 
 // --- 三分支 finish 助手：每条派发只加一行调用（守 dispatch-tool 行门）------------
 
-export function finishForegroundLedger(ledger, base, childId, result, prunedBlocks, elapsedMs, childCalls) {
+export function finishForegroundLedger(ledger, base, childId, result, prunedBlocks, elapsedMs, childCalls, childTotalTokens, childUsage) {
   const calls = childCalls ?? {};
   ledger.record({
     ...base,
@@ -146,6 +152,8 @@ export function finishForegroundLedger(ledger, base, childId, result, prunedBloc
       elapsedMs,
       prunedOutputLen: textFrom(prunedBlocks).length,
       toolCount: typeof calls.totalCalls === 'number' ? calls.totalCalls : null,
+      childTotalTokens,
+      childUsage,
     }),
   });
 }
@@ -161,7 +169,7 @@ export function finishContinuableLedger(ledger, base, childId) {
 // --- 审计 meta（ledger.meta.json）----------------------------------------------
 
 // meta 默认态（缺失/损坏/形状不符均回退此值 → fail-soft 从零）。last_write_ts 为
-// 最近一次成功落盘时间（§12.4 字段；旧文件无该字段时经合并回退 0）。
+// 最近一次成功落盘时间（旧文件无该字段时经合并回退 0）。
 const META_DEFAULTS = { v: 1, lostTelemetry: 0, lostGovernance: 0, health: 'ok', last_write_ts: 0 };
 
 // 读取并校验 meta.json；缺失/损坏/形状不符回退默认并 warn（fail-soft 从零）。
@@ -215,16 +223,19 @@ function persistAuditMeta(metaState, healthValue, warn, { warnOnFailure = true }
 
 // 治理失败统一接线：计 lostGovernance + health 置 degraded，meta 尽力落盘保证
 // 重启仍 degraded；内存 health 无论落盘成败一律降级（写失败只 warn，不降回 ok）。
-function markGovernanceFailureMeta(meta, persistMeta) {
+// ok → degraded 转变时经 onAlert 通知提醒系统（全局审计异常源）。
+function markGovernanceFailureMeta(meta, persistMeta, onAlert) {
+  const wasOk = meta.health === 'ok';
   meta.governanceLost += 1;
   meta.health = 'degraded';
   persistMeta('degraded');
+  if (wasOk && typeof onAlert === 'function') onAlert(meta.governanceLost);
 }
 
 // 治理审计事件（放行审计等）追加一行到 governance-audit.jsonl（append-only 不可变）。
 // 写失败绝不静默：warn + markGovernanceFailureMeta（计 lostGovernance + degraded）；
 // 写成功若正处 degraded，即为一次成功文件写 → 恢复 ok（与派发台账同口径）。
-function appendGovernanceAudit(meta, dir, auditFile, persistMeta, warn, entry) {
+function appendGovernanceAudit(meta, dir, auditFile, persistMeta, warn, onAlert, entry) {
   const line = JSON.stringify({ v: GOVERNANCE_AUDIT_VERSION, ts: Date.now(), ...entry });
   try {
     mkdirSync(dir, { recursive: true });
@@ -232,11 +243,11 @@ function appendGovernanceAudit(meta, dir, auditFile, persistMeta, warn, entry) {
     if (meta.health === 'degraded') persistMeta('ok');
   } catch (error) {
     warn(`dispatch ledger: 治理审计事件写入失败（${error instanceof Error ? error.message : String(error)}）`);
-    markGovernanceFailureMeta(meta, persistMeta);
+    markGovernanceFailureMeta(meta, persistMeta, onAlert);
   }
 }
 
-export function createEvolutionLedger({ dshHome, pluginVersion, warn = () => {} } = {}) {
+export function createEvolutionLedger({ dshHome, pluginVersion, warn = () => {}, onAlert } = {}) {
   if (typeof dshHome !== 'string' || dshHome.length === 0) {
     throw new Error('dispatch ledger: 派发台账需要 dshHome 目录');
   }
@@ -273,12 +284,12 @@ export function createEvolutionLedger({ dshHome, pluginVersion, warn = () => {}
       }
     },
     recordGovernanceAudit(entry) {
-      appendGovernanceAudit(meta, dir, auditFile, persistMeta, warn, entry);
+      appendGovernanceAudit(meta, dir, auditFile, persistMeta, warn, onAlert, entry);
     },
     // 治理审计失败（profile 变更写失败等）：计 lostGovernance + health 置 degraded，
     // 不抛、不阻断调用方；meta 尽力落盘保证重启仍 degraded。
     markGovernanceFailure() {
-      markGovernanceFailureMeta(meta, persistMeta);
+      markGovernanceFailureMeta(meta, persistMeta, onAlert);
     },
     // 进程内 health（'ok' | 'degraded'）。
     metaHealth: () => meta.health,

package/lib/core/evolution-summary.mjs

@@ -1,23 +1,11 @@
-// lib/core/evolution-summary.mjs — 派发台账（dispatch.jsonl）的确定性双层聚合
-// （summaries.json）。纯函数为主：给定输入完全决定输出，可复算、可复现。IO 仅在
-// writeSummaries（原子写 tmp+rename）与顶层装配层出现；computeSummaries 不读文件。
-//
-// 输入口径与派发台账一致（见 evolution-ledger.mjs）：每条 record 为 dispatch.jsonl
-// 一行的解析结果，含 requested/effective 双栏 cfg（preset/model/provider/
-// reasoningEffort/maxTokens/persona_present/toolFilter_present 等）与可选 outcome
-// {status|elapsed_ms|output_len|tool_count}。continuable 无结算（无 outcome 键），
-// 不参与 deployments_total/性能聚合，但参与轴分布。
-//
-// 不变量（可复算）：同输入恒同输出，遍历序稳定；聚合只读台账、不写回；parent_adopted
-// 等动态质量信号不在台账内（写入当时不存在），由聚合层惰性 join（本模块只留字段
-// 占位与可选输入 seam），原始台账本身不注入。
-
-// 仅 writeSummaries/readSummaries/buildAdviceText 需要 IO（node 内置 fs），与台账采集
-// 同种授权面；纯聚合/建议函数零 IO。
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+// lib/core/evolution-summary.mjs — 派发台账（dispatch.jsonl）的确定性双层聚合。
+// computeSummaries 纯函数不读文件；writeSummaries 才碰 IO（派发优化建议链 readSummaries /
+// refreshSummaries / computeAdvice / buildAdviceText 已拆至 evolution-advice.mjs 守行门）。
+// 不变量：同输入恒同输出；聚合只读台账不写回；parent_adopted 由聚合层惰性 join。
+import { mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { summarizeCosts } from './cost-evidence.mjs';
 
-// --- 加权成功分 ---------------------------------------------------------------
 // 公式：weighted_success = (completed − 0.3·confirmedFalse) / total，下限 0，小数点 3
 // 位。每例「已确认未被采纳」的派发（parentAdoptedConfirmedFalse）从分子扣 0.3；
 // unknown（未决）计 0 不惩罚——只有确认 false 才有惩罚，避免窗口期未判决的派发过早
@@ -53,8 +41,9 @@ export function confidenceLevel(n, minN = 3, highN = 10) {
 // --- profile 身份与轴提取（确定性）-------------------------------------------
 // L1 key = 生效配置重建的 profile 身份（台账不存 profileId，故从 effective cfg 重建）；
 // 无区分性配置时记 '(inline)'。能力轴（preset/provider/model/persona/toolFilter）构成
-// 身份；预算轴 effort 不并入（同一配置不同档位不拆组）——但「只调 effort 未调能力轴」
-// 的派发需独立身份才能产出预算轴升建议，此时 effort 单独成键。
+// 身份；预算轴 effort/maxTokens 不并入 L1 键（聚合语义修正：同一方案改预算不得被当成
+// 不同身份——恒判「降」的混合键已废弃）。纯 effort 组与无配置组都落 '(inline)'，
+// 升/降方向改由组内实际配置轴（summarizeGroup 的 axes 字段）判定。
 function cfgSet(cfg) {
   return cfg !== null && typeof cfg === 'object' ? cfg : {};
 }
@@ -67,12 +56,12 @@ function profileKeyOf(cfg) {
   if (c.model !== undefined && c.model !== null) parts.push(`model:${c.model}`);
   if (c.persona_present === true) parts.push('persona:1');
   if (c.toolFilter_present === true) parts.push('toolFilter:1');
-  if (parts.length === 0 && c.reasoningEffort !== undefined && c.reasoningEffort !== null) {
-    parts.push(`effort:${c.reasoningEffort}`);
-  }
   return parts.length > 0 ? parts.join('|') : '(inline)';
 }
 
+// 供 AdoptionTracker 等聚合 join 复用：与 computeSummaries 的 L1 身份键完全一致。
+export { profileKeyOf };
+
 // 能力轴取值：preset/model/provider 取 effective 值（实数命中）；persona 只存 present
 // 布尔（隐私不落原文）；toolFilter_from 取 toolFilter_present 的来源标记（requested/
 // effective 在台账内同源，记 'requested'/'effective'/absent）。
@@ -122,6 +111,25 @@ function mean(acc) {
   return acc === null || acc.count === 0 ? null : Number((acc.sum / acc.count).toFixed(2));
 }
 
+// 组内轴存在性：能力轴（preset/provider/model/persona/toolFilter）与预算轴
+// （reasoningEffort/maxTokens）。L1 键去 effort 后建议的升/降方向不再只依赖键文本
+// （纯 effort 组键为 '(inline)'），改为读组内实际配置轴。
+function groupAxes(records) {
+  let capability = false;
+  let budget = false;
+  for (const r of records) {
+    if (r === null || typeof r !== 'object') continue;
+    const eff = cfgSet(r.effective);
+    if ((eff.preset !== undefined && eff.preset !== null && eff.preset !== 'inherit')
+      || (eff.provider !== undefined && eff.provider !== null)
+      || (eff.model !== undefined && eff.model !== null)
+      || eff.persona_present === true || eff.toolFilter_present === true) capability = true;
+    if ((eff.reasoningEffort !== undefined && eff.reasoningEffort !== null)
+      || (eff.maxTokens !== undefined && eff.maxTokens !== null)) budget = true;
+  }
+  return { capability, budget };
+}
+
 // 组装一层聚合子集（L1 与 L2 复用）：outcome/score/perf/confidence/cooldown/deployments_total。
 function summarizeGroup(records, opts = {}) {
   const counts = outcomeCounts(records);
@@ -141,6 +149,7 @@ function summarizeGroup(records, opts = {}) {
     // tool_count 只对 completed 结算（见台账），且无 usage 事件时空值不计。
     if (r.outcome.status === 'completed') toolAcc = avg(toolAcc, r.outcome.tool_count);
   }
+  const cost = summarizeCosts(records);
   return {
     deployments_total: deploymentsTotal,
     outcome: counts,
@@ -155,15 +164,28 @@ function summarizeGroup(records, opts = {}) {
       min_n_required: 3,
       level: confidenceLevel(deploymentsTotal),
     },
+    // 省 token 证据（38c）：avg_cost 供模型侧 section 与设置页成本预览同源 join；
+    // 无价格/无 usage 的样本不进 priced，avg_cost 为 null 时调用方省略显示。
+    avg_cost: cost.priced > 0 ? Number((cost.estimated_cost / cost.priced).toFixed(4)) : null,
+    cost: {
+      estimated_cost: cost.estimated_cost,
+      estimated_inherit_cost: cost.estimated_inherit_cost,
+      estimated_saving: cost.estimated_saving,
+      priced: cost.priced,
+      inherit_count: cost.inherit_count,
+      inherit_ratio: cost.inherit_ratio,
+    },
     // 冷却期：until_ts/last_apply_ts 由应用层（建议采纳）回填；聚合层尚无来源，置 null。
     cooldown: { until_ts: null, last_apply_ts: null },
+    // 组内轴存在性：L1 键去 effort 后的方向判定来源（legacy 无此字段时回退键文本）。
+    axes: groupAxes(records),
   };
 }
 
 // --- 顶层聚合（纯函数，无 IO）---------------------------------------------------
 // records：dispatch.jsonl 逐行解析结果（调用方可先用 parseDispatchRecords 过滤损坏行）。
 // opts.parentAdoptedConfirmedFalse：可选按聚合 key 的「已确认未采纳」计数 map，供外部
-// 惰性 join 注入（Task 23 建议层）；缺省视为 0（台账内无该信号）。返回 l1/l2 普通对象。
+// 惰性 join 注入；缺省视为 0（台账内无该信号）。返回 l1/l2 普通对象。
 export function computeSummaries(records, opts = {}) {
   const l1Map = new Map();
   const l2Map = new Map();
@@ -189,91 +211,6 @@ export function computeSummaries(records, opts = {}) {
   return { l1: build(l1Map), l2: build(l2Map) };
 }
 
-// --- 只读建议（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;
-
-  return {
-    profileKey: key,
-    performanceText: performanceText(entry),
-    suggestion: directionFor(key, hasCapabilityAxis(key), hasBudgetAxis(key)),
-    confidence: level,
-    cooldownUntil: now + cooldownMs,
-  };
-}
-
 // --- 损坏行解析（纯函数，fail-soft 跳过 + 计数）-------------------------------
 // 逐行 JSON.parse；损坏/空行跳过并计数，不影响有效记录。
 export function parseDispatchRecords(lines) {
@@ -315,118 +252,4 @@ export function writeSummaries(file, data) {
   }
 }
 
-// --- 只读建议（evolution:advice 注入段，默认关）--------------------------------
-
-// 读 summaries.json（存在才读；损坏/形状不符 → null，fail-soft）。
-// §12.5 版本化：只接受 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。此前只被测试调用，summaries.json 无初始生成路径。opts 可注入
-// parentAdoptedConfirmedFalse join（F3 尚未接线）。缺失台账返回 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 ?? '未知错误'}`);
-  }
-}
-
-// 只读建议段文本生成：读 summaries → 逐 profile 校验候选（非 system fail-loud）→
-// suggestAdvice → 写回 cooldown → 渲染。空组跳过候选校验（只对产出建议要求 trust）。
-export function buildAdviceText({ summariesFile, dispatchFile, whitelist, logger }) {
-  // T1 惰性重算：summaries.json 缺失或台账已更新（mtime）时先 refreshSummaries。
-  if (dispatchFile !== undefined && summariesStale(dispatchFile, summariesFile)) {
-    refreshSummaries({ dispatchFile, summariesFile, logger });
-  }
-  const data = readSummaries(summariesFile, logger);
-  if (data === null) return '';
-  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;
-    // F4：候选校验移到「实际产出建议」之后——N<3 组不产出建议，不应因非 system
-    // 候选而抛（校验先于判定与模块注释「只有实际产出的建议键才要求 system-trust」矛盾）。
-    assertSystemCandidate(whitelist, presetFromKey(profileKey));
-    advice.push(suggestion);
-    produced.push([profileKey, suggestion.cooldownUntil]);
-  }
-  if (advice.length === 0) return '';
-  writeBackCooldowns(summariesFile, data, produced, logger);
-  return renderAdviceText(advice, global);
-}