@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.27

package/dist/scripts/nightly-evidence-tests.js

@@ -0,0 +1,161 @@
+/**
+ * M3 nightly 证据生产器合同测试(run-all §35,issue #22 验收⑥「nightly real-LLM 与成本质量证据可复跑」)。
+ * 全确定性、零网络、零 API 花费:
+ *   - 封存价表仅可审计换算(peak 保守上界),未知模型 fail-closed,usage 缺失 fail-closed;
+ *   - run_key 确定性 + 记录必须过消费方 parseNightlyRun(生产器写的就是评分器读的);
+ *   - 无凭证 = waiting_external_evidence,不写任何文件(issue #22 停机纪律);
+ *   - --dry-run mock 全链演练可跑通且绝不落盘。
+ * 真跑(花钱)不在 CI:heartbeat/founder 手动 `npx tsx scripts/nightly-evidence.ts`。
+ *
+ * 价表 schema 演进(issue #49):v1 (legacy DeepSeek only) / v2 (provider-aware;DeepSeek+MiniMax);
+ *   本测试在 v2 形态下覆盖:DeepSeek alias、裸模型名、MiniMax 跨 provider 命中、跨 provider 守门、
+ *   MiniMax flat_no_offpeak 纪律同价守门、未声明 schema_version 拒绝、unknown model fail-closed、
+ *   usage 缺失 fail-closed、run_key 确定性 + 消费方 parseNightlyRun、无凭证 waiting、dry-run 零落盘。
+ */
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { buildNightlyRunRecord, loadPriceTable, loadPromptSet, priceRunCost, runNightlyEvidence, } from './nightly-evidence.js';
+import { parseNightlyRun } from './product-metrics.js';
+let passed = 0;
+function ok(label) {
+    passed += 1;
+    console.log(`  ok ${label}`);
+}
+// ---- 1. 封存文件可加载,schema v2 + provider-aware alias/裸模型双查找(以仓库内真正随发的数据文件为夹具) ----
+const priceTable = loadPriceTable('data/llm-price-table.json');
+const promptSet = loadPromptSet('data/m3-nightly-prompts.json');
+assert.equal(priceTable.schema_version, 'gotry_llm_price_table_v2');
+assert.equal(promptSet.schema_version, 'gotry_m3_nightly_prompt_set_v1');
+assert.ok(promptSet.turns.length >= 1);
+assert.ok(priceTable.prices['deepseek-v4-flash'], '裸键 deepseek-v4-flash 必须可查');
+assert.ok(priceTable.prices['MiniMax-M3'], '裸键 MiniMax-M3 必须可查(provider 为单一时透明)');
+assert.ok(priceTable.prices['minimax:MiniMax-M3'], 'qualified 键 minimax:MiniMax-M3 必须可查');
+assert.ok(priceTable.aliases['deepseek-chat'], 'deepseek-chat 必须在 aliases 表');
+assert.equal(priceTable.aliases['deepseek-chat'], 'deepseek-v4-flash');
+ok('v2 schema 载入 + 裸键 + qualified 键 + alias 双查找');
+// ---- 2. 保守上界不变量:每个价目 hit<=miss 且 offpeak<=peak(只高不低) ----
+for (const [name, entry] of Object.entries(priceTable.prices)) {
+    assert.ok(entry.input_cache_hit_usd_per_1m_peak <= entry.input_cache_miss_usd_per_1m_peak, `${name} hit<=miss`);
+    assert.ok(entry.output_usd_per_1m_offpeak <= entry.output_usd_per_1m_peak, `${name} offpeak<=peak`);
+}
+ok('价目保守上界不变量(hit<=miss, offpeak<=peak)');
+// ---- 3. 换算数学:deepseek-chat -> v4-flash peak(miss 1M + 1M out = 1.76) ----
+const baseUsage = {
+    calls: 3,
+    inputTokens: 1_000_000,
+    outputTokens: 1_000_000,
+    inputCacheHitTokens: 0,
+    inputCacheMissTokens: 1_000_000,
+    responsesMissingUsage: 0,
+};
+const cost = priceRunCost('deepseek-chat', baseUsage, priceTable);
+assert.equal(cost, 1.76); // 0.44 + 1.32
+ok('peak miss 换算 0.44+1.32=1.76(经 alias)');
+const hitUsage = { ...baseUsage, inputCacheHitTokens: 1_000_000, inputCacheMissTokens: 0 };
+assert.equal(priceRunCost('deepseek-chat', hitUsage, priceTable), 1.334); // 0.014+1.32
+ok('peak hit 换算 0.014+1.32=1.334');
+// ---- 3b. MiniMax-M3 peak 换算(issue #49 验收):miss 1M + 1M out = 3.00(0.60+2.40,ADR-11 保守上界) ----
+const m3cost = priceRunCost('MiniMax-M3', baseUsage, priceTable);
+assert.equal(m3cost, 3.00); // 0.60 + 2.40
+ok('MiniMax-M3 peak miss 换算 0.60+2.40=3.00');
+const m3hit = priceRunCost('MiniMax-M3', hitUsage, priceTable);
+assert.equal(m3hit, 2.52); // 0.12+2.40
+ok('MiniMax-M3 peak hit 换算 0.12+2.40=2.52');
+// ---- 3c. MiniMax flat_no_offpeak 纪律:peak 与 offpeak 列同价 —— 给定用量下两种策略产出同一价格 ----
+const m3prov = priceTable.prices['minimax:MiniMax-M3'];
+assert.equal(m3prov.input_cache_miss_usd_per_1m_peak, m3prov.input_cache_miss_usd_per_1m_offpeak, 'MiniMax-M3 flat 纪律:peak==offpeak miss');
+assert.equal(m3prov.input_cache_hit_usd_per_1m_peak, m3prov.input_cache_hit_usd_per_1m_offpeak, 'MiniMax-M3 flat 纪律:peak==offpeak hit');
+assert.equal(m3prov.output_usd_per_1m_peak, m3prov.output_usd_per_1m_offpeak, 'MiniMax-M3 flat 纪律:peak==offpeak output');
+ok('MiniMax flat_no_offpeak 纪律同价守门');
+// ---- 3d. issue #49 验收:人为改一个不存在的模型名 → 仍 fail-closed(waiting/error,不猜价) ----
+assert.throws(() => priceRunCost('unknown-model-xyz', baseUsage, priceTable), /no entry for model/);
+ok('未知模型名 → fail-closed');
+// ---- 4. fail-closed:未知模型 / alias 悬空 / usage 缺失 / 非法 schema_version 都不许出现价格 ----
+const dangling = { ...priceTable, aliases: { 'deepseek-chat': 'not-a-model' } };
+assert.throws(() => priceRunCost('deepseek-chat', baseUsage, dangling), /has no entry/);
+assert.throws(() => priceRunCost('deepseek-chat', { ...baseUsage, responsesMissingUsage: 1 }, priceTable), /cost unprovable/);
+// 非法 schema_version 守门(写入 tmp 后用 loadPriceTable 加载应抛错)
+const tmpSchemaDir = mkdtempSync(join(tmpdir(), 'nightly-bad-schema-'));
+const badSchemaPath = join(tmpSchemaDir, 'bad.json');
+try {
+    writeFileSync(badSchemaPath, JSON.stringify({ schema_version: 'gotry_llm_price_table_v99', prices: {} }));
+    assert.throws(() => loadPriceTable(badSchemaPath), /schema_version must be/);
+    ok('非法 schema_version 拒绝');
+}
+finally {
+    rmSync(tmpSchemaDir, { recursive: true, force: true });
+}
+// 非法 provider price_strategy 守门(在 v2 表写入非法策略应抛错)
+const tmpStrategyDir = mkdtempSync(join(tmpdir(), 'nightly-bad-strategy-'));
+const badStrategyPath = join(tmpStrategyDir, 'bad.json');
+try {
+    writeFileSync(badStrategyPath, JSON.stringify({
+        schema_version: 'gotry_llm_price_table_v2',
+        providers: {
+            bad: { family: 'x', price_strategy: 'mystery_strategy', aliases: {}, models: { 'm': { input_cache_miss_usd_per_1m_peak: 0.1, input_cache_hit_usd_per_1m_peak: 0.01, output_usd_per_1m_peak: 0.5, input_cache_miss_usd_per_1m_offpeak: 0.1, input_cache_hit_usd_per_1m_offpeak: 0.01, output_usd_per_1m_offpeak: 0.5 } } },
+        },
+    }));
+    assert.throws(() => loadPriceTable(badStrategyPath), /price_strategy must be/);
+    ok('v2 非法 price_strategy 拒绝');
+}
+finally {
+    rmSync(tmpStrategyDir, { recursive: true, force: true });
+}
+ok('未知模型/悬空alias/usage缺失 fail-closed');
+// ---- 5. run_key 确定性 + 消费方合同 ----
+const executeAt = '2026-08-29T12:00:00.000Z';
+const recordInput = {
+    schema_version: 'gotry_m3_nightly_run_v1',
+    executed_at: executeAt,
+    real_llm: true,
+    prompt_set_sha256: 'a'.repeat(64),
+    output_sha256: 'b'.repeat(64),
+    cost_usd: 0.25,
+};
+const rec1 = buildNightlyRunRecord(recordInput);
+const rec2 = buildNightlyRunRecord({ ...recordInput });
+assert.equal(rec1.run_key, rec2.run_key);
+assert.match(rec1.run_key, /^hmac-sha256:[0-9a-f]{64}$/);
+parseNightlyRun(JSON.parse(JSON.stringify(rec1)), 0);
+const rec3 = buildNightlyRunRecord({ ...recordInput, cost_usd: 0.26 });
+assert.notEqual(rec3.run_key, rec1.run_key);
+ok('run_key 确定性 + 已过消费方 parseNightlyRun');
+// ---- 6. 无凭证 = waiting_external_evidence,零写入(evidence root 自身也不得被创建) ----
+const prevKey = process.env['LLM_API_KEY'];
+const prevDeepseekKey = process.env['DEEPSEEK_API_KEY'];
+const waitParent = mkdtempSync(join(tmpdir(), 'nightly-wait-'));
+const waitRoot = join(waitParent, 'evidence', 'm3');
+try {
+    delete process.env['LLM_API_KEY'];
+    delete process.env['DEEPSEEK_API_KEY'];
+    const waiting = await runNightlyEvidence({ evidenceRoot: waitRoot, dryRun: false, clock: () => new Date(executeAt) });
+    assert.equal(waiting.state, 'waiting_external_evidence');
+    assert.equal(waiting.record, null);
+    assert.ok(waiting.reason?.includes('backoff'));
+    assert.equal(existsSync(waitRoot), false, 'waiting 不得创建任何证据目录');
+}
+finally {
+    if (prevKey !== undefined)
+        process.env['LLM_API_KEY'] = prevKey;
+    if (prevDeepseekKey !== undefined)
+        process.env['DEEPSEEK_API_KEY'] = prevDeepseekKey;
+    rmSync(waitParent, { recursive: true, force: true });
+}
+ok('无凭证 → waiting_external_evidence 且零写入');
+// ---- 7. dry-run:mock 全链演练,记录为 real_llm=false 且绝不落盘 ----
+const dryParent = mkdtempSync(join(tmpdir(), 'nightly-dry-'));
+const dryRoot = join(dryParent, 'evidence', 'm3');
+try {
+    const dry = await runNightlyEvidence({ evidenceRoot: dryRoot, dryRun: true, clock: () => new Date(executeAt) });
+    assert.equal(dry.state, 'dry_run');
+    assert.equal(dry.record?.real_llm, false);
+    parseNightlyRun(JSON.parse(JSON.stringify(dry.record)), 0);
+    assert.equal(existsSync(dryRoot), false, 'dry-run 不得写任何证据文件');
+}
+finally {
+    rmSync(dryParent, { recursive: true, force: true });
+}
+ok('dry-run mock 全链演练 + real_llm=false + 零落盘');
+console.log(`nightly-evidence tests: ${passed} 组断言全绿(offline,真跑不在 CI)`);

