@danceiny/gotry 0.0.1-rc.10

package/dist/scripts/ledger-tests.js

@@ -0,0 +1,365 @@
+import Database from 'better-sqlite3';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { ensureLedger, openLedgerIfExists } from '../src/state-ledger.js';
+let pass = 0;
+let fail = 0;
+function assert(cond, msg) {
+    if (cond) {
+        pass++;
+        console.log(`  ok - ${msg}`);
+    } else {
+        fail++;
+        console.error(`  FAIL - ${msg}`);
+    }
+}
+const root = mkdtempSync(join(tmpdir(), 'gotry-ledger-'));
+const ledger = ensureLedger(root);
+const r1 = ledger.appendMotivationPatch({
+    weights: {
+        escape_rest: 0.7
+    },
+    evidence: [
+        '用户原话:想去湖边什么都不干'
+    ],
+    hard: {
+        wake_not_before: '06:30'
+    }
+});
+assert(r1.saved === true, '画像补丁落账(saved)');
+const r2 = ledger.appendMotivationPatch({
+    evidence: [
+        '用户原话:想去湖边什么都不干'
+    ]
+});
+assert(r2.saved === false, '同 evidence 重放幂等(mergeProfile 守门 → 零事件)');
+const before = ledger.countEvents();
+let threw = false;
+try {
+    ledger.db.transaction(()=>{
+        ledger.insertEvent({
+            actor: 'test',
+            kind: 'probe',
+            payload: {
+                x: 1
+            }
+        });
+        throw new Error('boom');
+    })();
+} catch  {
+    threw = true;
+}
+assert(threw && ledger.countEvents() === before, '事务内异常 → 整体回滚,账本无痕(崩溃一致性的单事务证明)');
+threw = false;
+try {
+    ledger.appendWish({
+        name: '无条件憧憬',
+        reason: '',
+        conditions: undefined
+    });
+} catch  {
+    threw = true;
+}
+assert(threw && ledger.countEvents() === before, 'conditions 红线在事务内拒绝且零事件(红线进 schema 层)');
+const w1 = ledger.appendWish({
+    name: '大理·洱海',
+    reason: '',
+    conditions: {
+        days: 5,
+        budget_cny: 4950,
+        best_months: [
+            3,
+            4
+        ]
+    }
+});
+const w2 = ledger.appendWish({
+    name: '大理·洱海',
+    reason: '两周年想再去',
+    conditions: {
+        days: 6
+    }
+});
+assert(w1.added === true && w2.added === false && w1.wish_id === w2.wish_id, '同名愿望幂等更新,wish_id 语义派生稳定');
+assert(ledger.readWishPool().length === 1, '愿望池投影恰 1 条');
+const u1 = ledger.appendUtilityEvent({
+    wish_id: w1.wish_id,
+    kind: 'recalled',
+    ts: '2026-08-28T00:00:00Z',
+    ctx: 'test'
+});
+const u2 = ledger.appendUtilityEvent({
+    wish_id: w1.wish_id,
+    kind: 'recalled',
+    ts: '2026-08-28T00:00:00Z',
+    ctx: 'test'
+});
+assert(u1.appended === true && u2.appended === false, '效用事件语义键幂等(重放 no-op)');
+ledger.appendUtilityEvent({
+    wish_id: w1.wish_id,
+    kind: 'verified_outcome',
+    ts: '2026-08-28T00:00:00Z',
+    ctx: 'test-noattr'
+});
+assert(ledger.readUtilityEvents().at(-1)?.kind === 'applied', '无归因 verified 降级 applied(六件语义纪律随账本)');
+const t1 = ledger.appendTripEvent({
+    destination: '大理',
+    start: '2026-10-01',
+    source: 'user-verbatim',
+    evidence: '用户原话:国庆去了大理'
+});
+const t1dup = ledger.appendTripEvent({
+    destination: '大理',
+    start: '2026-10-01',
+    source: 'user-verbatim',
+    evidence: '用户原话:国庆去了大理'
+});
+assert(t1.appended === true && t1dup.appended === false, '行程 trip_id 幂等');
+const tOverlap = ledger.appendTripEvent({
+    destination: '大理',
+    start: '2026-10-03',
+    source: 'user-verbatim',
+    evidence: '重叠探针'
+});
+assert(tOverlap.appended === false && /重叠/.test(tOverlap.reason ?? ''), '同目的地日期重叠冲突即停(由人裁决)');
+const tBad = ledger.appendTripEvent({
+    destination: 'X地',
+    start: '十月一',
+    source: 'user-verbatim',
+    evidence: 'x'
+});
+assert(tBad.appended === false, '词表外日期拒收(不猜)');
+const cBad = ledger.appendCompanion({
+    label: '爸爸',
+    constraints: {
+        health: [
+            '手机号13800001111'
+        ]
+    },
+    evidence: '探针'
+});
+assert(cBad.appended === false && /负面清单/.test(cBad.reason ?? ''), '同行人负面清单拒收(证件/手机号不入库)');
+const cOk = ledger.appendCompanion({
+    label: '爸爸',
+    constraints: {
+        health: [
+            '轻度高血压'
+        ]
+    },
+    evidence: '用户原话:爸爸65轻度高血压'
+});
+assert(cOk.appended === true && ledger.readCompanions().length === 1, '同行人正常入账');
+const co = ledger.confirmOutcome({
+    wishId: w1.wish_id,
+    attribution: 'helpful',
+    detail: '成了',
+    trip: {
+        destination: '大理',
+        start: '2026-10-01',
+        source: 'wish-confirmed',
+        evidence: `wish ${w1.wish_id} confirm-outcome(helpful)`
+    }
+});
+assert(co.recorded === true, 'confirm-outcome:verified_outcome 效用事件落账');
+assert(co.trip?.appended === false && /重叠/.test(co.trip?.reason ?? ''), 'confirm-outcome 单事务:行程过守门(重叠拒收,与文件版语义一致)——两写同生或同拒');
+const poolBefore = JSON.stringify(ledger.readWishPool());
+const profileBefore = ledger.readMotivation();
+ledger.db.exec('DELETE FROM projection_docs; DELETE FROM projection_items');
+ledger.rebuildProjections();
+assert(JSON.stringify(ledger.readWishPool()) === poolBefore, 'fold 重建:愿望池与直读逐字节一致');
+assert(JSON.stringify(ledger.readMotivation()?.weights) === JSON.stringify(profileBefore?.weights) && (ledger.readMotivation()?.evidence?.length ?? 0) === (profileBefore?.evidence?.length ?? 0), 'fold 重建:画像与直读一致');
+assert(ledger.readCompanions().length === 1 && ledger.readTrips().length === 1, 'fold 重建:同行人投影与行程日志一致');
+const wishAddedSeqs = ledger.readEvents('wish.added', 10).map((e)=>e.seq);
+const firstWishSeq = Math.min(...wishAddedSeqs);
+ledger.appendWish({
+    name: '普吉',
+    reason: '',
+    conditions: {
+        days: 5
+    }
+});
+ledger.rebuildProjections(firstWishSeq);
+assert(ledger.readWishPool().length === 1, `rewind 至 seq ${firstWishSeq}:投影回到历史时点(LangGraph fork 同构)`);
+ledger.rebuildProjections();
+assert(ledger.readWishPool().length === 2, 'rebuild 无参回到最新(events 是唯一权威,投影随时可重建)');
+const mroot = mkdtempSync(join(tmpdir(), 'gotry-migrate-'));
+const mdir = join(mroot, 'gotry-state');
+mkdirSync(mdir, {
+    recursive: true
+});
+writeFileSync(join(mdir, 'motivation-profile.json'), JSON.stringify({
+    weights: {
+        curiosity: 0.6
+    },
+    evidence: [
+        '原话A'
+    ],
+    hard: {},
+    updated_at: '2026-08-01T00:00:00Z'
+}));
+writeFileSync(join(mdir, 'wish-pool.json'), JSON.stringify([
+    {
+        wish_id: 'wLEGACY1',
+        name: '京都',
+        conditions: {
+            days: 7
+        },
+        added_at: '2026-08-01T00:00:00Z'
+    }
+]));
+writeFileSync(join(mdir, 'memory-utility.jsonl'), JSON.stringify({
+    schema: 'memory_utility_observation.v0',
+    event_id: 'wLEGACY1|recalled||',
+    wish_id: 'wLEGACY1',
+    kind: 'recalled',
+    ts: '2026-08-02T00:00:00Z'
+}) + '\n');
+writeFileSync(join(mdir, 'trips.jsonl'), JSON.stringify({
+    schema: 'travel_timeline.v1',
+    trip_id: '京都|2026-04-01|user-verbatim',
+    destination: '京都',
+    start: '2026-04-01',
+    source: 'user-verbatim',
+    evidence: '原话',
+    ts: '2026-08-01T00:00:00Z'
+}) + '\n');
+writeFileSync(join(mdir, 'companions.json'), JSON.stringify([
+    {
+        schema: 'companion_profile.v1',
+        companion_id: '妈妈',
+        label: '妈妈',
+        constraints: {
+            mobility: '步行≤3h'
+        },
+        evidence: [
+            '原话'
+        ],
+        ts: '2026-08-01T00:00:00Z'
+    }
+]));
+const m1 = ensureLedger(mroot);
+assert(m1.readMotivation()?.weights?.['curiosity'] === 0.6, '迁移:画像整档入账');
+assert(String(m1.readWishPool()[0]?.wish_id) === 'wLEGACY1', '迁移:愿望保留原主键');
+assert(m1.readUtilityEvents().length === 1 && m1.readTrips().length === 1 && m1.readCompanions().length === 1, '迁移:效用/行程/同行人入账');
+assert(existsSync(join(mdir, 'pre-ledger-backup', 'wish-pool.json')), '迁移:导入前快照存在(pre-ledger-backup/)');
+const migratedCount = m1.countEvents();
+ensureLedger(mroot);
+assert(m1.countEvents() === migratedCount, '重复 ensure 不重复导入(kv 旗标 + 幂等键双保险)');
+const wroot = mkdtempSync(join(tmpdir(), 'gotry-wf-'));
+const countFile = join(wroot, 'solve-count.txt');
+writeFileSync(countFile, '');
+const crash = spawnSync('npx', [
+    'tsx',
+    'scripts/ledger-workflow-crash.ts',
+    wroot,
+    'dp-crash1',
+    countFile
+], {
+    encoding: 'utf-8'
+});
+assert(crash.status === 9, `崩溃探针按设计 exit 9(实际 ${crash.status}:${(crash.stderr ?? '').slice(0, 200)})`);
+const runRow = openLedgerIfExists(wroot)?.getWorkflowRun('dp-crash1');
+assert(runRow?.status === 'pending', '崩溃后工单仍 pending(账本权威未损)');
+const count1 = readFileSync(countFile, 'utf-8').split('\n').filter(Boolean).length;
+assert(count1 === 1, '崩溃前真实求解恰 1 次');
+const resume = spawnSync('npx', [
+    'tsx',
+    'scripts/async-collect.ts',
+    'dp-crash1',
+    wroot
+], {
+    encoding: 'utf-8',
+    env: {
+        ...process.env,
+        GOTRY_SOLVE_COUNT_FILE: countFile
+    }
+});
+assert(resume.status === 0, `恢复进程 exit 0(实际 ${resume.status}:${(resume.stderr ?? '').slice(0, 300)})`);
+const count2 = readFileSync(countFile, 'utf-8').split('\n').filter(Boolean).length;
+assert(count2 === 1, '恢复时 done 步骤零重算(exactly-once:求解计数仍 1,不重复花钱)');
+assert(existsSync(join(wroot, 'gotry-state', 'async', 'dp-crash1.deliverable.md')), '交付物视图已落盘(.deliverable.md)');
+assert(openLedgerIfExists(wroot)?.getWorkflowRun('dp-crash1')?.status === 'settled', '账本终态 settled');
+const replay = spawnSync('npx', [
+    'tsx',
+    'scripts/async-collect.ts',
+    'dp-crash1',
+    wroot
+], {
+    encoding: 'utf-8',
+    env: {
+        ...process.env,
+        GOTRY_SOLVE_COUNT_FILE: countFile
+    }
+});
+assert(replay.status === 0, '终态复诵 exit 0(幂等)');
+const count3 = readFileSync(countFile, 'utf-8').split('\n').filter(Boolean).length;
+assert(count3 === 1, '终态复诵零重算');
+const pw1 = ledger.requestPendingWrite({
+    idemKey: 'booking:demo-1',
+    seam: 'flight-order-confirm',
+    payload: {
+        flight: 'MU123'
+    }
+});
+const pw2 = ledger.requestPendingWrite({
+    idemKey: 'booking:demo-1',
+    seam: 'flight-order-confirm',
+    payload: {
+        flight: 'MU123'
+    }
+});
+assert(pw1.created === true && pw2.created === false, 'pending_writes 幂等键去重(同一确认不可能登记两次)');
+const cf1 = ledger.confirmPendingWrite('booking:demo-1', 'PNR-ABC');
+const cf2 = ledger.confirmPendingWrite('booking:demo-1', 'PNR-ABC2');
+assert(cf1.ok === true && cf2.ok === false && cf2.status === 'confirmed', 'L3 确认只能发生一次,二连击被拒');
+const cp1 = ledger.compensatePendingWrite('booking:demo-1', '用户改签退款');
+assert(cp1.ok === true && ledger.listPendingWrites()[0]?.status === 'compensated', 'saga 补偿可达(pending/confirmed → compensated)');
+const audit = ledger.readEvents(undefined, 100).filter((e)=>e.kind.startsWith('write.'));
+assert(audit.some((e)=>e.kind === 'write.pending') && audit.some((e)=>e.kind === 'write.confirmed') && audit.some((e)=>e.kind === 'write.compensated'), '写权审计事件链完整(append-only,WriteGate 的 receipt 落点)');
+const forkPath = join(root, 'whatif.db');
+ledger.forkWhatIf(forkPath);
+const forkDb = new Database(forkPath);
+forkDb.prepare("INSERT INTO events (ts, actor, kind, subject_id, payload) VALUES (?, 'test', 'probe', '', '{}')").run(new Date().toISOString());
+const forkCount = forkDb.prepare('SELECT COUNT(*) AS n FROM events').get().n;
+forkDb.close();
+assert(ledger.countEvents() === forkCount - 1, 'what-if 分叉:副本写入不触正本(VACUUM INTO 预演)');
+const localLedger = ensureLedger(root);
+const u123 = ensureLedger(root, 'u123');
+localLedger.appendWish({
+    name: '本地愿望',
+    reason: '',
+    conditions: {
+        days: 3
+    }
+});
+u123.appendWish({
+    name: '云端愿望',
+    reason: '',
+    conditions: {
+        days: 7
+    }
+});
+assert(localLedger.readWishPool().some((w)=>String(w.name) === '本地愿望'), '本地租户读到自己的愿望');
+assert(!localLedger.readWishPool().some((w)=>String(w.name) === '云端愿望'), '本地租户读不到云端愿望(隔离)');
+assert(u123.readWishPool().some((w)=>String(w.name) === '云端愿望'), '云端租户读到自己的愿望');
+assert(!u123.readWishPool().some((w)=>String(w.name) === '本地愿望'), '云端租户读不到本地愿望(隔离)');
+assert(localLedger.tenant === 'local' && u123.tenant === 'u123', 'tenant_id 从第一天就是一等字段');
+rmSync(root, {
+    recursive: true,
+    force: true
+});
+rmSync(mroot, {
+    recursive: true,
+    force: true
+});
+rmSync(wroot, {
+    recursive: true,
+    force: true
+});
+console.log(`\nLEDGER TESTS: ${pass} ok, ${fail} fail`);
+if (fail > 0) process.exit(1);
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/ledger-tests.ts

