dsh-subagent-profile 0.3.2 → 0.3.4

package/lib/core/evolution-ledger.mjs

@@ -0,0 +1,300 @@
+// lib/core/evolution-ledger.mjs — 派发台账（dispatch.jsonl）采集。JSONL 追加不可变：
+// 只 appendFileSync 追加一行，绝不改写既有行。import-free（仅 node 内置
+// fs/crypto/path + lib/core/pure.mjs），可被 bare-CI 单测直接 import。采集异常只
+// warn + 丢失计数，绝不阻断派发（fail-soft）。
+//
+// 审计分级：每类写失败分别计数，计数与 health 落盘到同目录的 ledger.meta.json
+// （{v:1, lostTelemetry, lostGovernance, health}）。派发台账写失败计 lostTelemetry
+// （fail-soft 仅告警）；profile 变更/治理写失败走 markGovernanceFailure 计
+// lostGovernance 且 health 置 degraded（高可见，设置页红字暴露）。meta 独立成域
+// subagent-evolution/（以 dshHome 为根，不在 .agent-presets/ 下，不被 preset 同步
+// 裁剪）。health 持久化：重启保持 degraded，直到一次 meta 写成功（成功派发触发恢复）
+// 才回 ok。meta.json 原子写（tmp+rename），损坏 fail-soft 从零，写失败绝不抛。
+//
+// 隐私红线：绝不落子 Agent 原始输出 / prompt 原文 / persona 原文——每条记录只有长度
+// （min-PII）与确定性结构指纹。persona 只存 present 布尔 + 文本结构指纹；toolFilter 只
+// 存 present + allow/deny 数组结构指纹。parent_adopted / goal_achieved / human_edited
+// 不入库（写入那个时刻它们尚不存在，事后回填会破坏 append-only 不可变性，只由聚合层
+// 惰性 join）。
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { textFrom } from './pure.mjs';
+
+const LEDGER_VERSION = 1;
+const GOVERNANCE_AUDIT_VERSION = 1;
+const SOURCE = 'system';
+const ORIGIN = 'subagent';
+
+// --- 结构指纹（确定性，输入相同恒产出相同指纹）----------------------------------
+// 长度做导流 + sha1 前 8 区分内容：仅截断哈希可被碰撞枚举，叠加前缀长度后同时刻画
+// 内容形状与体量，避免可枚举碰撞。不含原文。
+function fingerprint(text) {
+  const value = String(text ?? '');
+  const hash = createHash('sha1').update(value, 'utf8').digest('hex').slice(0, 8);
+  return `L${value.length}_${hash}`;
+}
+
+// prompt 规范化结构指纹：长度 + 换行数 + sha1 前 8（内容形状标识，独缺原文）。
+function structureFingerprint(prompt) {
+  const value = String(prompt ?? '');
+  let newlines = 0;
+  for (let i = 0; i < value.length; i += 1) if (value[i] === '\n') newlines += 1;
+  return `${fingerprint(value)}_NL${newlines}`;
+}
+
+// allow/deny 数组结构指纹：各数组的项数 + 内容 sha1（只对数组结构，不含父级配置）。
+function toolFilterFingerprint(toolFilter) {
+  const list = (arr) => (Array.isArray(arr) ? arr : []);
+  const allow = list(toolFilter?.allow);
+  const deny = list(toolFilter?.deny);
+  const part = (label, arr) => `${label}:N${arr.length}_${fingerprint(JSON.stringify(arr))}`;
+  return `${part('allow', allow)};${part('deny', deny)}`;
+}
+
+// cfg（requested/effective 双栏共用）。pending 为 merged（continuable 时部分值会被
+// 丢弃）；opts 覆盖生效栏（continuable 生效 preset 恒 'inherit'、reasoningEffort 被
+// 宿主忽略应空置）。双栏拆分正是为捕捉「请求了但被宿主丢弃」的失真。空字段统一
+// 归一为 null（不写 undefined，保持 JSONL 行形状稳定）。
+function cfgOf(merged, opts = {}) {
+  const persona = typeof merged?.persona === 'string' ? merged.persona : '';
+  const hasPersona = persona.length > 0;
+  const toolFilterSet = merged?.toolFilter !== undefined && merged?.toolFilter !== null;
+  const str = (value) => (typeof value === 'string' && value.length > 0 ? value : null);
+  return {
+    preset: opts.preset ?? (typeof merged?.preset === 'string' && merged.preset !== '' ? merged.preset : 'inherit'),
+    provider: str(merged?.provider),
+    model: str(merged?.model),
+    reasoningEffort: opts.reasoningEffort !== undefined ? opts.reasoningEffort : str(merged?.reasoningEffort),
+    maxTokens: typeof merged?.maxTokens === 'number' ? merged.maxTokens : null,
+    maxDepth: typeof merged?.maxDepth === 'number' ? merged.maxDepth : null,
+    persona_present: hasPersona,
+    persona_fp: hasPersona ? fingerprint(persona) : null,
+    toolFilter_present: toolFilterSet,
+    toolFilter_fp: toolFilterSet ? toolFilterFingerprint(merged.toolFilter) : null,
+  };
+}
+
+// 记录静态元数据（写入即知的共享字段，不含 ts/v——由 record 落盘时补）。三分支各自
+// 在此基础上补 child_id 与 outcome 后调用 record。pluginVersion 由工厂闭包注入。
+function buildBase({ parent, args, merged, mode, pluginVersion }) {
+  const prompt = typeof args?.prompt === 'string' ? args.prompt : '';
+  const effectivePreset = mode === 'continuable' ? 'inherit' : (merged?.preset ?? 'inherit');
+  // continuable 下宿主忽略 reasoningEffort（决策轨迹侧将其列入 ignored），生效栏
+  // 空置以保持「生效值」语义与聚合层读值不失真。
+  const effectiveReasoningEffort = mode === 'continuable' ? null : (merged?.reasoningEffort ?? null);
+  return {
+    // 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),
+    effective: cfgOf(merged, { preset: effectivePreset, reasoningEffort: effectiveReasoningEffort }),
+    task: {
+      len: prompt.length,
+      structure: structureFingerprint(prompt),
+    },
+    source: SOURCE,
+    provenance: `dispatch:v${pluginVersion}`,
+    plugin_version: pluginVersion,
+  };
+}
+
+// --- outcome 组装（前台/后台结算时携带；continuable 无结算 → 不产 outcome）--------
+
+// tool_count 为「携带 usage 的 assistant/message 事件数」（collectChildCalls 的
+// totalCalls），是工具调用次数的可测代理而非字面计数值——宿主会话面无更直接的
+// 工具调用计数字段；拿不到记 null。
+function foregroundOutcome({ result, elapsedMs, prunedOutputLen, toolCount, childTotalTokens, childUsage }) {
+  const stopReason = result?.stopReason ?? 'completed';
+  const completed = stopReason === 'completed';
+  return {
+    status: completed ? 'completed' : (stopReason === 'aborted' ? 'killed' : 'failed'),
+    stop_reason: stopReason,
+    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 } : {}),
+  };
+}
+
+function backgroundOutcome(settled) {
+  const s = settled !== null && typeof settled === 'object' ? settled : {};
+  const totalCalls = s.calls !== null && typeof s.calls === 'object' && typeof s.calls.totalCalls === 'number'
+    ? s.calls.totalCalls
+    : null;
+  return {
+    status: s.status ?? 'failed',
+    stop_reason: s.stopReason ?? 'error',
+    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, childTotalTokens, childUsage) {
+  const calls = childCalls ?? {};
+  ledger.record({
+    ...base,
+    child_id: childId,
+    mode: 'foreground',
+    outcome: foregroundOutcome({
+      result,
+      elapsedMs,
+      prunedOutputLen: textFrom(prunedBlocks).length,
+      toolCount: typeof calls.totalCalls === 'number' ? calls.totalCalls : null,
+      childTotalTokens,
+      childUsage,
+    }),
+  });
+}
+
+export function finishBackgroundLedger(ledger, base, childId, settled) {
+  ledger.record({ ...base, child_id: childId, mode: 'background', outcome: backgroundOutcome(settled) });
+}
+
+export function finishContinuableLedger(ledger, base, childId) {
+  ledger.record({ ...base, child_id: childId, mode: 'continuable' });
+}
+
+// --- 审计 meta（ledger.meta.json）----------------------------------------------
+
+// meta 默认态（缺失/损坏/形状不符均回退此值 → fail-soft 从零）。last_write_ts 为
+// 最近一次成功落盘时间（旧文件无该字段时经合并回退 0）。
+const META_DEFAULTS = { v: 1, lostTelemetry: 0, lostGovernance: 0, health: 'ok', last_write_ts: 0 };
+
+// 读取并校验 meta.json；缺失/损坏/形状不符回退默认并 warn（fail-soft 从零）。
+// 只接受 v:1 与必填三字段的数字/字符串形态，防止被手改的坏元数据冒充。
+function loadAuditMeta(metaFile, warn) {
+  if (!existsSync(metaFile)) return { ...META_DEFAULTS };
+  try {
+    const parsed = JSON.parse(readFileSync(metaFile, 'utf8'));
+    if (
+      parsed !== null && typeof parsed === 'object' && parsed.v === 1
+      && typeof parsed.lostTelemetry === 'number' && Number.isFinite(parsed.lostTelemetry)
+      && typeof parsed.lostGovernance === 'number' && Number.isFinite(parsed.lostGovernance)
+      && (parsed.health === 'ok' || parsed.health === 'degraded')
+    ) {
+      return { ...META_DEFAULTS, ...parsed };
+    }
+    warn(`ledger meta: 审计元数据形状不符，已从零重建（${metaFile}）`);
+    return { ...META_DEFAULTS };
+  } catch {
+    warn(`ledger meta: 审计元数据损坏，已从零重建（${metaFile}）`);
+    return { ...META_DEFAULTS };
+  }
+}
+
+// --- 工厂 -----------------------------------------------------------------------
+
+// 原子写 meta.json（tmp+rename）。metaState 为可写闭包状态 {dir, metaFile, lost,
+// governanceLost, health}；写成功以 healthValue 为准（恢复 ok 即在此触发）。写失败
+// fail-soft：清理 tmp + warn、返回 false。warnOnFailure 供派发遥测失败路径关闭——
+// 该路径已就台账写失败 warn 一次，避免重复告警。
+function persistAuditMeta(metaState, healthValue, warn, { warnOnFailure = true } = {}) {
+  const payload = { v: 1, lostTelemetry: metaState.lost, lostGovernance: metaState.governanceLost, health: healthValue, last_write_ts: Date.now() };
+  let reported = false;
+  try {
+    mkdirSync(metaState.dir, { recursive: true });
+    const tmp = `${metaState.metaFile}.tmp`;
+    writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
+    renameSync(tmp, metaState.metaFile);
+    metaState.health = healthValue;
+  } catch (error) {
+    try { rmSync(`${metaState.metaFile}.tmp`, { force: true }); } catch { /* best effort */ }
+    reported = true;
+    if (warnOnFailure) {
+      warn(`ledger meta: 审计元数据写入失败（${error instanceof Error ? error.message : String(error)}）`);
+    }
+  }
+  return !reported;
+}
+
+// --- 治理审计（append-only）-------------------------------------------------------
+
+// 治理失败统一接线：计 lostGovernance + health 置 degraded，meta 尽力落盘保证
+// 重启仍 degraded；内存 health 无论落盘成败一律降级（写失败只 warn，不降回 ok）。
+// 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, onAlert, entry) {
+  const line = JSON.stringify({ v: GOVERNANCE_AUDIT_VERSION, ts: Date.now(), ...entry });
+  try {
+    mkdirSync(dir, { recursive: true });
+    appendFileSync(auditFile, `${line}\n`, 'utf8');
+    if (meta.health === 'degraded') persistMeta('ok');
+  } catch (error) {
+    warn(`dispatch ledger: 治理审计事件写入失败（${error instanceof Error ? error.message : String(error)}）`);
+    markGovernanceFailureMeta(meta, persistMeta, onAlert);
+  }
+}
+
+export function createEvolutionLedger({ dshHome, pluginVersion, warn = () => {}, onAlert } = {}) {
+  if (typeof dshHome !== 'string' || dshHome.length === 0) {
+    throw new Error('dispatch ledger: 派发台账需要 dshHome 目录');
+  }
+  const dir = join(dshHome, 'subagent-evolution');
+  const file = join(dir, 'dispatch.jsonl');
+  const auditFile = join(dir, 'governance-audit.jsonl');
+  const persisted = loadAuditMeta(join(dir, 'ledger.meta.json'), warn);
+  // 可写审计状态：lost（遥测）/governanceLost/health，初始为持久化值。
+  const meta = {
+    dir,
+    metaFile: join(dir, 'ledger.meta.json'),
+    lost: persisted.lostTelemetry,
+    governanceLost: persisted.lostGovernance,
+    health: persisted.health,
+  };
+  const persistMeta = (healthValue, opts) => persistAuditMeta(meta, healthValue, warn, opts);
+
+  return {
+    baseEntry: (input) => buildBase({ ...input, pluginVersion }),
+    // 追加不可变：mkdir recursive + appendFileSync。写失败只 warn + 丢失计数 ++，
+    // 绝不抛错、绝不阻断派发。写失败计 lostTelemetry 并落盘 meta；写成功恢复 ok。
+    record(entry) {
+      try {
+        // 序列化也在 try 内（循环引用/BigInt 等理论异常会绕过 fail-soft 外泄；
+        // 实际 entry 为自产标量，防御性收口）。
+        const line = JSON.stringify({ v: LEDGER_VERSION, ts: Date.now(), ...entry });
+        mkdirSync(dir, { recursive: true });
+        appendFileSync(file, `${line}\n`, 'utf8');
+        if (meta.health === 'degraded') persistMeta('ok');
+      } catch (error) {
+        meta.lost += 1;
+        warn(`dispatch ledger: 派发台账写入失败，已丢失 ${meta.lost} 条（${error instanceof Error ? error.message : String(error)}）`);
+        persistMeta(meta.health, { warnOnFailure: false });
+      }
+    },
+    recordGovernanceAudit(entry) {
+      appendGovernanceAudit(meta, dir, auditFile, persistMeta, warn, onAlert, entry);
+    },
+    // 治理审计失败（profile 变更写失败等）：计 lostGovernance + health 置 degraded，
+    // 不抛、不阻断调用方；meta 尽力落盘保证重启仍 degraded。
+    markGovernanceFailure() {
+      markGovernanceFailureMeta(meta, persistMeta, onAlert);
+    },
+    // 进程内 health（'ok' | 'degraded'）。
+    metaHealth: () => meta.health,
+    // 设置页 summary 的 audit 字段来源：{lostTelemetry, lostGovernance, health}。
+    auditState: () => ({ lostTelemetry: meta.lost, lostGovernance: meta.governanceLost, health: meta.health }),
+    lostCount: () => meta.lost,
+  };
+}