package/dist/scripts/nightly-evidence.js

@@ -0,0 +1,286 @@
+/**
+ * M3 nightly real-LLM 证据生产器(issue #22 验收「nightly real-LLM 与成本质量证据可复跑」)。
+ * ADR-11 巡检层的 nightly 形态:固定 prompt 集 × 真实 LLM,产出被 product-metrics.ts
+ * 消费的 `gotry_m3_nightly_run_v1` 记录,追加进私有证据账本 gotry-state/evidence/m3/cohort.jsonl
+ * (gitignored;绝不写真实产品状态 ts/dsh-runtime/gotry-state/)。
+ *
+ * 运行(在 ts/ 下):
+ *   npx tsx scripts/nightly-evidence.ts                  # 真跑:需 LLM_API_KEY,追加证据记录
+ *   npx tsx scripts/nightly-evidence.ts --dry-run        # mock 全链演练,绝不写证据
+ *   npx tsx scripts/nightly-evidence.ts --format json    # 机器可读状态(heartbeat 消费)
+ *   npx tsx scripts/nightly-evidence.ts --no-env-file    # 不读仓根 .env(等待态测试用)
+ *
+ * 纪律:
+ *   - 无凭证 = waiting_external_evidence + backoff/no-spend:退出码 0,状态 JSON 明示,不写任何文件。
+ *   - cost_usd 只能来自 dsh-llm 实测 usage × `data/llm-price-table.json` 封存价(peak 保守上界);
+ *     usage 缺失/模型无价目 = fail-closed,不写记录、不猜价格;价目调整走 PR 改封存文件。
+ *   - prompt_set_sha256 锚定 `data/m3-nightly-prompts.json` 内容;output_sha256 锚定本轮对话全文。
+ *   - 预算闸 GOTRY_NIGHTLY_BUDGET_USD(默认 1.00 美元):超闸时记录照写(已发生的花费是事实),
+ *     但退出码 3,heartbeat 应 backoff。
+ *   - 写入前先过消费方 parseNightlyRun 校验——生产器自己写出的必须是评分器读得懂的记录。
+ *
+ * 价表 schema 演进(issue #49 落地):
+ *   - `gotry_llm_price_table_v1`:仅 DeepSeek,flat 字段直接挂在 prices.<model> 下,本 loader 兼容读取。
+ *   - `gotry_llm_price_table_v2`(本仓现状):providers.<id>.models.<model>,provider-aware。
+ *     v2 引入 provider 别名/价格策略(tiered_peak_offpeak vs flat_no_offpeak),允许 MiniMax/等
+ *     没有 off-peak 列的 provider 以同价占位填入 _offpeak 列(peak_conservative_upper_bound 纪律)。
+ *   - reader 兼容 v1/v2:loadPriceTable 检测 schema_version;v1 走旧 PriceEntry 形态,v2 走
+ *     ProviderEntry 形态;priceRunCost 与外暴露 API 不变。
+ */
+import { createHash } from 'node:crypto';
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createMockLlm } from '../src/mock-llm.js';
+import { createOpenAICompatLlm } from '../src/dsh-llm.js';
+import { newState, runTurn } from '../src/loop.js';
+import { solveUnified } from '../src/unified.js';
+import { realtimeSolvePort } from '../src/realtime-pricing.js';
+import { parseNightlyRun } from './product-metrics.js';
+const SHA256 = /^[0-9a-f]{64}$/;
+const DEFAULT_BUDGET_USD = 1;
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (typeof value === 'object' && value !== null) {
+        const record = value;
+        return `{${Object.keys(record).sort().map(key => `${JSON.stringify(key)}:${canonical(record[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function sha256Of(value) {
+    return createHash('sha256').update(canonical(value)).digest('hex');
+}
+function round6(value) {
+    return Number(value.toFixed(6));
+}
+export function loadPromptSet(path) {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    if (raw['schema_version'] !== 'gotry_m3_nightly_prompt_set_v1') {
+        throw new Error(`prompt set schema_version must be gotry_m3_nightly_prompt_set_v1, got: ${String(raw['schema_version'])}`);
+    }
+    const turns = raw['turns'];
+    if (!Array.isArray(turns) || turns.length === 0 || turns.some(t => typeof t !== 'string' || t.length === 0)) {
+        throw new Error('prompt set turns must be a non-empty array of non-empty strings');
+    }
+    return { schema_version: 'gotry_m3_nightly_prompt_set_v1', description: raw['description'], turns: turns };
+}
+function assertPriceEntry(label, value) {
+    const entry = typeof value === 'object' && value !== null ? value : null;
+    if (!entry)
+        throw new Error(`${label} must be an object`);
+    for (const field of ['input_cache_miss_usd_per_1m_peak', 'input_cache_hit_usd_per_1m_peak', 'output_usd_per_1m_peak']) {
+        const num = entry[field];
+        if (typeof num !== 'number' || !Number.isFinite(num) || num < 0) {
+            throw new Error(`${label}.${field} must be a non-negative finite number`);
+        }
+    }
+    return value;
+}
+export function loadPriceTable(path) {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    const schemaVersion = raw['schema_version'];
+    if (schemaVersion === 'gotry_llm_price_table_v2') {
+        return loadPriceTableV2(raw);
+    }
+    if (schemaVersion === 'gotry_llm_price_table_v1') {
+        return loadPriceTableV1(raw);
+    }
+    throw new Error(`price table schema_version must be gotry_llm_price_table_v1 or _v2, got: ${String(schemaVersion)}`);
+}
+function loadPriceTableV1(raw) {
+    const aliases = typeof raw['aliases'] === 'object' && raw['aliases'] !== null ? raw['aliases'] : {};
+    for (const [from, to] of Object.entries(aliases)) {
+        if (typeof to !== 'string')
+            throw new Error(`price table alias ${from} must map to a model name`);
+    }
+    const prices = {};
+    for (const [name, entry] of Object.entries(typeof raw['prices'] === 'object' && raw['prices'] !== null ? raw['prices'] : {})) {
+        prices[name] = assertPriceEntry(`price table entry ${name}`, entry);
+    }
+    return { schema_version: 'gotry_llm_price_table_v1', aliases, prices };
+}
+/** v2 reader:providers.<id>.models.<model> 平铺为统一的 aliases/prices 双表,外暴露 API 不变。
+ *  lookup 规则:给定 model 名 →
+ *    1. 若在 aliases 表中,跳到别名目标(qualified `providerId:model`);
+ *    2. 否则直接以 qualified `providerId:model` 在 prices 中查找;
+ *    3. 否则尝试裸 `model` 键(单 provider 时透明,如 MiniMax-M3 在 minimax:models 下唯一);
+ *    4. 仍找不到 → fail-closed。 */
+function loadPriceTableV2(raw) {
+    const providersObj = typeof raw['providers'] === 'object' && raw['providers'] !== null ? raw['providers'] : null;
+    if (!providersObj)
+        throw new Error('price table v2 requires providers object');
+    const aliases = {};
+    const prices = {};
+    for (const [providerId, rawProvider] of Object.entries(providersObj)) {
+        const provider = assertProviderEntry(`price table provider ${providerId}`, rawProvider);
+        for (const [aliasName, target] of Object.entries(provider.aliases)) {
+            if (typeof target !== 'string')
+                throw new Error(`provider ${providerId} alias ${aliasName} must map to a model name`);
+            if (!provider.models[target]) {
+                throw new Error(`provider ${providerId} alias ${aliasName} -> ${target} has no entry; update data/llm-price-table.json via PR`);
+            }
+            aliases[aliasName] = target;
+        }
+        for (const [modelName, entry] of Object.entries(provider.models)) {
+            const qualified = `${providerId}:${modelName}`;
+            const validated = assertPriceEntry(`price table provider ${providerId} model ${modelName}`, entry);
+            if (prices[qualified])
+                throw new Error(`duplicate price table key ${qualified}`);
+            prices[qualified] = validated;
+            if (prices[modelName])
+                throw new Error(`duplicate price table key ${modelName} (across providers, disambiguate via aliases or qualified lookup)`);
+            prices[modelName] = validated;
+        }
+    }
+    return { schema_version: 'gotry_llm_price_table_v2', aliases, prices };
+}
+function assertProviderEntry(label, value) {
+    const entry = typeof value === 'object' && value !== null ? value : null;
+    if (!entry)
+        throw new Error(`${label} must be an object`);
+    const family = entry['family'];
+    if (typeof family !== 'string' || family.length === 0)
+        throw new Error(`${label}.family must be a non-empty string`);
+    const strategy = entry['price_strategy'];
+    if (strategy !== 'tiered_peak_offpeak' && strategy !== 'flat_no_offpeak') {
+        throw new Error(`${label}.price_strategy must be 'tiered_peak_offpeak' or 'flat_no_offpeak', got: ${String(strategy)}`);
+    }
+    const aliases = typeof entry['aliases'] === 'object' && entry['aliases'] !== null ? entry['aliases'] : {};
+    const models = typeof entry['models'] === 'object' && entry['models'] !== null ? entry['models'] : {};
+    return {
+        family,
+        price_strategy: strategy,
+        api_base: typeof entry['api_base'] === 'string' ? entry['api_base'] : undefined,
+        source_url: typeof entry['source_url'] === 'string' ? entry['source_url'] : undefined,
+        aliases,
+        models,
+    };
+}
+/** 换算单次运行成本(peak 保守上界:全部输入按 cache miss 峰价计,只高不低)。 */
+export function priceRunCost(model, usage, table) {
+    if (usage.responsesMissingUsage > 0) {
+        throw new Error(`usage provider omitted usage on ${usage.responsesMissingUsage} response(s) — cost unprovable, refusing to price (fail-closed)`);
+    }
+    const alias = table.aliases[model];
+    if (alias && !table.prices[alias])
+        throw new Error(`price table alias ${model} -> ${alias} has no entry; update data/llm-price-table.json via PR`);
+    const entry = table.prices[alias ?? model];
+    if (!entry)
+        throw new Error(`price table has no entry for model ${model}; update data/llm-price-table.json via PR (fail-closed, no guessed price)`);
+    const cost = (usage.inputCacheMissTokens * entry.input_cache_miss_usd_per_1m_peak
+        + usage.inputCacheHitTokens * entry.input_cache_hit_usd_per_1m_peak
+        + usage.outputTokens * entry.output_usd_per_1m_peak) / 1_000_000;
+    return round6(cost);
+}
+/** 记录构建(确定性:同内容同 executed_at => 同 run_key)。写入前由消费方 parseNightlyRun 校验。 */
+export function buildNightlyRunRecord(input) {
+    const { schema_version, executed_at, real_llm, prompt_set_sha256, output_sha256, cost_usd } = input;
+    const core = { schema_version, executed_at, real_llm, prompt_set_sha256, output_sha256, cost_usd };
+    if (!SHA256.test(prompt_set_sha256) || !SHA256.test(output_sha256)) {
+        throw new Error('nightly record hashes must be lowercase SHA-256 digests');
+    }
+    const record = { ...core, run_key: `hmac-sha256:${createHash('sha256').update(canonical(core)).digest('hex')}` };
+    parseNightlyRun(JSON.parse(JSON.stringify(record)), 0);
+    return record;
+}
+function activeModel() {
+    return process.env['LLM_MODEL'] ?? process.env['DEEPSEEK_MODEL'] ?? 'MiniMax-M2';
+}
+function arg(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+export async function runNightlyEvidence(options) {
+    const clock = options.clock ?? (() => new Date());
+    const llmKey = process.env['LLM_API_KEY'] ?? process.env['DEEPSEEK_API_KEY'];
+    if (!options.dryRun && !llmKey) {
+        return { state: 'waiting_external_evidence', record: null, reason: 'no real LLM credential (LLM_API_KEY/DEEPSEEK_API_KEY); waiting & backoff & no-spend per issue #22 停机纪律' };
+    }
+    const promptSet = loadPromptSet('data/m3-nightly-prompts.json');
+    const priceTable = loadPriceTable('data/llm-price-table.json');
+    const packPath = join('..', 'data', 'flights_2026.json');
+    const solvePort = realtimeSolvePort(solveUnified);
+    const port = options.dryRun ? createMockLlm(packPath) : createOpenAICompatLlm(packPath);
+    const state = newState();
+    const history = [];
+    for (const turn of promptSet.turns) {
+        const { reply } = await runTurn(state, turn, port, [...history], solvePort);
+        history.push({ role: 'user', text: turn }, { role: 'assistant', text: reply });
+    }
+    const promptSetSha = sha256Of(promptSet);
+    // history 是 user/assistant 交错序列;assistant 回复落在每个 user 之后(index*2+1)
+    const turnsTranscript = promptSet.turns.map((turn, index) => ({ turn_index: index, user: turn, reply: history[index * 2 + 1]?.text ?? '' }));
+    const outputSha = sha256Of(turnsTranscript);
+    let record;
+    if (options.dryRun) {
+        record = buildNightlyRunRecord({
+            schema_version: 'gotry_m3_nightly_run_v1',
+            executed_at: clock().toISOString(),
+            real_llm: false,
+            prompt_set_sha256: promptSetSha,
+            output_sha256: outputSha,
+            cost_usd: 0,
+        });
+        return { state: 'dry_run', record, reason: 'dry-run exercises the pipeline against mock LLM; no evidence written' };
+    }
+    const usage = port.usage;
+    if (!usage)
+        throw new Error('real LLM port did not expose usage tracker (dsh-llm regression) — refusing to write cost evidence');
+    if (usage.calls !== promptSet.turns.length) {
+        throw new Error(`usage calls ${usage.calls} != expected turns ${promptSet.turns.length} — fail-closed, no evidence written`);
+    }
+    const costUsd = priceRunCost(activeModel(), usage, priceTable);
+    record = buildNightlyRunRecord({
+        schema_version: 'gotry_m3_nightly_run_v1',
+        executed_at: clock().toISOString(),
+        real_llm: true,
+        prompt_set_sha256: promptSetSha,
+        output_sha256: outputSha,
+        cost_usd: costUsd,
+    });
+    mkdirSync(options.evidenceRoot, { recursive: true });
+    appendFileSync(join(options.evidenceRoot, 'cohort.jsonl'), `${JSON.stringify(record)}\n`, 'utf8');
+    const budget = Number(process.env['GOTRY_NIGHTLY_BUDGET_USD'] ?? DEFAULT_BUDGET_USD);
+    const overBudget = Number.isFinite(budget) && budget > 0 ? costUsd > budget : false;
+    return { state: 'evidence_written', record, cost_over_budget: overBudget, reason: overBudget ? `cost_usd ${costUsd} exceeds GOTRY_NIGHTLY_BUDGET_USD ${budget} — backoff suggested` : undefined };
+}
+function output(payload, asJson) {
+    if (asJson)
+        console.log(JSON.stringify(payload));
+    else {
+        console.log(`nightly-evidence state: ${payload.state}${payload.error ? ` — ${payload.error}` : ''}`);
+        if (payload.record)
+            console.log(JSON.stringify(payload.record, null, 2));
+        if (payload.reason)
+            console.log(payload.reason);
+    }
+}
+async function main() {
+    // 仓根 .env(gitignored):每行 KEY=VALUE,不覆盖已有环境变量;--no-env-file 供等待态测试绕过
+    if (!process.argv.includes('--no-env-file')) {
+        try {
+            for (const line of readFileSync(join('..', '.env'), 'utf-8').split('\n')) {
+                const m = line.match(/^([A-Z_]+)=(.*)$/);
+                if (m && !process.env[m[1]])
+                    process.env[m[1]] = m[2].trim();
+            }
+        }
+        catch { /* .env 可选 */ }
+    }
+    const asJson = (arg('--format') ?? 'markdown') === 'json';
+    const evidenceRoot = arg('--evidence-root') ?? 'gotry-state/evidence/m3';
+    const dryRun = process.argv.includes('--dry-run');
+    try {
+        const result = await runNightlyEvidence({ evidenceRoot, dryRun });
+        output(result, asJson);
+        if (result.cost_over_budget)
+            process.exitCode = 3;
+    }
+    catch (error) {
+        output({ state: 'error', record: null, error: error.message }, asJson);
+        process.exitCode = 1;
+    }
+}
+if (process.argv[1]?.endsWith('nightly-evidence.ts')) {
+    await main();
+}

package/dist/scripts/nudge-digest.js

@@ -1,3 +1,20 @@
+/**
+ * 「下一次出发」回访摘要(roadmap M4 交付「主动回访(可关闭)」的骨架):
+ * 读 wish pool + 效用 sidecar,按当前窗口条件匹配 0..1 条建议,渲染成摘要,
+ * 经可插拔通道送出——通道 key 未配时骨架降级为 stdout/file,即插即用。
+ *
+ * 通道(环境变量,无新依赖,fetch 为 Node 18+ 全局):
+ *   GOTRY_NUDGE_ENABLED=false      全局关闭(契约:可关闭;其余配置再对也直接退出)
+ *   GOTRY_NUDGE_CHANNEL=stdout|file|lark   默认 stdout
+ *   GOTRY_NUDGE_FILE=<path>        file 通道输出位置,默认 <stateRoot>/gotry-state/nudge-digest.md
+ *   GOTRY_LARK_WEBHOOK=<url>       lark 通道 webhook(founder 侧配置即生效)
+ *
+ * 纪律:0..1(muted 永不召回,无命中不硬推);lark 投递失败降级 stdout 不抛
+ * (回访是 sidecar 性质,永不阻塞主路径);本脚本只读状态文件。
+ *
+ * 运行:cd ts && npx tsx scripts/nudge-digest.ts [--days N] [--budget N] [--month M] [--state-root DIR]
+ * 无参数时 days/budget 不参与评分,month 取系统当月。
+ */
 import { writeFileSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { pickNudgeWish } from '../src/wish-pool.js';
@@ -11,6 +28,7 @@ function arg(name) {
 const stateRoot = arg('--state-root') ?? '.';
 const stateDir = join(stateRoot, 'gotry-state');
 function readEvents() {
+    // ADR-15:账本优先,未迁移 root 回退旧文件(只读)
     return readUtilityEventsWithFallback(stateRoot);
 }
 if (process.env['GOTRY_NUDGE_ENABLED'] === 'false') {
@@ -22,20 +40,20 @@ const anchor = buildTimeAnchor(new Date());
 const ctx = {
     days: arg('--days') ? Number(arg('--days')) : undefined,
     budgetCny: arg('--budget') ? Number(arg('--budget')) : undefined,
-    month: arg('--month') ? Number(arg('--month')) : new Date().getMonth() + 1
+    month: arg('--month') ? Number(arg('--month')) : new Date().getMonth() + 1,
 };
 const match = pickNudgeWish(pool, ctx);
-const lines = [
-    `# 「下一次出发」回访摘要(${anchor.today} ${anchor.todayWeekdayZh})`
-];
+const lines = [`# 「下一次出发」回访摘要(${anchor.today} ${anchor.todayWeekdayZh})`];
 if (!match) {
-    lines.push(`在册 ${pool.filter((p)=>!p.muted).length} 条憧憬,当前窗口无可成行匹配——不打扰(0..1 纪律:不硬推)。`);
-} else {
-    const c = match.entry.conditions ?? {};
+    lines.push(`在册 ${pool.filter(p => !p.muted).length} 条憧憬,当前窗口无可成行匹配——不打扰(0..1 纪律:不硬推)。`);
+}
+else {
+    const c = (match.entry.conditions ?? {});
     const u = projectUtility(readEvents())[match.wishId];
     lines.push(`**${String(match.entry.name ?? match.wishId)}**(${match.hits.join(' + ')},命中 ${match.score}/3 项)`);
     lines.push(`- 成行条件: ${JSON.stringify(c)}`);
-    if (match.entry.reason) lines.push(`- 当初为什么: ${String(match.entry.reason).slice(0, 160)}`);
+    if (match.entry.reason)
+        lines.push(`- 当初为什么: ${String(match.entry.reason).slice(0, 160)}`);
     lines.push(`- 效用状态: ${u?.status ?? 'unknown'}(被召回 ${u?.recalled ?? 0} 次)`);
     lines.push('');
     lines.push('_想安排就说一声;不想被打扰说「mute <名字>」即可休眠,憧憬不被拒绝。_');
@@ -44,40 +62,33 @@ const digest = lines.join('\n');
 const channel = process.env['GOTRY_NUDGE_CHANNEL'] ?? 'stdout';
 if (channel === 'file') {
     const out = process.env['GOTRY_NUDGE_FILE'] ?? join(stateDir, 'nudge-digest.md');
-    mkdirSync(dirname(out), {
-        recursive: true
-    });
+    mkdirSync(dirname(out), { recursive: true });
     writeFileSync(out, digest + '\n', 'utf-8');
     console.log(`摘要已写入 ${out}`);
-} else if (channel === 'lark') {
+}
+else if (channel === 'lark') {
     const webhook = process.env['GOTRY_LARK_WEBHOOK'];
     if (!webhook) {
         console.log('lark 通道未配置(GOTRY_LARK_WEBHOOK 缺失)——降级 stdout,即插即用等 key:');
         console.log(digest);
-    } else {
+    }
+    else {
         try {
             const resp = await fetch(webhook, {
                 method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify({
-                    msg_type: 'text',
-                    content: {
-                        text: digest
-                    }
-                })
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ msg_type: 'text', content: { text: digest } }),
             });
             console.log(`lark 投递 HTTP ${resp.status}`);
-            if (!resp.ok) console.log(digest);
-        } catch (e) {
+            if (!resp.ok)
+                console.log(digest); // 失败降级 stdout,不丢摘要
+        }
+        catch (e) {
             console.log(`lark 投递失败(${e.message})——降级 stdout:`);
             console.log(digest);
         }
     }
-} else {
+}
+else {
     console.log(digest);
 }
-
-
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/nudge-digest.ts