package/dist/scripts/ledger-workflow-crash.js

@@ -0,0 +1,42 @@
+import { appendFileSync } from 'node:fs';
+import { collectDeepPlanning, makeJournaledSolvePort, persistAsyncTicket } from '../src/loop.js';
+import { openLedgerIfExists } from '../src/state-ledger.js';
+const [root, id, countFile] = process.argv.slice(2);
+if (!root || !id || !countFile) {
+    console.error('用法:npx tsx scripts/ledger-workflow-crash.ts <stateRoot> <ticketId> <countFile>');
+    process.exit(1);
+}
+const ticket = {
+    id,
+    objective: '崩溃注入:已求解未交付(settle 前被杀)',
+    requestedAt: new Date().toISOString(),
+    etaLabel: '秒级'
+};
+const state = {
+    calendar: {
+        year: 2026,
+        assertedWeekdays: {}
+    },
+    profile: {},
+    gates: [],
+    wishes: [],
+    spec: {
+        segments: []
+    }
+};
+await persistAsyncTicket(ticket, state, root);
+const ledger = openLedgerIfExists(root);
+const solve = makeJournaledSolvePort(ledger, id, async ()=>({
+        feasible: false,
+        unsat_core: [
+            'crash-probe'
+        ],
+        suggestions: []
+    }), {
+    onRealSolve: ()=>appendFileSync(countFile, 'solve\n')
+});
+await collectDeepPlanning(state, ticket, solve);
+process.exit(9);
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/ledger-workflow-crash.ts

