@twinsearth/dsh-master 3.2.10 → 3.3.0

package/dist-host/cost/index.js

@@ -0,0 +1,312 @@
+// 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 / budget / policy / audit 组装成一个系统。
+ *
+ * `cost-optimizer` 插件通过它拿到统一的记账、预算、灰度与审计口径；
+ * M1 只做 observe（不接入任何替换路径），所以这些组件只被读取与记账，
+ * 不改变 Worker/模型调用行为。
+ */
+import { createLedger } from "./ledger.js";
+import { createBudget } from "./budget.js";
+import { createPolicy } from "./policy.js";
+import { createAuditChain } from "./audit.js";
+import { createAttribution } from "./attribution.js";
+import { createCostBus } from "./bus.js";
+import { createHostSurfaceAdapter } from "./host-surface.js";
+import { buildSavingsReport, classifyEntry } from "./report.js";
+import { buildMetricsReport, METRIC_KEYS, SUCCESS_REGRESSION_PP } from "./metrics.js";
+import { MODULE_MANIFESTS, MODULE_IDS, validateManifests } from "./modules/manifests.js";
+import { buildLedgerReport, formatLedgerReport, parseLedgerJsonl } from "./ledger-report.js";
+import { buildToolFaceReport, planToolFace } from "./toolface.js";
+import { buildReuseReport, formatReuseReport } from "./reuse-report.js";
+export { createLedger, createBudget, createPolicy, createAuditChain, createAttribution, createCostBus, createHostSurfaceAdapter, buildSavingsReport, classifyEntry, buildMetricsReport, METRIC_KEYS, SUCCESS_REGRESSION_PP, MODULE_MANIFESTS, MODULE_IDS, validateManifests, buildLedgerReport, formatLedgerReport, parseLedgerJsonl, buildToolFaceReport, planToolFace, buildReuseReport, formatReuseReport };
+export * from "./types.js";
+/**
+ * @param {{
+ *   mode?: string, allowlist?: string[] | {forks?:string[],tasks?:string[],tags?:string[],tools?:string[]},
+ *   policyScopes?: {global?:string, forks?:Record<string,string>, tasks?:Record<string,string>},
+ *   budgetLimits?: Array<{unit:string, limitTokens?:number, limitCost?:number, onExhaust?:string, degradeTo?:string}>,
+ *   degradeModels?: string[],
+ *   now?: () => number, maxEntries?: number, maxRecords?: number,
+ * }} [options]
+ */
+export function createCostSystem(options = {}) {
+    const now = typeof options.now === 'function' ? options.now : () => Date.now();
+    const audit = createAuditChain({ now, maxRecords: options.maxRecords });
+    const policy = createPolicy({ mode: options.mode, allowlist: options.allowlist, scopes: options.policyScopes, audit, now });
+    const budget = createBudget({ limits: options.budgetLimits, degradeModels: options.degradeModels, now });
+    const ledger = createLedger({
+        now,
+        maxEntries: options.maxEntries,
+        dataDir: options.dataDir,
+        persist: options.persist === true,
+        logger: options.logger,
+    });
+    const attribution = createAttribution({ ledger, now });
+    const bus = createCostBus({ now, maxEvents: options.maxBusEvents, relays: options.relays });
+    /** 宿主会话工具面适配器（可选；默认关闭，不依赖任何第三方插件）。 */
+    const hostSurface = createHostSurfaceAdapter({
+        ledger,
+        bus,
+        enabled: options.hostSurface?.enabled === true,
+        source: options.hostSurface?.source,
+        now,
+    });
+    /** 模块降级累计（按模块聚合；不参与节省计算）。 */
+    const degradedByModule = new Map();
+    function recordUsage(input = {}) {
+        const out = ledger.append({
+            account: input.account ?? 'execution',
+            module: input.module,
+            source: input.source ?? 'model',
+            phase: input.phase,
+            surface: input.surface,
+            external: input.external,
+            taskId: input.taskId,
+            forkId: input.forkId,
+            sessionId: input.sessionId,
+            ticketId: input.ticketId,
+            turn: input.turn,
+            step: input.step,
+            provider: input.provider,
+            model: input.model,
+            toolName: input.toolName,
+            inputTokens: input.inputTokens,
+            outputTokens: input.outputTokens,
+            cachedTokens: input.cachedTokens,
+            totalTokens: input.totalTokens,
+            baselineTokens: input.baselineTokens,
+            savedTokens: input.savedTokens,
+            estimated: input.estimated,
+            meta: input.meta,
+        });
+        if (out.ok) {
+            bus.publish('cost:event', { kind: 'ledger',
+                id: out.entry.id,
+                account: out.entry.account,
+                module: out.entry.module,
+                phase: out.entry.phase,
+                surface: out.entry.surface,
+                total: out.entry.total,
+                savedTokens: out.entry.savedTokens,
+                taskId: out.entry.taskId,
+                estimated: out.entry.estimated,
+            });
+        }
+        return out;
+    }
+    /** 按维度查询账本（task/fork/session/module/account/phase/时间窗）。 */
+    function query(filter = {}) {
+        return ledger.query(filter);
+    }
+    /** 从 JSONL 回放（进程重启后恢复报表）。 */
+    function replay(direction = 'forward') {
+        return ledger.replay(direction);
+    }
+    /**
+     * §8 联动报表：A（单价下降）与 B（跳过调用）分列，governance 摊销后逐任务算净额，
+     * 净亏任务显式列出（不隐藏）。
+     */
+    function savingsReport(input = {}) {
+        const from = input.from === undefined ? undefined : Number(input.from);
+        const to = input.to === undefined ? undefined : Number(input.to);
+        const entries = ledger.query({ limit: Math.max(1, Number(input.limit ?? 5000) || 5000), ...(from === undefined ? {} : { from }), ...(to === undefined ? {} : { to }) }).entries;
+        const certificates = audit.substitutions({});
+        return buildSavingsReport({ entries, certificates, amortize: input.amortize });
+    }
+    function authorize(input = {}) {
+        const out = budget.authorize(input);
+        if (!out.ok) {
+            try {
+                audit.append({ type: 'budget.denied', actor: 'cost-budget', payload: { ...out } });
+            }
+            catch { /* ignore */ }
+            bus.publish('cost:event', { kind: 'budget.denied', ...out });
+        }
+        else if (out.degraded) {
+            try {
+                audit.append({ type: 'budget.degraded', actor: 'cost-budget', payload: { ...out } });
+            }
+            catch { /* ignore */ }
+            bus.publish('cost:event', { kind: 'budget.degraded', ...out });
+        }
+        else {
+            bus.publish('cost:event', { kind: 'budget.authorized', unit: out.unit, key: out.key, consumedTokens: out.consumedTokens, remainingTokens: out.remainingTokens });
+        }
+        return out;
+    }
+    /** 归因入口：enforce 写账本；shadow 只累计「本可节省」。 */
+    function attribute(input = {}) {
+        const out = attribution.attribute(input);
+        if (out.ok)
+            bus.publish('cost:event', { kind: 'attribution', mode: out.mode, module: out.module, savedTokens: out.savedTokens ?? 0, projectedTokens: out.projectedTokens ?? 0 });
+        return out;
+    }
+    /** §5.4：总额 − 各模块之和，差额进 unattributed（报表单列）。 */
+    function attributeTotal(input = {}) {
+        const out = attribution.attributeTotal(input);
+        if (out.ok)
+            bus.publish('cost:event', { kind: 'attribution.total', totalSavedTokens: out.totalSavedTokens, attributedTokens: out.attributedTokens, unattributedTokens: out.unattributedTokens });
+        return out;
+    }
+    /**
+     * §5.5：一次真实替换 = 证书 + 账本事件，两者共用 `taskId + step`。
+     * 任何一步失败都 fail-closed（不写半套）。
+     */
+    function substitute(cert = {}) {
+        const recorded = audit.appendSubstitution(cert);
+        if (!recorded.ok) {
+            bus.publish('cost:event', { kind: 'substitution.rejected', code: recorded.code, taskId: cert?.taskId ?? null });
+            return recorded;
+        }
+        let attributed = null;
+        if (Number(recorded.cert.savedTokens) > 0) {
+            attributed = attribution.attribute({
+                taskId: recorded.cert.taskId,
+                module: cert.moduleId ?? 'b3-ccs',
+                savedTokens: recorded.cert.savedTokens,
+                mode: 'enforce',
+                forkId: recorded.cert.forkId ?? undefined,
+                sessionId: recorded.cert.sessionId ?? undefined,
+                step: recorded.cert.step,
+                meta: { kind: 'substitution', step: recorded.cert.step, edgeId: recorded.cert.edgeId, replacedCallbackId: recorded.cert.replacedCallbackId },
+            });
+            if (!attributed.ok)
+                return attributed;
+        }
+        bus.publish('cost:substitution', {
+            taskId: recorded.cert.taskId,
+            step: recorded.cert.step,
+            edgeId: recorded.cert.edgeId,
+            toolName: recorded.cert.toolName,
+            savedTokens: recorded.cert.savedTokens,
+        });
+        return { ok: true, cert: recorded.cert, attribution: attributed, hash: recorded.record.hash };
+    }
+    /**
+     * §5.5：回放「这一省是怎么来的」——按 `taskId + step` 取出证书与账本事件。
+     */
+    function trace({ taskId, step } = {}) {
+        if (taskId === undefined || String(taskId).trim() === '') {
+            return { ok: false, code: 'task-missing', message: 'trace requires taskId' };
+        }
+        const filter = { taskId };
+        if (step !== undefined)
+            filter.step = step;
+        const certificates = audit.substitutions(filter);
+        const entries = ledger.query({ taskId, limit: 500 }).entries
+            .filter((entry) => (step === undefined ? true : entry.step === Number(step)));
+        const savedFromCerts = certificates.reduce((sum, cert) => sum + Number(cert.savedTokens ?? 0), 0);
+        // 对账只比「替换产生的账本事件」：其它节省（A1 压缩等）不属于证书口径。
+        const substitutionEntries = entries.filter((entry) => entry.meta?.kind === 'substitution');
+        const savedFromLedger = substitutionEntries.reduce((sum, entry) => sum + entry.savedTokens, 0);
+        const savedFromLedgerAll = entries.reduce((sum, entry) => sum + entry.savedTokens, 0);
+        return Object.freeze({
+            ok: true,
+            taskId: String(taskId),
+            step: step === undefined ? null : Number(step),
+            certificates,
+            entries,
+            /** 两边对账：证书声明的节省应等于**替换账本**记到的节省。 */
+            savedFromCertificates: savedFromCerts,
+            savedFromLedger,
+            /** 任务全部节省（含 A1 等非替换来源），仅展示，不参与对账。 */
+            savedFromLedgerAll,
+            reconciled: savedFromCerts === savedFromLedger,
+        });
+    }
+    /**
+     * 降级留痕（目标 2.1-5）：模块异常 → 审计链 + 事件总线 + 计数。
+     * 降级**不计入任何节省**，只用于让报表能区分「真的省了」与「模块挂了」。
+     */
+    function degraded(input = {}) {
+        const module = String(input.module ?? 'unknown');
+        const phase = String(input.phase ?? 'transform');
+        const message = String(input.message ?? '');
+        const count = Math.max(1, Number(input.count ?? 1) || 1);
+        const at = now();
+        const totals = degradedByModule.get(module) ?? { module, events: 0, occurrences: 0, lastAt: 0, phases: {} };
+        totals.events += 1;
+        totals.occurrences += count;
+        totals.lastAt = at;
+        totals.phases[phase] = (totals.phases[phase] ?? 0) + count;
+        degradedByModule.set(module, totals);
+        try {
+            audit.append({ type: 'cost.degraded', actor: 'cost-system', payload: { module, phase, message, count, taskId: input.taskId ?? null } });
+        }
+        catch { /* ignore */ }
+        bus.publish('cost:degraded', { module, phase, message, count, taskId: input.taskId ?? null });
+        return { ok: true, module, phase, count, total: { ...totals, phases: { ...totals.phases } }, at };
+    }
+    /**
+     * §10.1 验收指标：七项必须给全；缺项显式报 `complete:false + missing[]`。
+     * 传入 `tasks` / `control` / `guard` / `traceCheck` 才能算出对照与回放检查。
+     */
+    function metrics(input = {}) {
+        const entries = ledger.query({ limit: Math.max(1, Number(input.limit ?? 5000) || 5000) }).entries;
+        const certificates = audit.substitutions({});
+        return buildMetricsReport({
+            entries,
+            certificates,
+            tasks: input.tasks,
+            control: input.control,
+            guard: input.guard,
+            audit: { ok: audit.verify().ok },
+            traceCheck: typeof input.traceCheck === 'function' ? input.traceCheck : (taskId) => trace({ taskId }),
+        });
+    }
+    /**
+     * M1 交付物：记账报表（估算/实测分列、两本账不合并、外部面单列、unattributed 留位）。
+     */
+    function ledgerReport(input = {}) {
+        const entries = ledger.query({ limit: Math.max(1, Number(input.limit ?? 5000) || 5000), ...(input.from === undefined ? {} : { from: Number(input.from) }), ...(input.to === undefined ? {} : { to: Number(input.to) }) }).entries;
+        return buildLedgerReport({ entries, from: input.from, to: input.to, bucketMs: input.bucketMs });
+    }
+    function subscribe(listener) {
+        return bus.subscribe(listener);
+    }
+    function status() {
+        const ledgerSnapshot = ledger.snapshot();
+        const auditVerify = audit.verify();
+        const attributionSnapshot = attribution.snapshot();
+        const busSnapshot = bus.snapshot(1);
+        return Object.freeze({
+            ok: true,
+            mode: policy.describe().mode,
+            policy: policy.describe(),
+            /** 三档命中统计（observe 也计数；shadow 落证书；enforce 才替换）。 */
+            policyStats: policy.stats(),
+            ledger: ledgerSnapshot,
+            budget: budget.state(),
+            audit: { ok: auditVerify.ok, count: auditVerify.count, brokenAt: auditVerify.brokenAt },
+            attribution: attributionSnapshot,
+            /* §5.4：模块收益与未归因收益**分开列**，未归因永不算模块业绩。 */
+            attributionSummary: {
+                attributedSavedTotal: attributionSnapshot.attributedSavedTotal,
+                unattributedSavedTotal: attributionSnapshot.unattributedSavedTotal,
+                attributedProjectedTotal: attributionSnapshot.attributedProjectedTotal,
+                unattributedProjectedTotal: attributionSnapshot.unattributedProjectedTotal,
+            },
+            bus: { count: busSnapshot.count, dropped: busSnapshot.dropped, subscribers: busSnapshot.subscribers, relays: busSnapshot.relays },
+            degraded: {
+                modules: [...degradedByModule.values()].map((item) => ({ ...item, phases: { ...item.phases } })),
+                occurrences: [...degradedByModule.values()].reduce((sum, item) => sum + item.occurrences, 0),
+            },
+            /* 报表口径：只把本项目 worker 面的 execution.saved 当节省；governance 与外部适配器并列。 */
+            savings: {
+                executionSaved: ledgerSnapshot.ownExecutionSaved,
+                governanceCost: ledgerSnapshot.governance.total,
+                netSaved: ledgerSnapshot.netSaved,
+                /** 外部（宿主面）插件自报：仅对照，不计入上面的任何数字。 */
+                externalSaved: ledgerSnapshot.externalSaved,
+            },
+            /** 估算 token 与实测 token 分列（不混算）。 */
+            tokens: ledgerSnapshot.tokens,
+            surfaces: ledgerSnapshot.bySurface,
+            hostSurface: hostSurface.status(),
+        });
+    }
+    return Object.freeze({ ledger, budget, policy, audit, attribution, bus, hostSurface, recordUsage, authorize, attribute, attributeTotal, substitute, trace, degraded, query, replay, savingsReport, metrics, ledgerReport, subscribe, status });
+}

