@twinsearth/dsh-master 3.2.9 → 3.3.0

package/src/cost/ledger.ts

@@ -0,0 +1,385 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 dsh-Master contributors — see LICENSE-CORE.
+// @ts-nocheck — host JS→TS 迁移阶段：运行时行为优先，类型注解逐步补齐（worker/ 仍严格检查）。
+
+/**
+ * 3.3.0 系统层 · ledger（计量账本，设计 §5.1）。
+ *
+ * 按**事件**记账（不是按聚合），每个事件带 task/fork/session/turn/step/phase，
+ * 因此可回放、可按维度查询。
+ *
+ * 口径纪律：
+ *   * 两本账 `execution` / `governance` 分开；`netSaved` 只减 governance；
+ *   * 作用面 `worker` / `host` 分开，外部适配器（`external`）永不计入本项目节省；
+ *   * 估算 token（provider 未返回 usage 的兜底）标记 `estimated: true`，
+ *     报表中与实测**分列**、不相加。
+ *
+ * 存储：进程内环形缓冲（有界）+ 可选 JSONL 落盘（`<dataDir>/cost-ledger.jsonl`）。
+ * 选择「逐行追加」而不是整文件重写：账本只增不改，单行 append 是 O(1)；
+ * 整文件 tmp+rename（ticket-store 的风格）会让每次记账变成 O(n)，账本量大时不可接受。
+ * 追加失败不影响主流程，只累加 `failed` 计数（成本记账不得打断执行）。
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { COST_MODULES, COST_SURFACES, COST_PHASES } from './types.ts'
+
+/** source → phase 的缺省推导（调用方也可显式给 phase）。 */
+const PHASE_OF_SOURCE = Object.freeze({
+  model: 'completion',
+  tool: 'tool',
+  substitution: 'substitution',
+  retry: 'prompt',
+  authoring: 'authoring',
+  offline: 'authoring',
+})
+
+const LEDGER_FILE = 'cost-ledger.jsonl'
+
+function finiteTokens(value) {
+  const n = Number(value)
+  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : null
+}
+
+function emptyBlock() {
+  return { input: 0, output: 0, total: 0, saved: 0, entries: 0 }
+}
+
+function addToBlock(block, entry) {
+  block.input += entry.input
+  block.output += entry.output
+  block.total += entry.total
+  block.saved += entry.savedTokens
+  block.entries += 1
+}
+
+const str = (value) => (value === undefined || value === null ? null : String(value))
+const int = (value, fallback = 0) => {
+  const n = Number(value)
+  return Number.isFinite(n) ? Math.trunc(n) : fallback
+}
+
+/**
+ * @param {{
+ *   now?: () => number, maxEntries?: number, maxTasks?: number,
+ *   dataDir?: string, persist?: boolean, logger?: { warn?: Function },
+ * }} [options]
+ */
+export function createLedger(options = {}) {
+  const now = typeof options.now === 'function' ? options.now : () => Date.now()
+  const maxEntries = Math.max(1, Number(options.maxEntries ?? 5000) || 5000)
+  const maxTasks = Math.max(1, Number(options.maxTasks ?? 200) || 200)
+  const dataDir = options.dataDir === undefined || options.dataDir === null ? '' : String(options.dataDir).trim()
+  const persistEnabled = options.persist === true && dataDir !== ''
+  const file = persistEnabled ? path.join(dataDir, LEDGER_FILE) : null
+  let persistedAppends = 0
+  let persistedFailures = 0
+
+  const entries = []
+  const totals = { execution: emptyBlock(), governance: emptyBlock() }
+  const byModule = new Map()
+  const byTask = new Map()
+  const byFork = new Map()
+  /** 按作用面拆分（worker = 本项目自研；host = 外部适配器，只展示不并入）。 */
+  const bySurface = new Map()
+  /** 本项目自己的执行节省（worker 面、非外部）与外部适配器自报节省（分开累计）。 */
+  let ownExecutionSaved = 0
+  let externalExecutionSaved = 0
+  /** 实测 vs 估算（不混算）。 */
+  const estimateSplit = { measuredTokens: 0, measuredEntries: 0, estimatedTokens: 0, estimatedEntries: 0 }
+  let dropped = 0
+  let seq = 0
+
+  const moduleRow = (module) => {
+    if (!byModule.has(module)) byModule.set(module, emptyBlock())
+    return byModule.get(module)
+  }
+  const taskRow = (key) => {
+    if (!byTask.has(key)) byTask.set(key, emptyBlock())
+    return byTask.get(key)
+  }
+  const forkRow = (key) => {
+    if (!byFork.has(key)) byFork.set(key, emptyBlock())
+    return byFork.get(key)
+  }
+  const surfaceRow = (surface, external) => {
+    const key = `${surface}|${external ? 'external' : 'own'}`
+    if (!bySurface.has(key)) bySurface.set(key, { ...emptyBlock(), surface, external })
+    return bySurface.get(key)
+  }
+
+  /** 单行追加；失败只计数，不影响主流程。回放期间不重复落盘。 */
+  let replaying = false
+  function persistLine(entry) {
+    if (!file || replaying) return
+    try {
+      fs.mkdirSync(dataDir, { recursive: true })
+      const line = `${JSON.stringify({ v: 1, ...entry })}\n`
+      // 单次 append 调用：账本只增不改，避免整文件重写。
+      fs.appendFileSync(file, line, 'utf8')
+      persistedAppends += 1
+    } catch (error) {
+      persistedFailures += 1
+      try { options.logger?.warn?.(`[cost-ledger] append failed: ${String(error?.message ?? error)}`) } catch { /* ignore */ }
+    }
+  }
+
+  function append(input = {}) {
+    const account = String(input.account ?? '')
+    if (account !== 'execution' && account !== 'governance') {
+      return { ok: false, code: 'account-invalid', message: 'account must be execution or governance' }
+    }
+    const source = input.source === undefined ? 'model' : String(input.source)
+    if (!Object.prototype.hasOwnProperty.call(PHASE_OF_SOURCE, source)) {
+      return { ok: false, code: 'source-invalid', message: `source must be one of ${Object.keys(PHASE_OF_SOURCE).join('/')}` }
+    }
+    const phase = input.phase === undefined ? PHASE_OF_SOURCE[source] : String(input.phase)
+    if (!COST_PHASES.includes(phase)) {
+      return { ok: false, code: 'phase-invalid', message: `phase must be one of ${COST_PHASES.join('/')}` }
+    }
+    const module = input.module === undefined ? 'unattributed' : String(input.module)
+    if (!COST_MODULES.includes(module)) {
+      return { ok: false, code: 'module-invalid', message: `module must be one of ${COST_MODULES.join('/')}` }
+    }
+    const surface = input.surface === undefined ? 'worker' : String(input.surface)
+    if (!COST_SURFACES.includes(surface)) {
+      return { ok: false, code: 'surface-invalid', message: `surface must be one of ${COST_SURFACES.join('/')}` }
+    }
+    const external = input.external === true
+    const inputTokens = finiteTokens(input.inputTokens ?? 0)
+    const outputTokens = finiteTokens(input.outputTokens ?? 0)
+    const cachedTokens = finiteTokens(input.cachedTokens ?? 0)
+    if (inputTokens === null) return { ok: false, code: 'input-tokens-invalid', message: 'inputTokens must be a non-negative number' }
+    if (outputTokens === null) return { ok: false, code: 'output-tokens-invalid', message: 'outputTokens must be a non-negative number' }
+    if (cachedTokens === null) return { ok: false, code: 'cached-tokens-invalid', message: 'cachedTokens must be a non-negative number' }
+    const totalInput = input.totalTokens === undefined ? inputTokens + outputTokens : finiteTokens(input.totalTokens)
+    if (totalInput === null) return { ok: false, code: 'total-tokens-invalid', message: 'totalTokens must be a non-negative number' }
+    if (totalInput === 0 && inputTokens + outputTokens > 0) {
+      return { ok: false, code: 'total-tokens-invalid', message: 'totalTokens is zero while input/output tokens are not' }
+    }
+    const baseline = input.baselineTokens === undefined ? null : finiteTokens(input.baselineTokens)
+    if (baseline === null && input.baselineTokens !== undefined) {
+      return { ok: false, code: 'baseline-tokens-invalid', message: 'baselineTokens must be a non-negative number' }
+    }
+    const explicitSaved = input.savedTokens === undefined ? null : finiteTokens(input.savedTokens)
+    if (explicitSaved === null && input.savedTokens !== undefined) {
+      return { ok: false, code: 'saved-tokens-invalid', message: 'savedTokens must be a non-negative number' }
+    }
+    // 显式 savedTokens 优先（归因条目 total=0，只能由调用方给出节省）；
+    // 只有 baseline 时按 baseline - total 推导；两者都没有则 0。
+    const savedTokens = explicitSaved !== null
+      ? explicitSaved
+      : (baseline === null ? 0 : Math.max(0, baseline - totalInput))
+    const estimated = input.estimated === true
+
+    const at = now()
+    seq += 1
+    const entry = Object.freeze({
+      id: `cost_${at.toString(36)}_${seq.toString(36)}`,
+      at,
+      account,
+      module,
+      source,
+      phase,
+      surface,
+      external,
+      taskId: str(input.taskId),
+      forkId: str(input.forkId),
+      sessionId: str(input.sessionId),
+      ticketId: str(input.ticketId),
+      turn: int(input.turn),
+      step: int(input.step),
+      provider: str(input.provider),
+      model: str(input.model),
+      toolName: str(input.toolName),
+      input: inputTokens,
+      output: outputTokens,
+      cached: cachedTokens,
+      total: totalInput,
+      baselineTokens: baseline,
+      savedTokens,
+      estimated,
+      meta: Object.freeze({ ...(input.meta ?? {}) }),
+    })
+
+    entries.push(entry)
+    if (entries.length > maxEntries) {
+      entries.shift()
+      dropped += 1
+    }
+    addToBlock(totals[account], entry)
+    addToBlock(moduleRow(module), entry)
+    addToBlock(surfaceRow(surface, external), entry)
+    addToBlock(forkRow(entry.forkId ?? 'unattributed'), entry)
+    const taskKey = entry.taskId ?? entry.ticketId ?? 'unattributed'
+    addToBlock(taskRow(taskKey), entry)
+    while (byTask.size > maxTasks) {
+      const oldest = byTask.keys().next().value
+      byTask.delete(oldest)
+    }
+    if (account === 'execution') {
+      if (external) externalExecutionSaved += savedTokens
+      else if (surface === 'worker') ownExecutionSaved += savedTokens
+    }
+    if (estimated) {
+      estimateSplit.estimatedTokens += totalInput
+      estimateSplit.estimatedEntries += 1
+    } else {
+      estimateSplit.measuredTokens += totalInput
+      estimateSplit.measuredEntries += 1
+    }
+    persistLine(entry)
+    return { ok: true, entry }
+  }
+
+  function snapshot() {
+    const execution = Object.freeze({ ...totals.execution })
+    const governance = Object.freeze({ ...totals.governance })
+    const bySurfaceRows = [...bySurface.values()].map((row) => Object.freeze({ ...row })).sort((a, b) => b.total - a.total)
+    const byModuleRows = [...byModule.entries()].map(([module, block]) => Object.freeze({ module, ...block })).sort((a, b) => b.total - a.total)
+    const byTaskRows = [...byTask.entries()].map(([key, block]) => Object.freeze({ key, ...block })).sort((a, b) => b.total - a.total)
+    const byForkRows = [...byFork.entries()].map(([forkId, block]) => Object.freeze({ forkId, ...block })).sort((a, b) => b.total - a.total)
+    const allTokens = estimateSplit.measuredTokens + estimateSplit.estimatedTokens
+    return Object.freeze({
+      ok: true,
+      count: entries.length,
+      dropped,
+      execution,
+      governance,
+      /** 只算本项目（worker 面）的执行节省减去治理成本；外部适配器不参与。 */
+      netSaved: ownExecutionSaved - governance.total,
+      ownExecutionSaved,
+      externalSaved: externalExecutionSaved,
+      bySurface: bySurfaceRows,
+      byModule: byModuleRows,
+      byTask: byTaskRows,
+      byFork: byForkRows,
+      tokens: Object.freeze({
+        ...estimateSplit,
+        estimatedRatio: allTokens > 0 ? estimateSplit.estimatedTokens / allTokens : 0,
+      }),
+      persistence: Object.freeze({
+        enabled: persistEnabled,
+        file,
+        appended: persistedAppends,
+        failed: persistedFailures,
+      }),
+    })
+  }
+
+  /**
+   * 按维度查询（设计 §5.1）：task / fork / session / module / account / phase / 时间窗。
+   * 返回最近 limit 条（按时间正序）。
+   */
+  function query(filter = {}) {
+    const limit = Math.max(1, Number(filter.limit ?? 200) || 200)
+    const matches = entries.filter((entry) => {
+      if (filter.taskId !== undefined && entry.taskId !== String(filter.taskId)) return false
+      if (filter.forkId !== undefined && entry.forkId !== String(filter.forkId)) return false
+      if (filter.sessionId !== undefined && entry.sessionId !== String(filter.sessionId)) return false
+      if (filter.ticketId !== undefined && entry.ticketId !== String(filter.ticketId)) return false
+      if (filter.module !== undefined && entry.module !== String(filter.module)) return false
+      if (filter.account !== undefined && entry.account !== String(filter.account)) return false
+      if (filter.phase !== undefined && entry.phase !== String(filter.phase)) return false
+      if (filter.surface !== undefined && entry.surface !== String(filter.surface)) return false
+      if (filter.external !== undefined && entry.external !== filter.external) return false
+      if (filter.estimated !== undefined && entry.estimated !== filter.estimated) return false
+      if (filter.from !== undefined && entry.at < Number(filter.from)) return false
+      if (filter.to !== undefined && entry.at > Number(filter.to)) return false
+      return true
+    })
+    const rows = matches.slice(-limit)
+    return Object.freeze({
+      ok: true,
+      matched: matches.length,
+      returned: rows.length,
+      tokens: rows.reduce((sum, entry) => sum + entry.total, 0),
+      saved: rows.reduce((sum, entry) => sum + entry.savedTokens, 0),
+      entries: rows.slice(),
+    })
+  }
+
+  /** 从 JSONL 重新装载（进程重启后回放）；只读文件，不改内存中的既有事件。 */
+  function replay(direction = 'forward') {
+    if (!file) return { ok: false, code: 'persistence-disabled', message: 'ledger has no dataDir' }
+    let text
+    try {
+      text = fs.readFileSync(file, 'utf8')
+    } catch (error) {
+      if (error?.code === 'ENOENT') return { ok: true, loaded: 0, skipped: 0 }
+      return { ok: false, code: 'read-failed', message: String(error?.message ?? error) }
+    }
+    const lines = text.split('\n').filter((line) => line.trim() !== '')
+    const ordered = direction === 'reverse' ? [...lines].reverse() : lines
+    let loaded = 0
+    let skipped = 0
+    replaying = true
+    try {
+      for (const line of ordered) {
+        try {
+          const parsed = JSON.parse(line)
+          if (!parsed || typeof parsed !== 'object') { skipped += 1; continue }
+          const result = append({
+            account: parsed.account,
+            module: parsed.module,
+            source: parsed.source,
+            phase: parsed.phase,
+            surface: parsed.surface,
+            external: parsed.external,
+            taskId: parsed.taskId ?? undefined,
+            forkId: parsed.forkId ?? undefined,
+            sessionId: parsed.sessionId ?? undefined,
+            ticketId: parsed.ticketId ?? undefined,
+            turn: parsed.turn,
+            step: parsed.step,
+            provider: parsed.provider ?? undefined,
+            model: parsed.model ?? undefined,
+            toolName: parsed.toolName ?? undefined,
+            inputTokens: parsed.input,
+            outputTokens: parsed.output,
+            cachedTokens: parsed.cached,
+            totalTokens: parsed.total,
+            baselineTokens: parsed.baselineTokens ?? undefined,
+            savedTokens: parsed.savedTokens,
+            estimated: parsed.estimated,
+            meta: parsed.meta,
+          })
+          if (result.ok) loaded += 1
+          else skipped += 1
+        } catch {
+          skipped += 1
+        }
+      }
+    } finally {
+      replaying = false
+    }
+    return { ok: true, loaded, skipped }
+  }
+
+  function list(limit = 50) {
+    const n = Math.max(1, Number(limit) || 50)
+    return entries.slice(-n)
+  }
+
+  function reset() {
+    entries.length = 0
+    byModule.clear()
+    byTask.clear()
+    byFork.clear()
+    bySurface.clear()
+    Object.assign(totals.execution, emptyBlock())
+    Object.assign(totals.governance, emptyBlock())
+    ownExecutionSaved = 0
+    externalExecutionSaved = 0
+    estimateSplit.measuredTokens = 0
+    estimateSplit.measuredEntries = 0
+    estimateSplit.estimatedTokens = 0
+    estimateSplit.estimatedEntries = 0
+    dropped = 0
+    seq = 0
+    return { ok: true }
+  }
+
+  return Object.freeze({ append, snapshot, query, replay, list, reset })
+}