package/dist/scripts/memory-capture-tests.js

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import { mergeProfile } from '../src/memory-capture.js';
+const cur = {
+    weights: {
+        escape_rest: 1
+    },
+    evidence: [
+        '用户原话:「想去湖边什么都不干」'
+    ],
+    hard: {
+        wake_not_before: '07:00'
+    }
+};
+{
+    const m1 = mergeProfile(cur, {
+        evidence: [
+            '用户原话:「预算 5000 以内」',
+            '用户原话:「想去湖边什么都不干」'
+        ]
+    });
+    assert.equal(m1?.evidence.length, 2, `追加新+跳过重复,实际 ${m1?.evidence.length}`);
+    assert.ok(m1?.evidence[0].includes('湖边'), '既有 evidence 原位保留(P0)');
+    const m2 = mergeProfile(m1, {
+        evidence: [
+            '用户原话:「预算 5000 以内」'
+        ]
+    });
+    assert.equal(m2, null, '纯重复补丁应返 null(幂等)');
+    console.log('1. 追加不删史 + 幂等 OK');
+}{
+    const m = mergeProfile(cur, {
+        weights: {
+            escape_rest: 0.5,
+            curiosity: 0.5
+        },
+        evidence: [
+            '用户原话:「这次既要躺平也要探索」'
+        ]
+    });
+    const sum = Object.values(m?.weights ?? {}).reduce((a, b)=>a + b, 0);
+    assert.ok(Math.abs(sum - 1) < 0.01, `权重应归一,实际 sum=${sum}`);
+    const noEv = mergeProfile(cur, {
+        weights: {
+            escape_rest: 0.3,
+            curiosity: 0.7
+        }
+    });
+    assert.equal(noEv?.weights.escape_rest, 1, '权重变更无新 evidence 应被拒(P0)');
+    console.log('2. 权重归一 + P0 证据校验 OK');
+}{
+    const first = mergeProfile(null, {
+        weights: {
+            escape_rest: 1
+        },
+        evidence: [
+            '用户原话:「想去湖边」'
+        ]
+    });
+    assert.ok(first && first.evidence.length === 1 && Object.keys(first.weights).length === 1, '首存应生效');
+    assert.equal(mergeProfile(null, null), null, 'null 补丁仍守卫');
+    console.log('2.5 首存语义(current=null→空档案) OK');
+}{
+    assert.equal(mergeProfile(cur, null), null, 'null 补丁');
+    assert.equal(mergeProfile(cur, {}), null, '空补丁');
+    const m = mergeProfile(cur, {
+        hard: {
+            wake_not_before: '08:30',
+            budget_cny: 5000
+        }
+    });
+    assert.equal(m?.hard?.wake_not_before, '08:30', 'hard 后到优先');
+    assert.equal(m?.hard?.budget_cny, 5000, 'hard 新键并入');
+    console.log('3. 空守卫 + hard 覆盖后到优先 OK');
+}console.log('\nMEMORY-MERGE TESTS: 3/3 OK(T1 合并守门层)');
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/memory-capture-tests.ts