package/lib/core/evolution-summary.mjs

@@ -0,0 +1,255 @@
+// 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 才有惩罚，避免窗口期未判决的派发过早
+// 拉低分数。total = completed+failed+killed。
+export function weightedSuccess({ completed, failed, killed, parentAdoptedConfirmedFalse = 0 }) {
+  const total = completed + failed + killed;
+  if (total <= 0) return 0;
+  const falseCount = Number.isFinite(parentAdoptedConfirmedFalse) ? parentAdoptedConfirmedFalse : 0;
+  const numerator = Math.max(0, completed - 0.3 * Math.max(0, falseCount));
+  return Number((numerator / total).toFixed(3));
+}
+
+// --- 采纳判定窗口（三态）------------------------------------------------------
+// 参数化判定窗口：窗口内（尚未超过 N 轮 或 T ms）未引用一律 unknown；窗口外已确认未
+// 引用（adoptedAt 为 null）落 false；adoptedAt 有值恒 true。N/T 待实测后校准，故均为
+// 参数而非常量。
+export function adoptStatus({ windowN = null, windowMs = null, dispatchedAt, adoptedAt, now, roundsElapsed = null }) {
+  if (adoptedAt !== null && adoptedAt !== undefined) return 'true';
+  const base = dispatchedAt !== null && dispatchedAt !== undefined ? dispatchedAt : now;
+  const withinMs = windowMs === null || (now - base) < windowMs;
+  const withinRounds = windowN === null || (roundsElapsed !== null ? roundsElapsed : 0) < windowN;
+  return withinMs && withinRounds ? 'unknown' : 'false';
+}
+
+// --- 置信度级别 ---------------------------------------------------------------
+// 阈值（3/10）与 min_n_required 为建议初值，待实测后校准。
+export function confidenceLevel(n, minN = 3, highN = 10) {
+  if (n >= highN) return 'high';
+  if (n >= minN) return 'medium';
+  return 'low';
+}
+
+// --- profile 身份与轴提取（确定性）-------------------------------------------
+// L1 key = 生效配置重建的 profile 身份（台账不存 profileId，故从 effective cfg 重建）；
+// 无区分性配置时记 '(inline)'。能力轴（preset/provider/model/persona/toolFilter）构成
+// 身份；预算轴 effort/maxTokens 不并入 L1 键（聚合语义修正：同一方案改预算不得被当成
+// 不同身份——恒判「降」的混合键已废弃）。纯 effort 组与无配置组都落 '(inline)'，
+// 升/降方向改由组内实际配置轴（summarizeGroup 的 axes 字段）判定。
+function cfgSet(cfg) {
+  return cfg !== null && typeof cfg === 'object' ? cfg : {};
+}
+
+function profileKeyOf(cfg) {
+  const c = cfgSet(cfg);
+  const parts = [];
+  if (c.preset !== undefined && c.preset !== null && c.preset !== 'inherit') parts.push(`preset:${c.preset}`);
+  if (c.provider !== undefined && c.provider !== null) parts.push(`provider:${c.provider}`);
+  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');
+  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）。
+function capabilityAxisKeys(profileKey, record) {
+  const eff = cfgSet(record?.effective);
+  const req = cfgSet(record?.requested);
+  const keys = [];
+  if (eff.preset !== undefined && eff.preset !== null) keys.push(`${profileKey}:preset:${eff.preset}`);
+  if (eff.model !== undefined && eff.model !== null) keys.push(`${profileKey}:model:${eff.model}`);
+  if (eff.provider !== undefined && eff.provider !== null) keys.push(`${profileKey}:provider:${eff.provider}`);
+  keys.push(`${profileKey}:persona:${eff.persona_present === true ? 'present' : 'absent'}`);
+  const from = req.toolFilter_present === true && eff.toolFilter_present === true
+    ? 'requested-and-effective'
+    : (eff.toolFilter_present === true ? 'effective' : 'absent');
+  keys.push(`${profileKey}:toolFilter_from:${from}`);
+  return keys;
+}
+
+function budgetAxisKeys(profileKey, record) {
+  const eff = cfgSet(record?.effective);
+  const keys = [];
+  if (eff.maxTokens !== undefined && eff.maxTokens !== null) keys.push(`${profileKey}:maxTokens:${eff.maxTokens}`);
+  if (eff.reasoningEffort !== undefined && eff.reasoningEffort !== null) {
+    keys.push(`${profileKey}:reasoningEffort:${eff.reasoningEffort}`);
+  }
+  return keys;
+}
+
+// --- 单组聚合 -----------------------------------------------------------------
+function outcomeCounts(records) {
+  const counts = { completed: 0, failed: 0, killed: 0 };
+  for (const r of records) {
+    if (r !== null && typeof r === 'object' && r.outcome && r.outcome.status === 'completed') counts.completed += 1;
+    else if (r !== null && typeof r === 'object' && r.outcome && r.outcome.status === 'failed') counts.failed += 1;
+    else if (r !== null && typeof r === 'object' && r.outcome && r.outcome.status === 'killed') counts.killed += 1;
+  }
+  return counts;
+}
+
+function avg(existing, value) {
+  if (value === undefined || value === null || !Number.isFinite(value)) return existing;
+  if (existing === null) return { sum: value, count: 1 };
+  return { sum: existing.sum + value, count: existing.count + 1 };
+}
+
+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);
+  const deploymentsTotal = counts.completed + counts.failed + counts.killed;
+  const parentAdoptedConfirmedFalse = opts.parentAdoptedConfirmedFalse ?? 0;
+  const score = {
+    weighted_success: weightedSuccess({ ...counts, parentAdoptedConfirmedFalse }),
+    win_rate: deploymentsTotal > 0 ? Number((counts.completed / deploymentsTotal).toFixed(3)) : 0,
+  };
+  let elapsedAcc = null;
+  let outputAcc = null;
+  let toolAcc = null;
+  for (const r of records) {
+    if (!r || typeof r !== 'object' || !r.outcome) continue;
+    elapsedAcc = avg(elapsedAcc, r.outcome.elapsed_ms);
+    outputAcc = avg(outputAcc, r.outcome.output_len);
+    // 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,
+    score,
+    perf: {
+      avg_elapsed_ms: mean(elapsedAcc),
+      avg_output_len: mean(outputAcc),
+      avg_tool_count: mean(toolAcc),
+    },
+    confidence: {
+      n: deploymentsTotal,
+      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 注入；缺省视为 0（台账内无该信号）。返回 l1/l2 普通对象。
+export function computeSummaries(records, opts = {}) {
+  const l1Map = new Map();
+  const l2Map = new Map();
+  for (const record of records) {
+    if (record === null || typeof record !== 'object') continue;
+    const eff = cfgSet(record.effective);
+    const profileKey = profileKeyOf(eff);
+    if (!l1Map.has(profileKey)) l1Map.set(profileKey, []);
+    l1Map.get(profileKey).push(record);
+    for (const axisKey of capabilityAxisKeys(profileKey, record).concat(budgetAxisKeys(profileKey, record))) {
+      if (!l2Map.has(axisKey)) l2Map.set(axisKey, []);
+      l2Map.get(axisKey).push(record);
+    }
+  }
+  const falseCounts = opts.parentAdoptedConfirmedFalse ?? {};
+  const build = (map) => {
+    const out = {};
+    for (const [key, list] of map) {
+      out[key] = summarizeGroup(list, { parentAdoptedConfirmedFalse: falseCounts[key] ?? 0 });
+    }
+    return out;
+  };
+  return { l1: build(l1Map), l2: build(l2Map) };
+}
+
+// --- 损坏行解析（纯函数，fail-soft 跳过 + 计数）-------------------------------
+// 逐行 JSON.parse；损坏/空行跳过并计数，不影响有效记录。
+export function parseDispatchRecords(lines) {
+  let skipped = 0;
+  const records = [];
+  for (const line of lines) {
+    if (typeof line !== 'string' || line.trim().length === 0) {
+      skipped += 1;
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      records.push(parsed);
+    } catch {
+      skipped += 1;
+    }
+  }
+  return { records, skipped };
+}
+
+// --- 原子写入（tmp+rename；profiles-store 模式）------------------------------
+// 写 <file>.tmp 后 rename 覆盖，崩溃不产生截断文件。失败不 throw，返回 {persisted,
+// error?} 由调用方按 fail-soft 处理。何时重算由调度层（审计分层/手动触发）决定，本
+// 模块只提供写入原语。目录缺失时 mkdir recursive 补齐。
+export function writeSummaries(file, data) {
+  const tmp = `${file}.tmp`;
+  try {
+    // 顶层带 v 版本号（台账按行带 v 同源），改 schema 时递增。
+    const payload = { v: 1, ...data, _computed_at: Date.now() };
+    const dir = dirname(file);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
+    renameSync(tmp, file);
+    return { persisted: true };
+  } catch (error) {
+    // 尽力清理未 rename 的残留 tmp。
+    try { rmSync(tmp, { force: true }); } catch { /* best effort */ }
+    return { persisted: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+