package/src/cost/metrics.ts

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 dsh-Master contributors — see LICENSE-CORE.
+// @ts-nocheck — host JS→TS 迁移阶段：运行时行为优先，类型注解逐步补齐（worker/ 仍严格检查）。
+
+/**
+ * 3.3.0 · metrics（验收指标，设计 §10.1）。
+ *
+ * **每份报告必须给全**七项指标；缺任何一项都必须显式报 `complete: false` + `missing[]`，
+ * 不允许"报一半也算报告"。
+ *
+ * | 指标 | 口径 |
+ * |---|---|
+ * | tokens/task | 完整任务输入+输出，含重试/回退/失败执行 |
+ * | 成功率 | 与对照组同 scorer；差值 ≥2pp 下降即触发降级审查 |
+ * | GDR 命中率 / 未命中分布 | 每次复用尝试为分母 |
+ * | CCS 替换数 / 证书完整率 | 证书必须 100% 可回放 |
+ * | 节省归因 | A1/A2/A3/B1–B4 分列 + unattributed |
+ * | governance 成本 | 作者步骤、RSI 离线、选择/验证 |
+ * | 耗时 | wall-clock 中位数与 p95 |
+ */
+
+export const METRIC_KEYS = Object.freeze([
+  'tokensPerTask',
+  'success',
+  'gdr',
+  'ccs',
+  'attribution',
+  'governance',
+  'latency',
+])
+
+/** 成功率相对对照组下降 ≥2pp ⇒ 触发降级审查（§10.1）。 */
+export const SUCCESS_REGRESSION_PP = 0.02
+
+const MODULES = Object.freeze(['a1-compact', 'a2-disclosure', 'a3-batch', 'b1-edg', 'b2-gdr', 'b3-ccs', 'b4-rsi', 'unattributed'])
+
+function num(value) {
+  const n = Number(value)
+  return Number.isFinite(n) ? n : 0
+}
+
+function percentile(sorted, ratio) {
+  if (sorted.length === 0) return null
+  if (sorted.length === 1) return sorted[0]
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(ratio * sorted.length) - 1))
+  return sorted[index]
+}
+
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b)
+  return percentile(sorted, 0.5)
+}
+
+function p95(values) {
+  const sorted = [...values].sort((a, b) => a - b)
+  return percentile(sorted, 0.95)
+}
+
+/**
+ * @param {{
+ *   entries?: object[],
+ *   certificates?: object[],
+ *   tasks?: Array<{taskId: string, success?: boolean, elapsedMs?: number, tokens?: number}>,
+ *   control?: { successRate?: number, tokensPerTask?: number },
+ *   guard?: { attempts?: number, hits?: number, byReason?: object },
+ *   audit?: { ok?: boolean, count?: number },
+ *   traceCheck?: (taskId: string) => { reconciled?: boolean },
+ * }} [input]
+ */
+export function buildMetricsReport(input = {}) {
+  const entries = Array.isArray(input.entries) ? input.entries : []
+  const certificates = Array.isArray(input.certificates) ? input.certificates : []
+  const tasks = Array.isArray(input.tasks) ? input.tasks : []
+  const missing = []
+
+  // ---- tokens/task：完整任务输入+输出（含重试/回退/失败执行）----
+  const tokensByTask = new Map()
+  for (const entry of entries) {
+    if (entry?.account !== 'execution') continue
+    const key = String(entry.taskId ?? 'unattributed')
+    tokensByTask.set(key, (tokensByTask.get(key) ?? 0) + Math.max(0, num(entry.total)))
+  }
+  const taskTokens = (tasks.length > 0
+    ? tasks.map((task) => Math.max(0, num(task.tokens) || (tokensByTask.get(String(task.taskId)) ?? 0)))
+    : [...tokensByTask.values()])
+  // 既有任务显式 tokens、也有账本 token 事件，才算「有 token 数据」；否则该项缺失。
+  const hasTokenData = tokensByTask.size > 0 || tasks.some((task) => num(task?.tokens) > 0)
+  const tokensPerTask = hasTokenData && taskTokens.length > 0
+    ? Math.round((taskTokens.reduce((sum, value) => sum + value, 0) / taskTokens.length) * 100) / 100
+    : null
+  if (tokensPerTask === null) missing.push('tokensPerTask')
+
+  // ---- 成功率：与对照组同 scorer；≥2pp 下降触发审查 ----
+  const scored = tasks.filter((task) => typeof task?.success === 'boolean')
+  const successRate = scored.length > 0 ? scored.filter((task) => task.success === true).length / scored.length : null
+  if (successRate === null) missing.push('success')
+  const controlRate = Number.isFinite(Number(input?.control?.successRate)) ? Number(input.control.successRate) : null
+  const successDelta = successRate !== null && controlRate !== null ? Math.round((successRate - controlRate) * 10000) / 10000 : null
+  const regression = successDelta !== null && successDelta <= -SUCCESS_REGRESSION_PP
+  const success = {
+    rate: successRate,
+    samples: scored.length,
+    scorer: 'same-as-control',
+    control: controlRate,
+    delta: successDelta,
+    /** §10.1：差值 ≥2pp 下降 ⇒ 触发降级审查。 */
+    reviewRequired: regression,
+    thresholdPp: SUCCESS_REGRESSION_PP,
+  }
+
+  // ---- GDR：每次复用尝试为分母 ----
+  const attempts = Math.max(0, num(input?.guard?.attempts))
+  const hits = Math.max(0, num(input?.guard?.hits))
+  const byReason = { ...(input?.guard?.byReason ?? {}) }
+  const gdr = {
+    attempts,
+    hits,
+    hitRate: attempts > 0 ? Math.round((hits / attempts) * 10000) / 10000 : null,
+    byReason,
+    denominator: 'reuse-attempts',
+  }
+  if (attempts === 0) missing.push('gdr')
+
+  // ---- CCS：替换数 + 证书完整率（必须 100% 可回放）----
+  const dispatched = certificates.filter((cert) => cert?.dispatched !== false)
+  const REQUIRED = ['edgeId', 'toolName', 'schemaHash', 'guardExpr', 'receiptDigest', 'replacedCallbackId', 'taskId']
+  const complete = certificates.filter((cert) => REQUIRED.every((key) => String(cert?.[key] ?? '').trim() !== '') && cert?.viaNativeDispatcher === true)
+  const reconciled = certificates.filter((cert) => {
+    if (typeof input?.traceCheck !== 'function') return true
+    try { return input.traceCheck(String(cert?.taskId ?? ''))?.reconciled === true } catch { return false }
+  })
+  const completeness = certificates.length > 0 ? Math.round((complete.length / certificates.length) * 10000) / 10000 : null
+  const ccs = {
+    substitutions: dispatched.length,
+    certificates: certificates.length,
+    completeness,
+    replayable: completeness === 1,
+    reconciled: certificates.length === 0 ? null : reconciled.length === certificates.length,
+    auditVerified: input?.audit?.ok !== false,
+  }
+  if (certificates.length === 0) missing.push('ccs')
+
+  // ---- 节省归因：按模块分列 + unattributed ----
+  const byModule = {}
+  for (const key of MODULES) byModule[key] = 0
+  for (const entry of entries) {
+    if (entry?.account !== 'execution' || !(num(entry?.savedTokens) > 0)) continue
+    const moduleKey = MODULES.includes(String(entry.module)) ? String(entry.module) : 'unattributed'
+    byModule[moduleKey] += Math.max(0, num(entry.savedTokens))
+  }
+  const attribution = { byModule, total: Object.values(byModule).reduce((sum, value) => sum + value, 0) }
+  if (attribution.total === 0) missing.push('attribution')
+
+  // ---- governance：作者 / RSI 离线 / 选择与验证 ----
+  const governanceByKind = { author: 0, rsiOffline: 0, selection: 0, other: 0 }
+  for (const entry of entries) {
+    if (entry?.account !== 'governance') continue
+    const tokens = Math.max(0, num(entry.total))
+    const kind = String(entry.meta?.kind ?? entry.source ?? 'other')
+    if (kind.includes('edg') || kind.includes('author')) governanceByKind.author += tokens
+    else if (kind.includes('rsi') || String(entry.source) === 'offline') governanceByKind.rsiOffline += tokens
+    else if (kind.includes('select') || kind.includes('valid') || kind.includes('load')) governanceByKind.selection += tokens
+    else governanceByKind.other += tokens
+  }
+  const governance = {
+    ...governanceByKind,
+    total: Object.values(governanceByKind).reduce((sum, value) => sum + value, 0),
+  }
+
+  // ---- 耗时：中位数 + p95 ----
+  const durations = tasks.map((task) => num(task?.elapsedMs)).filter((value) => value > 0)
+  const latency = {
+    medianMs: durations.length > 0 ? median(durations) : null,
+    p95Ms: durations.length > 0 ? p95(durations) : null,
+    samples: durations.length,
+  }
+  if (durations.length === 0) missing.push('latency')
+
+  const uniqueMissing = METRIC_KEYS.filter((key) => missing.includes(key))
+  return Object.freeze({
+    ok: true,
+    complete: uniqueMissing.length === 0,
+    missing: uniqueMissing,
+    tokensPerTask: Object.freeze({ value: tokensPerTask, includesRetries: true, includesFailures: true, samples: taskTokens.length }),
+    success: Object.freeze(success),
+    gdr: Object.freeze(gdr),
+    ccs: Object.freeze(ccs),
+    attribution: Object.freeze({ ...attribution, byModule: Object.freeze({ ...byModule }) }),
+    governance: Object.freeze(governance),
+    latency: Object.freeze(latency),
+    control: Object.freeze({ successRate: controlRate, tokensPerTask: Number.isFinite(Number(input?.control?.tokensPerTask)) ? Number(input.control.tokensPerTask) : null }),
+  })
+}