package/dist/scripts/memory-decay-tests.js

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import { decayedConfidence, eventDecayScore, windowFactor } from '../src/memory-decay.js';
+const NOW = new Date(2026, 7, 28, 12);
+let n = 0;
+function pass(name, body) {
+    body();
+    console.log(`  ${++n}. ${name} OK`);
+}
+pass('分级窗口:边界值与地板', ()=>{
+    assert.equal(windowFactor(0), 1.0);
+    assert.equal(windowFactor(30), 1.0);
+    assert.equal(windowFactor(31), 0.75);
+    assert.equal(windowFactor(90), 0.75);
+    assert.equal(windowFactor(91), 0.5);
+    assert.equal(windowFactor(180), 0.5);
+    assert.equal(windowFactor(181), 0.25);
+    assert.equal(windowFactor(365), 0.25);
+    assert.equal(windowFactor(366), 0.1);
+    assert.equal(windowFactor(3000), 0.1, '地板 0.1:旧而不灭');
+});
+pass('种类权重:verified > applied > recalled(自称被召回 ≠ 有用)', ()=>{
+    const ts = '2026-08-27T00:00:00Z';
+    assert.ok(eventDecayScore({
+        ts,
+        kind: 'verified_outcome'
+    }, NOW) > eventDecayScore({
+        ts,
+        kind: 'applied'
+    }, NOW));
+    assert.ok(eventDecayScore({
+        ts,
+        kind: 'applied'
+    }, NOW) > eventDecayScore({
+        ts,
+        kind: 'recalled'
+    }, NOW));
+});
+pass('单调:同种类,新事件分 ≥ 旧事件分', ()=>{
+    const fresh = eventDecayScore({
+        ts: '2026-08-27T00:00:00Z',
+        kind: 'recalled'
+    }, NOW);
+    const old = eventDecayScore({
+        ts: '2025-01-01T00:00:00Z',
+        kind: 'recalled'
+    }, NOW);
+    assert.ok(fresh >= old);
+    assert.equal(old, 0.025, '地板乘子=0.25×0.1(一年外)');
+});
+pass('置信度上界 1 且多事件累加有界', ()=>{
+    const many = Array.from({
+        length: 50
+    }, ()=>({
+            ts: '2026-08-27T00:00:00Z',
+            kind: 'verified_outcome'
+        }));
+    assert.equal(decayedConfidence(many, NOW), 1);
+    const one = decayedConfidence([
+        {
+            ts: '2026-08-27T00:00:00Z',
+            kind: 'verified_outcome'
+        }
+    ], NOW);
+    assert.ok(one > 0 && one <= 1);
+});
+pass('动机层零衰减(构造性):本模块无作用于 motivation-profile 的 API,权重原样透传', ()=>{
+    const weights = {
+        escape_rest: 0.4,
+        curiosity: 0.09
+    };
+    const snapshot = JSON.stringify(weights);
+    void decayedConfidence([
+        {
+            ts: '2020-01-01T00:00:00Z',
+            kind: 'recalled'
+        }
+    ], NOW);
+    assert.equal(JSON.stringify(weights), snapshot);
+});
+console.log(`\nMEMORY DECAY TESTS: ${n}/5 OK(memory-design P3 分级窗口/单调/地板/上界/动机零衰减)`);
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/memory-decay-tests.ts

