@danceiny/gotry 0.0.1-rc.10

package/dist/scripts/agent-reach-wrapper-tests.js

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict';
+import { reach, reachStatus } from '../capabilities/agent-reach.js';
+{
+    const st = await reachStatus(90_000);
+    assert.equal(st.ok, true);
+    assert.equal(st.via, 'agent-reach-cli');
+    assert.ok(st.output.length > 50, 'doctor 输出非空(上游原样)');
+    console.log(`1. status → doctor 透传 (${st.latencyMs}ms) OK`);
+}{
+    const r = await reach({
+        channel: 'web',
+        method: 'read',
+        args: [
+            'https://example.com'
+        ],
+        timeoutMs: 30_000
+    });
+    assert.equal(r.verdict, 'found');
+    assert.ok(r.evidence.includes('[agent-reach:web.read@'), '证据链 [agent-reach:web.read@ts]');
+    assert.ok(typeof r.data === 'string' && r.data.length > 200, 'content 非空 markdown');
+    console.log(`2. web.read example.com → found (${r.latencyMs}ms) OK`);
+}{
+    const r = await reach({
+        channel: 'v2ex',
+        method: 'get_hot_topics',
+        timeoutMs: 30_000
+    });
+    if (r.ok) {
+        assert.ok(Array.isArray(r.data), 'hot topics 是数组');
+        console.log(`3. v2ex.get_hot_topics → found (${r.data.length} topics) OK`);
+    } else {
+        assert.ok([
+            'error',
+            'needs-setup'
+        ].includes(r.verdict), '降级合法');
+        console.log(`3. v2ex.get_hot_topics → ${r.verdict}(网络边界,降级合法) OK`);
+    }
+}{
+    const r = await reach({
+        channel: 'xueqiu',
+        method: 'get_stock_quote',
+        args: [
+            'SH600519'
+        ],
+        timeoutMs: 30_000
+    });
+    assert.equal(r.verdict, 'needs-setup', `实际 verdict=${r.verdict} error=${r.error}`);
+    assert.ok((r.setup ?? '').includes('configure'), 'setup 透传上游 configure 指引(不转述)');
+    console.log('4. xueqiu.get_stock_quote → needs-setup(上游原话指引) OK');
+}{
+    const r = await reach({
+        channel: 'nosuch',
+        method: 'foo'
+    });
+    assert.equal(r.ok, false);
+    const channels = r.inventory?.channels ?? {};
+    assert.ok(channels.web && channels.xueqiu && channels['exa_search'], 'inventory 带回上游注册表(含 exa_search 真名)');
+    console.log(`5. 未知渠道 → 自描述清单(${Object.keys(channels).length} 渠道) OK`);
+}{
+    const r = await reach({
+        channel: 'web',
+        method: 'nosuch'
+    });
+    assert.equal(r.ok, false);
+    const methods = r.inventory?.methods ?? {};
+    assert.ok(methods.read, 'inventory.methods 带 read 签名');
+    console.log(`6. 未知方法 → 自描述清单(${Object.keys(methods).length} 方法) OK`);
+}{
+    const r = await reach({
+        channel: '',
+        method: ''
+    });
+    assert.equal(r.ok, false);
+    assert.equal(r.verdict, 'error');
+    console.log('7. 空 channel/method 降级 OK');
+}console.log('\nAGENT-REACH WRAPPER TESTS: 7/7 OK(反射桥 + doctor 透传 + 自描述错误)');
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/agent-reach-wrapper-tests.ts

package/dist/scripts/anything-tests.js