package/dist-host/cost/ledger-report.js

@@ -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 · M1 记账报表（`ledger-report`）。
+ *
+ * 交付物「记账报表」的实体：把账本事件整理成**可读、可核对**的报表，
+ * 并且遵守前几节定下的口径纪律：
+ *
+ *   * **估算 ≠ 实测**：两列分开给，`estimatedRatio` 显式展示，不混算；
+ *   * **两本账不合并**：execution 与 governance 分账，`netSaved` 只在能对上时给；
+ *   * **外部面单列**：宿主面外部插件自报收益永不并入本项目节省；
+ *   * **unattributed 必须留位**：归因缺口显式展示为 0 或非 0，不允许"消失"；
+ *   * **非法行不入账**：JSONL 里坏行跳过并计数，不静默丢弃也不假装成功。
+ */
+import { COST_MODULES, COST_PHASES, COST_SURFACES } from "./types.js";
+const num = (value) => {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+};
+const nonNegative = (value) => Math.max(0, num(value));
+/**
+ * 解析落盘的 JSONL 账本（`cost-ledger.jsonl`，逐行追加）。
+ * 坏行跳过并计数 —— 报表必须能说明"有多少行没读进来"。
+ * @param {string} text
+ */
+export function parseLedgerJsonl(text) {
+    const entries = [];
+    let skipped = 0;
+    for (const line of String(text ?? '').split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && (parsed.account === 'execution' || parsed.account === 'governance'))
+                entries.push(parsed);
+            else
+                skipped += 1;
+        }
+        catch {
+            skipped += 1;
+        }
+    }
+    return { entries, skipped };
+}
+const emptyRow = () => ({ entries: 0, inputTokens: 0, outputTokens: 0, total: 0, savedTokens: 0, estimated: false });
+function addTo(map, key, entry) {
+    if (!map.has(key))
+        map.set(key, { ...emptyRow(), key });
+    const row = map.get(key);
+    row.entries += 1;
+    row.inputTokens += nonNegative(entry.inputTokens);
+    row.outputTokens += nonNegative(entry.outputTokens);
+    row.total += nonNegative(entry.total);
+    row.savedTokens += nonNegative(entry.savedTokens);
+    if (entry.estimated === true)
+        row.estimated = true;
+    return row;
+}
+/**
+ * 记账报表。
+ *
+ * @param {{
+ *   entries?: object[],
+ *   from?: number,
+ *   to?: number,
+ *   bucketMs?: number,
+ * }} [input]
+ */
+export function buildLedgerReport(input = {}) {
+    const from = Number.isFinite(Number(input.from)) ? Number(input.from) : null;
+    const to = Number.isFinite(Number(input.to)) ? Number(input.to) : null;
+    const bucketMs = Math.max(1, Number(input.bucketMs ?? 60 * 60 * 1000) || 60 * 60 * 1000);
+    const raw = Array.isArray(input.entries) ? input.entries : [];
+    const byPhase = new Map();
+    const byModule = new Map();
+    const byTask = new Map();
+    const bySurface = new Map();
+    const accounts = {
+        execution: { entries: 0, total: 0, savedTokens: 0 },
+        governance: { entries: 0, total: 0, savedTokens: 0 },
+    };
+    const tokens = { measuredTokens: 0, estimatedTokens: 0, inputTokens: 0, outputTokens: 0 };
+    const buckets = new Map();
+    let ownExecutionSaved = 0;
+    let externalSaved = 0;
+    let filtered = 0;
+    let invalid = 0;
+    for (const entry of raw) {
+        if (!entry || (entry.account !== 'execution' && entry.account !== 'governance')) {
+            invalid += 1;
+            continue;
+        }
+        const at = num(entry.at);
+        if (from !== null && at < from) {
+            filtered += 1;
+            continue;
+        }
+        if (to !== null && at > to) {
+            filtered += 1;
+            continue;
+        }
+        const account = accounts[entry.account];
+        account.entries += 1;
+        account.total += nonNegative(entry.total);
+        const total = nonNegative(entry.total);
+        const saved = nonNegative(entry.savedTokens);
+        if (entry.estimated === true)
+            tokens.estimatedTokens += total;
+        else
+            tokens.measuredTokens += total;
+        tokens.inputTokens += nonNegative(entry.inputTokens);
+        tokens.outputTokens += nonNegative(entry.outputTokens);
+        if (entry.account === 'execution' && saved > 0) {
+            if (entry.external === true)
+                externalSaved += saved;
+            else
+                ownExecutionSaved += saved;
+        }
+        account.savedTokens += saved;
+        addTo(byPhase, String(entry.phase ?? 'unknown'), entry);
+        addTo(byModule, String(entry.module ?? 'unattributed'), entry);
+        addTo(byTask, String(entry.taskId ?? 'unattributed'), entry);
+        addTo(bySurface, String(entry.surface ?? 'worker'), entry);
+        const bucketKey = Math.floor(at / bucketMs) * bucketMs;
+        if (!buckets.has(bucketKey))
+            buckets.set(bucketKey, { at: bucketKey, entries: 0, total: 0, savedTokens: 0, estimatedTokens: 0 });
+        const bucket = buckets.get(bucketKey);
+        bucket.entries += 1;
+        bucket.total += total;
+        bucket.savedTokens += saved;
+        if (entry.estimated === true)
+            bucket.estimatedTokens += total;
+    }
+    // 固定列：模块与相位都按枚举铺满，缺的给 0（报表要能一眼看出"这一项是 0"而不是"没这一列"）
+    const phaseRows = COST_PHASES.map((phase) => byPhase.get(phase) ?? { ...emptyRow(), key: phase });
+    const moduleRows = COST_MODULES.map((module) => byModule.get(module) ?? { ...emptyRow(), key: module });
+    const surfaceRows = COST_SURFACES.map((surface) => bySurface.get(surface) ?? { ...emptyRow(), key: surface });
+    const taskRows = [...byTask.values()].sort((a, b) => b.total - a.total || a.key.localeCompare(b.key));
+    const allTokens = tokens.measuredTokens + tokens.estimatedTokens;
+    return Object.freeze({
+        ok: true,
+        window: Object.freeze({ from, to, bucketMs }),
+        counts: Object.freeze({ entries: accounts.execution.entries + accounts.governance.entries, invalid, filtered }),
+        accounts: Object.freeze({
+            execution: Object.freeze({ ...accounts.execution }),
+            governance: Object.freeze({ ...accounts.governance }),
+            /** 两本账相减只在 execution 为「本项目（非外部）」口径时成立。 */
+            netSaved: ownExecutionSaved - accounts.governance.total,
+        }),
+        tokens: Object.freeze({ ...tokens, estimatedRatio: allTokens > 0 ? tokens.estimatedTokens / allTokens : 0 }),
+        savings: Object.freeze({
+            ownExecutionSaved,
+            /** 外部面收益：只展示，不计入本项目净节省。 */
+            externalSaved,
+        }),
+        byPhase: Object.freeze(phaseRows.map((row) => Object.freeze(row))),
+        byModule: Object.freeze(moduleRows.map((row) => Object.freeze(row))),
+        bySurface: Object.freeze(surfaceRows.map((row) => Object.freeze(row))),
+        byTask: Object.freeze(taskRows.map((row) => Object.freeze(row))),
+        timeline: Object.freeze([...buckets.values()].sort((a, b) => a.at - b.at).map((row) => Object.freeze(row))),
+        /** 记账口径声明，供报表阅读者核对（写进报表而不是只写在文档里）。 */
+        discipline: Object.freeze({
+            estimatedAndMeasuredSeparated: true,
+            accountsNotMerged: true,
+            externalNeverSummed: true,
+            unattributedAlwaysListed: true,
+        }),
+    });
+}
+/** 人读行（CLI / 面板共用，避免两处格式分叉）。 */
+export function formatLedgerReport(report) {
+    const lines = [];
+    lines.push(`记账报表  窗口 ${report.window.from ?? '-'} → ${report.window.to ?? '-'}`);
+    lines.push(`事件 ${report.counts.entries} 条（非法 ${report.counts.invalid}，被窗口过滤 ${report.counts.filtered}）`);
+    lines.push('');
+    lines.push('账本            条数      token      节省');
+    for (const [name, row] of Object.entries(report.accounts)) {
+        if (name === 'netSaved')
+            continue;
+        lines.push(`${name.padEnd(14)} ${String(row.entries).padEnd(8)} ${String(row.total).padEnd(10)} ${row.savedTokens}`);
+    }
+    lines.push(`净节省（本项目） ${report.accounts.netSaved}`);
+    lines.push(`外部面收益（不并入） ${report.savings.externalSaved}`);
+    lines.push('');
+    lines.push(`估算占比 ${(report.tokens.estimatedRatio * 100).toFixed(1)}%（实测 ${report.tokens.measuredTokens} / 估算 ${report.tokens.estimatedTokens}）`);
+    lines.push('');
+    lines.push('按模块             token     节省');
+    for (const row of report.byModule)
+        lines.push(`${row.key.padEnd(16)} ${String(row.total).padEnd(10)} ${row.savedTokens}`);
+    return lines.join('\n');
+}