package/dist/scripts/memory-metrics.js

@@ -0,0 +1,24 @@
+import { projectUtility } from '../src/memory-utility.js';
+import { decayedConfidence } from '../src/memory-decay.js';
+import { readUtilityEventsWithFallback, readWishPoolWithFallback } from '../src/state-ledger.js';
+const stateRoot = process.argv[2] ?? '.';
+const pool = readWishPoolWithFallback(stateRoot);
+const events = readUtilityEventsWithFallback(stateRoot);
+const projection = projectUtility(events);
+const active = pool.filter((w)=>typeof w.wish_id === 'string');
+const recalledWishes = Object.values(projection).filter((w)=>w.recalled > 0).length;
+const verifiedWishes = Object.values(projection).filter((w)=>w.verified > 0).length;
+const refluxBaseline = verifiedWishes / Math.max(recalledWishes, 1);
+console.log('=== GoTry 记忆效用指标(M4 北极星过程面,只读) ===');
+console.log(`wish pool: ${pool.length} 条在册(其中 ${pool.filter((w)=>w.muted).length} 条休眠,${active.length} 条有稳定 wish_id)`);
+console.log(`效用事件: ${events.length} 条(recalled=${events.filter((e)=>e.kind === 'recalled').length}, applied=${events.filter((e)=>e.kind === 'applied').length}, verified=${events.filter((e)=>e.kind === 'verified_outcome').length})`);
+for (const w of Object.values(projection)){
+    const name = pool.find((p)=>p.wish_id === w.wish_id)?.name ?? w.wish_id;
+    const conf = decayedConfidence(events.filter((e)=>e.wish_id === w.wish_id), new Date());
+    console.log(`  - ${name}: status=${w.status}, recalled=${w.recalled}, applied=${w.applied}, verified=${w.verified}, 新鲜置信度=${conf}(P3 时间窗衰减)`);
+}
+console.log(`经验回流率基线 = ${verifiedWishes}/${recalledWishes} = ${refluxBaseline.toFixed(2)}(verified/recalled;单用户起步期样本稀疏属预期)`);
+if (pool.length === 0) console.log('(wish pool 为空——首访用户,指标从首条憧憬入池开始积累)');
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/memory-metrics.ts