@@ -0,0 +1,95 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile, chmod } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { anythingSearch } from '../capabilities/anything.js';
+const tmp = await mkdtemp(join(tmpdir(), 'anything-test-'));
+try {
+    async function fakeBin(name, behaviour) {
+        const p = join(tmp, name);
+        if (behaviour === 'ok') {
+            await writeFile(p, `#!/bin/sh
+cat <<'JSON'
+{"candidates":[
+  {"type":"hotel","name":"Park Hyatt","hotel":{"id":"h1","name":"Park Hyatt","latitude":22.31,"longitude":114.16}},
+  {"type":"city","name":"大理市","region":{"id":"d1","name":"Dali","latitude":25.58,"longitude":100.21}},
+  {"type":"place","name":"洱海","region":{"id":"r1","name":"Erhai Lake","latitude":25.74,"longitude":100.25}}
+]}
+JSON
+`, {
+                mode: 0o755
+            });
+        } else if (behaviour === 'empty') {
+            await writeFile(p, `#!/bin/sh
+cat <<'JSON'
+{"candidates":[]}
+JSON
+`, {
+                mode: 0o755
+            });
+        } else if (behaviour === 'fail') {
+            await writeFile(p, `#!/bin/sh
+echo 'hotelbe down' >&2
+exit 1
+`, {
+                mode: 0o755
+            });
+        } else {
+            await writeFile(p, `#!/bin/sh
+echo 'starting' >&2
+while :; do sleep 5; done
+`, {
+                mode: 0o755
+            });
+        }
+        return p;
+    }
+    const ok = await fakeBin('hbcli-ok', 'ok');
+    const r1 = await anythingSearch({
+        keyword: 'Park Hyatt',
+        hbcliBin: ok
+    });
+    assert.equal(r1.verdict, 'hit');
+    assert.equal(r1.hits.length, 3);
+    assert.ok(r1.evidence.includes('hbcli-anything@'));
+    console.log(`1. Park Hyatt → hit (${r1.hits.length} candidates) OK`);
+    const empty = await fakeBin('hbcli-empty', 'empty');
+    const r2 = await anythingSearch({
+        keyword: 'nothing',
+        hbcliBin: empty
+    });
+    assert.equal(r2.verdict, 'miss');
+    assert.equal(r2.hits.length, 0);
+    console.log('2. nothing → miss OK');
+    const fail = await fakeBin('hbcli-fail', 'fail');
+    const r3 = await anythingSearch({
+        keyword: 'x',
+        hbcliBin: fail
+    });
+    assert.equal(r3.verdict, 'error');
+    assert.equal(r3.ok, false);
+    assert.match(r3.evidence, /error/);
+    console.log('3. fail → error (降级) OK');
+    const hang = await fakeBin('hbcli-hang', 'hang');
+    const r4 = await anythingSearch({
+        keyword: 'x',
+        hbcliBin: hang,
+        timeoutMs: 800
+    });
+    assert.equal(r4.verdict, 'error', 'timeout 应判 error');
+    console.log(`4. hang/timeout → error OK (latency=${r4.latencyMs}ms)`);
+    const r5 = await anythingSearch({
+        keyword: '   '
+    });
+    assert.equal(r5.verdict, 'error');
+    console.log('5. empty keyword → error OK');
+    console.log('\nANYTHING TESTS: 5/5 OK(hbcli fake + graceful degrade)');
+} finally{
+    await rm(tmp, {
+        recursive: true,
+        force: true
+    });
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/anything-tests.ts

package/dist/scripts/async-collect.js

@@ -0,0 +1,37 @@
+import { appendFileSync } from 'node:fs';
+import { collectDeepPlanning, loadAsyncTicket, makeJournaledSolvePort, settleAsyncTicket } from '../src/loop.js';
+import { solveUnified } from '../src/unified.js';
+import { openLedgerIfExists } from '../src/state-ledger.js';
+const ticketId = process.argv[2];
+const stateRoot = process.argv[3] ?? '.';
+if (!ticketId) {
+    console.error('用法:npx tsx scripts/async-collect.ts <ticketId> [stateRoot](权威在账本 workflow_runs,视图在 gotry-state/async/)');
+    process.exit(1);
+}
+const loaded = await loadAsyncTicket(ticketId, stateRoot);
+if (!loaded) {
+    console.error(`工单 ${ticketId} 不存在(账本 workflow_runs / gotry-state/async/${ticketId}.json)`);
+    process.exit(1);
+}
+const ledger = openLedgerIfExists(stateRoot);
+const run = ledger?.getWorkflowRun(ticketId);
+if (run?.status === 'settled' && run.deliverable) {
+    console.log(`工单 ${ticketId} 已交付(账本终态,复诵不重算):\n\n${run.deliverable}`);
+    process.exit(0);
+}
+if (!ledger) {
+    console.error(`工单 ${ticketId}:stateRoot(${stateRoot})无账本——持久化先于回收,不应发生`);
+    process.exit(1);
+}
+const solve = makeJournaledSolvePort(ledger, ticketId, solveUnified, {
+    onRealSolve: ()=>{
+        const f = process.env['GOTRY_SOLVE_COUNT_FILE'];
+        if (f) appendFileSync(f, 'solve\n');
+    }
+});
+const { reply } = await collectDeepPlanning(loaded.state, loaded.ticket, solve);
+const out = await settleAsyncTicket(ticketId, reply, stateRoot);
+console.log(`交付物已落盘:${out}\n\n${reply}`);
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/async-collect.ts

package/dist/scripts/companion-tests.js

@@ -0,0 +1,112 @@
+import assert from 'node:assert/strict';
+import { companionId, sensitiveViolation, upsertCompanion } from '../src/companions.js';
+let n = 0;
+function pass(name, body) {
+    body();
+    console.log(`  ${++n}. ${name} OK`);
+}
+pass('负面清单守卫:证件号/手机号拒收入库(红线 6 工程形态)', ()=>{
+    assert.ok(sensitiveViolation('护照号 E12345678')?.includes('负面清单'), '证件拒');
+    assert.ok(sensitiveViolation('我电话 13812345678')?.includes('负面清单'), '手机号拒');
+    assert.equal(sensitiveViolation('爸爸65,轻度高血压,走不动山路'), null, '行为约束正常');
+    const r = upsertCompanion([], {
+        label: '爸爸',
+        constraints: {
+            health: [
+                '轻度高血压'
+            ]
+        },
+        evidence: '身份证号 110101199001011234,轻度高血压'
+    });
+    assert.equal(r.appended, false);
+    assert.ok(r.reason?.includes('负面清单'));
+});
+pass('新建:约束+证据落库,companion_id 语义派生', ()=>{
+    const r = upsertCompanion([], {
+        label: '爸 爸',
+        constraints: {
+            health: [
+                '轻度高血压'
+            ],
+            mobility: '步行≤4h'
+        },
+        evidence: '爸爸65有轻度高血压,别太累'
+    });
+    assert.equal(r.appended, true);
+    assert.equal(r.companionId, '爸爸');
+    const p = r.profiles[0];
+    assert.deepEqual(p.constraints.health, [
+        '轻度高血压'
+    ]);
+    assert.deepEqual(p.evidence, [
+        '爸爸65有轻度高血压,别太累'
+    ]);
+});
+pass('upsert 合并:数组追加不删史/覆盖取新/幂等', ()=>{
+    let ps = [];
+    ps = upsertCompanion(ps, {
+        label: '爸爸',
+        constraints: {
+            health: [
+                '轻度高血压'
+            ],
+            mobility: '步行≤4h'
+        },
+        evidence: '原话一'
+    }).profiles;
+    ps = upsertCompanion(ps, {
+        label: '爸爸',
+        constraints: {
+            health: [
+                '晕车'
+            ],
+            mobility: '步行≤3h'
+        },
+        evidence: '原话二:晕车'
+    }).profiles;
+    const p = ps.find((x)=>x.companion_id === '爸爸');
+    assert.deepEqual(p.constraints.health, [
+        '轻度高血压',
+        '晕车'
+    ], '数组追加不删史');
+    assert.equal(p.constraints.mobility, '步行≤3h', '标量取新值');
+    assert.equal(p.evidence.length, 2, '证据两条');
+    const r3 = upsertCompanion(ps, {
+        label: '爸爸',
+        constraints: {
+            health: [
+                '晕车'
+            ],
+            mobility: '步行≤3h'
+        },
+        evidence: '原话二:晕车'
+    });
+    assert.equal(r3.appended, false, '全量相同幂等 no-op');
+});
+pass('多人并存与 id 稳定性', ()=>{
+    let ps = [];
+    ps = upsertCompanion(ps, {
+        label: '爸爸',
+        constraints: {
+            health: [
+                '高血压'
+            ]
+        },
+        evidence: 'a'
+    }).profiles;
+    ps = upsertCompanion(ps, {
+        label: '女朋友',
+        constraints: {
+            prefs: [
+                '怕吵'
+            ]
+        },
+        evidence: 'b'
+    }).profiles;
+    assert.equal(ps.length, 2);
+    assert.equal(companionId('女 朋友'), '女朋友');
+});
+console.log(`\nCOMPANION TESTS: ${n}/4 OK(memory-design P2 守门面)`);
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/companion-tests.ts

package/dist/scripts/diff-test.js

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import * as unifiedModule from '../src/unified.js';
+import { parseCandidate, parseRequest } from '../src/model.js';
+const payload = JSON.parse(await readFile(join('..', 'data', 'golden_erhai.json'), 'utf-8'));
+const req = parseRequest(payload['request']);
+const candidates = payload['candidates'].map(parseCandidate);
+const specA = unifiedModule.segmentsFromCandidate(req, candidates);
+const tsA = unifiedModule.solveChoiceSegment(specA, req);
+const specB = JSON.parse(JSON.stringify(specA));
+const tsB = unifiedModule.solveChoiceSegment(specB, req);
+console.log(`pure-TS 双路径稳定性(同模块, 独立 spec 实例 — 验证幂等)\n`);
+assert.equal(tsA['recommended'], tsB['recommended'], 'recommended 一致');
+const tsV = Object.fromEntries(tsA['verdicts'].map((v)=>[
+        v['candidate_id'],
+        v
+    ]));
+const tsVc = Object.fromEntries(tsB['verdicts'].map((v)=>[
+        v['candidate_id'],
+        v
+    ]));
+assert.deepEqual(Object.keys(tsV).sort(), Object.keys(tsVc).sort(), '候选集合一致');
+for (const id of Object.keys(tsV)){
+    assert.equal(tsV[id]['feasible'], tsVc[id]['feasible'], `${id} feasible 一致`);
+    assert.deepEqual(tsV[id]['unsat_core'] ?? [], tsVc[id]['unsat_core'] ?? [], `${id} unsat_core 一致`);
+    if (tsV[id]['wish_pool'] && tsVc[id]['wish_pool']) {
+        assert.equal(tsV[id]['wish_pool']['conditions']['days'], tsVc[id]['wish_pool']['conditions']['days'], `${id} wish days 一致`);
+        assert.equal(tsV[id]['wish_pool']['conditions']['budget_cny'], tsVc[id]['wish_pool']['conditions']['budget_cny'], `${id} wish budget(最优值)一致`);
+    }
+    if (tsV[id]['true_cost'] && tsVc[id]['true_cost']) {
+        const sameWake = tsV[id]['true_cost']['wake'] === tsVc[id]['true_cost']['wake'];
+        console.log(`${id}: wake ${tsV[id]['true_cost']['wake']} vs ${tsVc[id]['true_cost']['wake']} ${sameWake ? '(等价选择)' : '(不同选择,均在可行域)'}`);
+    }
+}
+console.log('\nDIFF TEST OK: 双路径判定一致(纯 TS,无 Python 依赖)');
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/diff-test.ts

package/dist/scripts/engine-run.js

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseCandidate, parseRequest } from '../src/model.js';
+import { solve } from '../src/engine.js';
+const payload = JSON.parse(await readFile(join('..', 'data', 'golden_erhai.json'), 'utf-8'));
+const req = parseRequest(payload['request']);
+const candidates = payload['candidates'].map(parseCandidate);
+const t0 = Date.now();
+const result = await solve(req, candidates);
+console.log(`(TS 引擎总耗时含 WASM init: ${Date.now() - t0}ms, recommended=${result['recommended']})\n`);
+console.log(result['answer_md']);
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/engine-run.ts

