@twinsearth/dsh-master 3.2.10 → 3.3.0

package/dist-host/cost/ledger.js

@@ -0,0 +1,401 @@
+// 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.js";
+/** 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/dist-host/cost/metrics.js

@@ -0,0 +1,198 @@
+// 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 }),
+    });
+}