package/dist/scripts/nudge-digest.js

@@ -0,0 +1,83 @@
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { pickNudgeWish } from '../src/wish-pool.js';
+import { projectUtility } from '../src/memory-utility.js';
+import { buildTimeAnchor } from '../src/time-anchor.js';
+import { readUtilityEventsWithFallback, readWishPoolWithFallback } from '../src/state-ledger.js';
+function arg(name) {
+    const i = process.argv.indexOf(name);
+    return i >= 0 ? process.argv[i + 1] : undefined;
+}
+const stateRoot = arg('--state-root') ?? '.';
+const stateDir = join(stateRoot, 'gotry-state');
+function readEvents() {
+    return readUtilityEventsWithFallback(stateRoot);
+}
+if (process.env['GOTRY_NUDGE_ENABLED'] === 'false') {
+    console.log('回访已关闭(GOTRY_NUDGE_ENABLED=false)——可关闭契约,正常退出');
+    process.exit(0);
+}
+const pool = readWishPoolWithFallback(stateRoot);
+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
+};
+const match = pickNudgeWish(pool, ctx);
+const lines = [
+    `# 「下一次出发」回访摘要(${anchor.today} ${anchor.todayWeekdayZh})`
+];
+if (!match) {
+    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)}`);
+    lines.push(`- 效用状态: ${u?.status ?? 'unknown'}(被召回 ${u?.recalled ?? 0} 次)`);
+    lines.push('');
+    lines.push('_想安排就说一声;不想被打扰说「mute <名字>」即可休眠,憧憬不被拒绝。_');
+}
+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
+    });
+    writeFileSync(out, digest + '\n', 'utf-8');
+    console.log(`摘要已写入 ${out}`);
+} 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 {
+        try {
+            const resp = await fetch(webhook, {
+                method: 'POST',
+                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) {
+            console.log(`lark 投递失败(${e.message})——降级 stdout:`);
+            console.log(digest);
+        }
+    }
+} else {
+    console.log(digest);
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/nudge-digest.ts