package/dist/scripts/engine-tests.js

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseCandidate, parseRequest, requiredUsableHours } from '../src/model.js';
+import { solve, solveCandidate } from '../src/engine.js';
+const payload = JSON.parse(await readFile(join('..', 'data', 'golden_erhai.json'), 'utf-8'));
+const req = parseRequest(payload['request']);
+const candidates = payload['candidates'].map(parseCandidate);
+const result = await solve(req, candidates);
+const verdicts = Object.fromEntries(result.verdicts.map((v)=>[
+        v['candidate_id'],
+        v
+    ]));
+assert.equal(verdicts['dali']['feasible'], false);
+assert.ok(verdicts['dali']['unsat_core'].includes('duration'));
+const wp = verdicts['dali']['wish_pool'];
+assert.ok(wp, 'dali wish pool exists');
+assert.ok(wp['conditions']['days'] >= 5);
+assert.ok('budget_cny' in wp['conditions']);
+assert.ok(wp['conditions']['best_months'].length > 0);
+assert.ok(verdicts['dali']['suggestions'].length > 0);
+assert.ok(verdicts['dali']['suggestions'].some((s)=>s['text'].includes('天')));
+assert.equal(verdicts['qiandao']['feasible'], true);
+assert.equal(result.recommended, 'qiandao');
+const t = verdicts['qiandao']['true_cost'];
+assert.ok(t['money_cny'] <= 3000);
+assert.ok(Number(String(t['wake']).replace(':', '')) >= 630);
+assert.ok(t['energy_arrival_pct'] >= 40);
+assert.ok(t['usable_hours'] >= requiredUsableHours(req.motivation));
+assert.equal(verdicts['taihu']['feasible'], true);
+assert.ok(verdicts['taihu']['true_cost']['money_cny'] <= verdicts['qiandao']['true_cost']['money_cny']);
+assert.ok(result.answer_md.includes('千岛湖'));
+assert.ok(result.answer_md.includes('下一次出发'));
+assert.ok(result.answer_md.includes('待你决定的两个问题'));
+const tight = structuredClone(payload);
+tight['request']['budget_cny'] = 900;
+const tightReq = parseRequest(tight['request']);
+const v = await solveCandidate(candidates.find((c)=>c.id === 'qiandao'), tightReq);
+assert.equal(v.feasible, false);
+assert.ok(v.unsatCore.includes('budget'));
+assert.ok(v.suggestions.some((s)=>s.text.includes('预算提高到')));
+console.log('TS ENGINE TESTS: 8/8 OK');
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/engine-tests.ts

package/dist/scripts/hbcli-tests.js

@@ -0,0 +1,101 @@
+import assert from 'node:assert/strict';
+import { writeFile, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { callHbcliJson, searchHotels } from '../capabilities/hbcli.js';
+const tmp = await mkdtemp(join(tmpdir(), 'hbcli-test-'));
+async function fakeBin(name, code, payload) {
+    const p = join(tmp, name);
+    await writeFile(p, `#!/bin/sh\necho '${payload}'\nexit ${code}\n`, {
+        mode: 0o755
+    });
+    return p;
+}
+const okBin = await fakeBin('hbcli-ok', 0, '{"hotels":[{"id":"h1","name":"x"}]}');
+const failBin = await fakeBin('hbcli-fail', 1, 'certificate has expired');
+const failBin2 = join(tmp, 'hbcli-fail2');
+await writeFile(failBin2, `#!/bin/sh\nexit 1\n`, {
+    mode: 0o755
+});
+const r1 = await callHbcliJson([
+    'search',
+    'hotel-list',
+    '--json'
+], {
+    hbcliBin: okBin
+});
+assert.equal(r1.via, 'hbcli-realtime', 'happy path');
+assert.deepEqual(r1.result, {
+    hotels: [
+        {
+            id: 'h1',
+            name: 'x'
+        }
+    ]
+});
+assert.match(r1.evidence, /^\[实时API:hbcli@/);
+assert.ok(r1.latencyMs >= 0);
+const r2 = await callHbcliJson([
+    'search',
+    'hotel-list',
+    '--json'
+], {
+    hbcliBin: failBin2,
+    timeoutMs: 5000
+});
+assert.equal(r2.via, 'hbcli-error', 'error path');
+assert.match(r2.evidence, /\[实时API:hbcli@error@/, `evidence got: ${r2.evidence}`);
+assert.equal(r2.exitCode, 1, '失败时 exitCode 透传');
+assert.ok(r2.error, '有 error 字段');
+const r3 = await callHbcliJson([
+    'search',
+    'hotel-list',
+    '--json'
+], {
+    hbcliBin: '/nope/hbcli',
+    timeoutMs: 5000
+});
+assert.equal(r3.via, 'hbcli-error', 'no-binary path');
+assert.match(r3.evidence, /spawn_error/, `evidence got: ${r3.evidence}`);
+const fallback = join(tmp, 'hotels-fallback.json');
+await writeFile(fallback, JSON.stringify({
+    meta: 'fake',
+    stays: [
+        {
+            id: 's1'
+        }
+    ]
+}));
+{
+    const { writeFileSync, chmodSync } = await import('node:fs');
+    const echoBin = join(tmp, 'hbcli-echo');
+    writeFileSync(echoBin, '#!/bin/sh\necho "ARGS:$@"; echo \'{}\' ');
+    chmodSync(echoBin, 0o755);
+    const re = await searchHotels({
+        destination: '普吉',
+        adults: 2
+    }, {
+        hbcliBin: echoBin
+    });
+    const argLine = JSON.stringify(re);
+    if (!argLine.includes('destination-name') || !argLine.includes('room-occupancies')) {
+        throw new Error(`FAIL: v0.3.0 旗标未对齐,实际 ${argLine.slice(0, 200)}`);
+    }
+    console.log('5. v0.3.0 旗标(--destination-name/--room-occupancies)对齐 OK');
+}const r4 = await searchHotels({
+    destination: '普吉'
+}, {
+    hbcliBin: failBin2,
+    fallbackPath: fallback
+});
+assert.equal(r4.via, 'hbcli-error', 'searchHotels: fails to hbcli → fallback');
+assert.equal(r4.summary.includes('降级到静态包'), true, 'summary 指明降级');
+assert.ok(r4.hotels, 'hotels 字段填上静态包内容');
+await rm(tmp, {
+    recursive: true,
+    force: true
+});
+console.log('HBCLI TESTS: 5/5 OK (happy / error / no-binary / fallback / v0.3.0 旗标回归)');
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/hbcli-tests.ts

package/dist/scripts/incident-tests.js

@@ -0,0 +1,96 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import { recordIncident, resolveIncidentsPath } from '../capabilities/incident-log.js';
+const here = dirname(fileURLToPath(import.meta.url));
+const tmp = await mkdtemp(join(tmpdir(), 'incident-test-'));
+const path1 = resolveIncidentsPath(tmp);
+recordIncident({
+    ts: '2026-08-22T00:00:00Z',
+    kind: 'uncaughtException',
+    message: 'synthetic',
+    stack: 'no-stack'
+}, tmp);
+const content = await readFile(path1, 'utf-8');
+const written = JSON.parse(content.trim().split('\n')[0]);
+assert.equal(written.kind, 'uncaughtException');
+assert.equal(written.message, 'synthetic');
+assert.equal(written.stack, 'no-stack');
+console.log('UNIT 1 OK: recordIncident 同步 fsync 写盘');
+const childCode = `
+import { installProcessGuards } from '${here}/../capabilities/incident-log.ts'
+installProcessGuards('${tmp}', { uncaughtException: 'test-child' })
+setTimeout(() => { throw new Error('boom-from-child') }, 50)
+setTimeout(() => { console.log('CHILD_DONE'); process.exit(0) }, 400)
+`;
+const childPath = join(tmp, 'child.mjs');
+const { writeFile } = await import('node:fs/promises');
+await writeFile(childPath, childCode);
+const result = await new Promise((resolve, reject)=>{
+    const child = spawn(process.execPath, [
+        '--experimental-strip-types',
+        childPath
+    ], {
+        stdio: [
+            'ignore',
+            'pipe',
+            'pipe'
+        ]
+    });
+    let stdout = '', stderr = '';
+    child.stdout.on('data', (d)=>{
+        stdout += d.toString();
+    });
+    child.stderr.on('data', (d)=>{
+        stderr += d.toString();
+    });
+    child.on('close', (code)=>resolve({
+            stdout,
+            stderr,
+            code
+        }));
+    child.on('error', reject);
+});
+assert.equal(result.code, 0, `子进程应为 graceful exit,但拿到 ${result.code}: ${result.stderr.slice(0, 200)}`);
+assert.match(result.stdout, /CHILD_DONE/, `子进程应触发我的 400ms setTimeout: stdout=${result.stdout} stderr=${result.stderr.slice(0, 200)}`);
+const childLogPath = resolveIncidentsPath(tmp);
+const childLogContent = await readFile(childLogPath, 'utf-8');
+const lines = childLogContent.trim().split('\n').filter(Boolean);
+assert.ok(lines.length >= 1, `应至少写一行 incident, 实际为: ${childLogContent}`);
+const lastLine = JSON.parse(lines.at(-1));
+assert.equal(lastLine.kind, 'uncaughtException', `kind 应是 uncaughtException,实际: ${lastLine.kind}`);
+assert.match(lastLine.message, /boom-from-child/, `应记录错误消息,实际: ${lastLine.message}`);
+assert.equal(lastLine.source, 'test-child', `source 来自 labels.uncaughtException,实际: ${lastLine.source}`);
+console.log('INTEG 1 OK: 子进程 uncaughtException → fsync 写盘,handler 不阻塞 graceful exit');
+{
+    const { guardToolExecute } = await import('../capabilities/incident-log.js');
+    const asyncBoom = guardToolExecute('synthetic-tool', tmp, async ()=>{
+        throw new Error('boom-async');
+    });
+    const r1 = await asyncBoom({
+        x: 1
+    }, undefined);
+    assert.equal(r1.ok, false, '异步抛错应降级为结构化错误,不向上抛');
+    assert.ok(String(r1.summary).includes('synthetic-tool'), 'summary 指明来源工具');
+    assert.ok(String(r1.evidence).includes('tool_execute_error'), 'evidence 带 incident 标记');
+    const syncBoom = guardToolExecute('synthetic-tool-sync', tmp, ()=>{
+        throw new Error('boom-sync');
+    });
+    const r2 = await syncBoom({}, undefined);
+    assert.equal(r2.ok, false, '同步抛错同样隔离');
+    const guardedLog = (await readFile(path1, 'utf8')).trim().split('\n').filter(Boolean);
+    const toolErrs = guardedLog.map((l)=>JSON.parse(l)).filter((x)=>x.kind === 'tool_execute_error');
+    assert.equal(toolErrs.length, 2, '两条 tool_execute_error 均应落盘');
+    console.log('UNIT 2 OK: guardToolExecute 同步/异步异常隔离 + incident 落盘');
+}await rm(tmp, {
+    recursive: true,
+    force: true
+});
+console.log('INCIDENT TESTS: 3/3 OK');
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/incident-tests.ts

package/dist/scripts/journey-tests.js

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { solveJourney, parseFlightPackLegs } from '../src/journey.js';
+import { hhmmToMin } from '../src/model.js';
+const pack = JSON.parse(await readFile(join('..', 'data', 'flights_2026.json'), 'utf-8'));
+const legs = parseFlightPackLegs(pack);
+const r1 = await solveJourney({
+    legs,
+    budgetCny: 9000
+});
+assert.equal(r1.feasible, true);
+assert.equal(r1.money_cny, r1.legs.reduce((a, l)=>a + l.price_cny, 0));
+assert.ok(r1.money_cny >= 7300 && r1.money_cny <= 8550, `有效解区间: ${r1.money_cny}(M-4 reconcile 已知 f3=FD582 路径下限; demo 上限 8550)`);
+const f5 = r1.legs.find((l)=>l.service === 'EK329');
+assert.equal(f5.energy_pct, 75);
+assert.ok(f5.wake.includes('前一日'), `wake 跨日显示: ${f5.wake}`);
+const f4 = r1.legs.find((l)=>[
+        'MU5233',
+        'ZH9108',
+        'DZ6252'
+    ].includes(l.service));
+assert.ok(f4 !== undefined, 'f4 没产出任何候选');
+console.log(`3. f4 → ${f4.service}`);
+const tight = legs.map((l)=>l.id === 'f1' ? {
+        ...l,
+        arriveByMin: hhmmToMin('15:00')
+    } : l);
+const r2 = await solveJourney({
+    legs: tight
+});
+assert.equal(r2.feasible, false);
+assert.ok(r2.unsat_core.includes('f1:arrive_by'));
+assert.ok(r2.suggestions.some((sg)=>sg.relax === 'f1:arrive_by'));
+const r3 = await solveJourney({
+    legs,
+    budgetCny: 1000
+});
+assert.equal(r3.feasible, false);
+assert.ok(r3.unsat_core.includes('total:budget'));
+assert.ok(r3.suggestions.some((sg)=>sg.relax === 'total:budget'));
+console.log(`TS JOURNEY TESTS: 5/5 OK(五段全链可行,¥${r1.money_cny},与 Python oracle 结构一致)`);
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/journey-tests.ts