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

package/dist/scripts/travel-timeline-tests.js

@@ -1,123 +1,59 @@
+/**
+ * 旅行时间线单测(memory-design P1,travel_timeline.v1):
+ * 守门(必填/绝对日期/幂等/重叠冲突即停)/投影/交叉一致(verified 无 timeline 缺口)。
+ * 运行:cd ts && npx tsx scripts/travel-timeline-tests.ts
+ */
 import assert from 'node:assert/strict';
 import { appendTrip, makeTripId, projectTimeline, timelineGapsForVerified, resolveTimelineDate } from '../src/travel-timeline.js';
 import { buildTimeAnchor } from '../src/time-anchor.js';
-const anchor = buildTimeAnchor(new Date(2026, 7, 28, 12));
+const anchor = buildTimeAnchor(new Date(2026, 7, 28, 12)); // 2026-08-28
 let n = 0;
 function pass(name, body) {
     body();
     console.log(`  ${++n}. ${name} OK`);
 }
-pass('守门:必填与绝对日期(不猜)', ()=>{
-    const ev = {
-        destination: '大理',
-        start: '2025-10-01',
-        source: 'user-verbatim',
-        evidence: '用户原话'
-    };
-    assert.equal(appendTrip([], {
-        ...ev,
-        destination: ''
-    }).appended, false, '无目的地拒');
-    assert.equal(appendTrip([], {
-        ...ev,
-        evidence: ''
-    }).appended, false, '无 evidence 拒(溯源 P0)');
-    assert.ok(appendTrip([], {
-        ...ev,
-        start: '下周一'
-    }).reason?.includes('YYYY-MM-DD'), '词表外日期拒收(不猜)');
-    assert.ok(appendTrip([], {
-        ...ev,
-        end: '2025-09-30'
-    }).reason?.includes('end 早于 start'), 'end<start 拒');
+pass('守门:必填与绝对日期(不猜)', () => {
+    const ev = { destination: '大理', start: '2025-10-01', source: 'user-verbatim', evidence: '用户原话' };
+    assert.equal(appendTrip([], { ...ev, destination: '' }).appended, false, '无目的地拒');
+    assert.equal(appendTrip([], { ...ev, evidence: '' }).appended, false, '无 evidence 拒(溯源 P0)');
+    assert.ok(appendTrip([], { ...ev, start: '下周一' }).reason?.includes('YYYY-MM-DD'), '词表外日期拒收(不猜)');
+    assert.ok(appendTrip([], { ...ev, end: '2025-09-30' }).reason?.includes('end 早于 start'), 'end<start 拒');
 });
-pass('幂等:同目的地+start+source = 同一行程 no-op', ()=>{
-    const ev = {
-        destination: '大理',
-        start: '2025-10-01',
-        source: 'user-verbatim',
-        evidence: '原话'
-    };
+pass('幂等:同目的地+start+source = 同一行程 no-op', () => {
+    const ev = { destination: '大理', start: '2025-10-01', source: 'user-verbatim', evidence: '原话' };
     const r1 = appendTrip([], ev);
     assert.equal(r1.appended, true);
-    const r2 = appendTrip(r1.events, {
-        ...ev,
-        evidence: '换个说法再说一遍'
-    });
+    const r2 = appendTrip(r1.events, { ...ev, evidence: '换个说法再说一遍' });
     assert.equal(r2.appended, false, '同 trip_id 重放 no-op');
     assert.equal(r2.tripId, r1.tripId);
 });
-pass('重叠冲突即停:同目的地日期区间重叠拒收', ()=>{
-    const r1 = appendTrip([], {
-        destination: '大理',
-        start: '2025-10-01',
-        end: '2025-10-05',
-        source: 'user-verbatim',
-        evidence: '原话'
-    });
-    const r2 = appendTrip(r1.events, {
-        destination: '大理',
-        start: '2025-10-04',
-        source: 'user-verbatim',
-        evidence: '原话2'
-    });
+pass('重叠冲突即停:同目的地日期区间重叠拒收', () => {
+    const r1 = appendTrip([], { destination: '大理', start: '2025-10-01', end: '2025-10-05', source: 'user-verbatim', evidence: '原话' });
+    const r2 = appendTrip(r1.events, { destination: '大理', start: '2025-10-04', source: 'user-verbatim', evidence: '原话2' });
     assert.equal(r2.appended, false);
     assert.ok(r2.reason?.includes('重叠'), '冲突理由说明');
 });
-pass('日期解析:锚点卡词表进、词表外 null(经 resolveTimelineDate)', ()=>{
+pass('日期解析:锚点卡词表进、词表外 null(经 resolveTimelineDate)', () => {
     assert.equal(resolveTimelineDate('2025-10-01', anchor), '2025-10-01');
     assert.equal(resolveTimelineDate('去年国庆', anchor), null, '开放表达不猜');
 });
-pass('投影:start 倒序(最近在前)', ()=>{
+pass('投影:start 倒序(最近在前)', () => {
     let evs = [];
-    evs = appendTrip(evs, {
-        destination: '普吉',
-        start: '2026-07-10',
-        source: 'user-verbatim',
-        evidence: 'a'
-    }).events;
-    evs = appendTrip(evs, {
-        destination: '大理',
-        start: '2025-10-01',
-        source: 'user-verbatim',
-        evidence: 'b'
-    }).events;
+    evs = appendTrip(evs, { destination: '普吉', start: '2026-07-10', source: 'user-verbatim', evidence: 'a' }).events;
+    evs = appendTrip(evs, { destination: '大理', start: '2025-10-01', source: 'user-verbatim', evidence: 'b' }).events;
     const p = projectTimeline(evs);
     assert.equal(p[0]?.destination, '普吉');
     assert.equal(p.length, 2);
 });
-pass('交叉一致:verified wish 无 timeline = 缺口暴露(巡检口径,不自动补写)', ()=>{
-    const evs = appendTrip([], {
-        destination: '大理',
-        start: '2025-10-01',
-        source: 'wish-confirmed',
-        evidence: 'wish w1 confirm'
-    }).events;
+pass('交叉一致:verified wish 无 timeline = 缺口暴露(巡检口径,不自动补写)', () => {
+    const evs = appendTrip([], { destination: '大理', start: '2025-10-01', source: 'wish-confirmed', evidence: 'wish w1 confirm' }).events;
     const gaps = timelineGapsForVerified(evs, [
-        {
-            wishId: 'w1',
-            destination: '大理'
-        },
-        {
-            wishId: 'w2',
-            destination: '清迈'
-        }
-    ]);
-    assert.deepEqual(gaps, [
-        {
-            wishId: 'w2'
-        }
+        { wishId: 'w1', destination: '大理' },
+        { wishId: 'w2', destination: '清迈' },
     ]);
+    assert.deepEqual(gaps, [{ wishId: 'w2' }]);
 });
-pass('trip_id 语义派生:确定性可重放', ()=>{
-    assert.equal(makeTripId({
-        destination: '大 理',
-        start: '2025-10-01',
-        source: 'user-verbatim',
-        evidence: 'x'
-    }), '大_理|2025-10-01|user-verbatim');
+pass('trip_id 语义派生:确定性可重放', () => {
+    assert.equal(makeTripId({ destination: '大 理', start: '2025-10-01', source: 'user-verbatim', evidence: 'x' }), '大_理|2025-10-01|user-verbatim');
 });
 console.log(`\nTRAVEL TIMELINE TESTS: ${n}/7 OK(memory-design P1 守门面)`);
-
-
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/travel-timeline-tests.ts

package/dist/scripts/turn-handoff-collect-tests.js

@@ -0,0 +1,169 @@
+/**
+ * turn-handoff 收集器闭环测试(ADR-24 v2 收集半段)。
+ * 假 planner(node 脚本)驱动:成功/失败/空输出/幂等复诵零重算/--all/
+ * 缺单;并断言递归防护真的传进了子进程(GOTRY_HANDOFF_CHILD=1 且父进程
+ * 的数值 pin/工单根被清除)。全程隔离 stateRoot,不触真实 gotry-state。
+ */
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { listTurnHandoffTickets, settleTurnHandoffTicket, writeTurnHandoffTicket } from '../src/turn-deadline.js';
+const TS_DIR = join(import.meta.dirname, '..');
+const TSX = join(TS_DIR, 'node_modules', 'tsx', 'dist', 'cli.mjs');
+function runCollector(args, env = {}) {
+    // 用 execFileSync 的同步抓取替代 spawn 手工聚合,行为等价且断言更直接。
+    try {
+        const stdout = execFileSync(process.execPath, [TSX, 'scripts/turn-handoff-collect.ts', ...args], {
+            cwd: TS_DIR,
+            env: { ...process.env, ...env },
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return { status: 0, stdout, stderr: '' };
+    }
+    catch (error) {
+        const e = error;
+        return { status: e.status ?? null, stdout: e.stdout ?? '', stderr: e.stderr ?? '' };
+    }
+}
+const root = mkdtempSync(join(tmpdir(), 'gotry-handoff-collect-'));
+const planners = mkdtempSync(join(tmpdir(), 'gotry-handoff-planners-'));
+const plannerCalls = join(planners, 'calls.log');
+// ok:记录调用环境(递归防护证据)→ 输出交付物
+const okPlanner = join(planners, 'ok.mjs');
+writeFileSync(okPlanner, `import { appendFileSync } from 'node:fs'
+appendFileSync(${JSON.stringify(plannerCalls)}, [
+  'call child=' + process.env.GOTRY_HANDOFF_CHILD,
+  'pin=' + (process.env.GOTRY_TURN_DEADLINE_SOFT_MS ?? 'CLEARED'),
+  'root=' + (process.env.GOTRY_TURN_HANDOFF_ROOT ?? 'CLEARED'),
+  'msg=' + process.argv[2]?.slice(0, 12),
+].join(' | ') + '\\n')
+console.log('# 规划结果\\n方案A:9.26 DXB→CAN,10.3 衡阳婚礼,10.5 返程')
+`);
+const failPlanner = join(planners, 'fail.mjs');
+writeFileSync(failPlanner, `import { appendFileSync } from 'node:fs'
+appendFileSync(${JSON.stringify(plannerCalls)}, 'call fail\\n')
+process.exit(3)
+`);
+const emptyPlanner = join(planners, 'empty.mjs');
+writeFileSync(emptyPlanner, `import { appendFileSync } from 'node:fs'
+appendFileSync(${JSON.stringify(plannerCalls)}, 'call empty\\n')
+`);
+const calls = () => (existsSync(plannerCalls) ? readFileSync(plannerCalls, 'utf-8').trim().split('\n') : []);
+try {
+    // 1) 缺单 → exit 1
+    assert.equal(runCollector(['th-missing', root]).status, 1);
+    // 2) 成功回收:planner 恰跑一次,工单 settled,交付物含方案,终态 JSON
+    const t1 = await writeTurnHandoffTicket(root, '帮我规划10.3衡阳婚礼十几天行程');
+    {
+        const r = runCollector([t1.id, root], { GOTRY_HANDOFF_PLANNER_BIN: okPlanner });
+        assert.equal(r.status, 0, `stderr=${r.stderr}`);
+        const terminal = JSON.parse(r.stdout.trim().split('\n').at(-1));
+        assert.equal(terminal['schema'], 'gotry_turn_handoff_terminal.v1');
+        assert.equal(terminal['status'], 'succeeded');
+        assert.ok(String(terminal['deliverable_path']).includes(`${t1.id}.deliverable.md`));
+    }
+    const t1After = JSON.parse(readFileSync(join(root, 'gotry-state', 'turn-handoffs', `${t1.id}.json`), 'utf8'));
+    assert.equal(t1After['status'], 'settled');
+    assert.ok(t1After['settledAt']);
+    const deliverable1 = readFileSync(join(root, 'gotry-state', 'turn-handoffs', `${t1.id}.deliverable.md`), 'utf8');
+    assert.ok(deliverable1.includes('方案A') && deliverable1.includes(t1.id));
+    // 3) 幂等复诵:重跑 exit 0,同交付物,planner 零重算
+    {
+        const before = calls().length;
+        const r = runCollector([t1.id, root], { GOTRY_HANDOFF_PLANNER_BIN: okPlanner });
+        assert.equal(r.status, 0);
+        const terminal = JSON.parse(r.stdout.trim().split('\n').at(-1));
+        assert.equal(terminal['status'], 'succeeded');
+        assert.equal(calls().length, before, 'settled ticket must not re-run the planner');
+    }
+    // 4) 递归防护证据:ok planner 记录的子环境
+    {
+        const last = [...calls()].reverse().find(l => l.includes('child='));
+        assert.ok(last, 'planner ran');
+        assert.ok(last.includes('child=1'), `GOTRY_HANDOFF_CHILD must be 1: ${last}`);
+        assert.ok(last.includes('pin=CLEARED'), `parent deadline pins must be cleared: ${last}`);
+        assert.ok(last.includes('root=CLEARED'), `parent handoff root must be cleared: ${last}`);
+        assert.ok(last.includes('msg=帮我规划10.3衡阳婚礼'), 'planner receives the verbatim user ask');
+    }
+    // 5) 失败回收:exit 2,工单 failed + error,交付物是诚实失败说明
+    const t2 = await writeTurnHandoffTicket(root, '另一趟失败的规划');
+    {
+        const r = runCollector([t2.id, root], { GOTRY_HANDOFF_PLANNER_BIN: failPlanner });
+        assert.equal(r.status, 2);
+        const terminal = JSON.parse(r.stdout.trim().split('\n').at(-1));
+        assert.equal(terminal['status'], 'failed');
+        assert.ok(String(terminal['error']).startsWith('planner exited 3'), `error shape: ${terminal['error']}`);
+    }
+    const t2After = JSON.parse(readFileSync(join(root, 'gotry-state', 'turn-handoffs', `${t2.id}.json`), 'utf8'));
+    assert.equal(t2After['status'], 'failed');
+    assert.ok(String(t2After['error']).startsWith('planner exited 3'));
+    const deliverable2 = readFileSync(join(root, 'gotry-state', 'turn-handoffs', `${t2.id}.deliverable.md`), 'utf8');
+    assert.ok(deliverable2.includes('没有完成') && deliverable2.includes('planner exited 3'), 'honest failure note');
+    // 失败复诵:exit 2,零重算
+    {
+        const before = calls().length;
+        assert.equal(runCollector([t2.id, root], { GOTRY_HANDOFF_PLANNER_BIN: failPlanner }).status, 2);
+        assert.equal(calls().length, before);
+    }
+    // 6) 空输出 → failed
+    const t3 = await writeTurnHandoffTicket(root, '空输出的规划');
+    {
+        const r = runCollector([t3.id, root], { GOTRY_HANDOFF_PLANNER_BIN: emptyPlanner });
+        assert.equal(r.status, 2);
+        const terminal = JSON.parse(r.stdout.trim().split('\n').at(-1));
+        assert.equal(terminal['error'], 'planner produced empty output');
+    }
+    // 7) --all:只收 open(t4/t5),已终态的 t1/t2/t3 零重算。
+    // t4/t5 同毫秒创建会让「最新优先」断言 flaky(requestedAt 毫秒精度);
+    // 把 t5 钉到 now+5s,排序严格确定。
+    const t4 = await writeTurnHandoffTicket(root, '批量规划一');
+    const t5 = await writeTurnHandoffTicket(root, '批量规划二');
+    {
+        const dir = join(root, 'gotry-state', 'turn-handoffs');
+        const t5json = JSON.parse(readFileSync(join(dir, `${t5.id}.json`), 'utf8'));
+        writeFileSync(join(dir, `${t5.id}.json`), JSON.stringify({
+            ...t5json,
+            requestedAt: new Date(Date.now() + 5_000).toISOString(),
+        }));
+    }
+    {
+        const before = calls().length;
+        const r = runCollector(['--all', root], { GOTRY_HANDOFF_PLANNER_BIN: okPlanner });
+        assert.equal(r.status, 0, `stderr=${r.stderr}`);
+        const terminal = JSON.parse(r.stdout.trim().split('\n').at(-1));
+        assert.equal(terminal['status'], 'succeeded');
+        assert.equal(calls().length, before + 2, 'exactly the two open tickets collected');
+    }
+    // 8) --all 无 open → exit 0
+    assert.equal(runCollector(['--all', root], { GOTRY_HANDOFF_PLANNER_BIN: okPlanner }).status, 0);
+    // 9) 复访视图:倒序 + settled 摘录 + failed 错误
+    {
+        const views = await listTurnHandoffTickets(root);
+        assert.equal(views.length, 5);
+        assert.equal(views[0].id, t5.id, 'newest first');
+        const settled = views.find(v => v.id === t1.id);
+        assert.equal(settled.status, 'settled');
+        assert.ok(settled.deliverableExcerpt?.includes('方案A'));
+        const failed = views.find(v => v.id === t2.id);
+        assert.equal(failed.status, 'failed');
+        assert.ok(failed.error?.startsWith('planner exited 3'));
+    }
+    console.log('turn handoff collector tests: OK (settle/fail/empty/idempotent replay/--all/recursion guard env/revisit views)');
+}
+finally {
+    rmSync(root, { recursive: true, force: true });
+    rmSync(planners, { recursive: true, force: true });
+}
+// settleTurnHandoffTicket 直接契约(不经 collector):原子写 + 字段完整
+{
+    const r = mkdtempSync(join(tmpdir(), 'gotry-handoff-settle-'));
+    const t = await writeTurnHandoffTicket(r, '直调结算');
+    const { deliverablePath } = await settleTurnHandoffTicket(r, t, 'settled', '交付内容');
+    assert.ok(existsSync(deliverablePath));
+    const views = await listTurnHandoffTickets(r);
+    assert.equal(views[0].deliverableExcerpt, '交付内容');
+    rmSync(r, { recursive: true, force: true });
+}

package/dist/scripts/turn-handoff-collect.js

@@ -0,0 +1,161 @@
+/**
+ * 后台深度规划工单收集器(ADR-24 v2 收集闭环;async-collect 的 turn-handoff 对位)。
+ *
+ * 「一小时后回来看看」的后台半段:加载 open 工单 → 以 GOTRY_HANDOFF_CHILD=1
+ * 派生 headless 规划会话(唯一出口 converge,不回递归)→ 捕获最终答复为
+ * 交付物 → settleTurnHandoffTicket 结算(交付物 .deliverable.md + 工单状态
+ * 原子更新)。终态幂等:已 settled/failed 的工单复诵交付物与终态 JSON,零
+ * 重算、零再花。最后一行固定输出 gotry_turn_handoff_terminal.v1 JSON;
+ * succeeded exit 0,failed exit 2。
+ *
+ * 运行(在 ts/ 下):
+ *   npx tsx scripts/turn-handoff-collect.ts <ticketId> [stateRoot]
+ *   npx tsx scripts/turn-handoff-collect.ts --all [stateRoot]
+ * 环境变量:
+ *   GOTRY_HANDOFF_PLANNER_BIN      规划器二进制(默认 <repo>/bin/gotry-inner.js)
+ *   GOTRY_HANDOFF_PLANNER_TIMEOUT_MS 规划器硬上限(默认 900_000)
+ *
+ * v1 诚实边界:工单只携带用户原文,规划会话是全新上下文(fresh cwd/DSH_HOME)
+ * ——原会话中已读的工作区文件/日历结论不随单迁移,由规划器按需重取。
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { listTurnHandoffTickets, settleTurnHandoffTicket, TURN_HANDOFF_SCHEMA, } from '../src/turn-deadline.js';
+const TURN_HANDOFF_TERMINAL_SCHEMA = 'gotry_turn_handoff_terminal.v1';
+const ROOT = join(import.meta.dirname, '..', '..');
+function emitTerminal(outcome) {
+    console.log(JSON.stringify(outcome));
+    process.exit(outcome.status === 'succeeded' ? 0 : 2);
+}
+function loadTicket(stateRoot, ticketId) {
+    try {
+        const path = join(stateRoot === '.' ? process.cwd() : stateRoot, 'gotry-state', 'turn-handoffs', `${ticketId}.json`);
+        const ticket = JSON.parse(readFileSync(path, 'utf-8'));
+        return ticket?.schema === TURN_HANDOFF_SCHEMA ? ticket : null;
+    }
+    catch {
+        return null;
+    }
+}
+function replay(ticket, stateRoot) {
+    const dir = join(stateRoot === '.' ? process.cwd() : stateRoot, 'gotry-state', 'turn-handoffs');
+    emitTerminal({
+        schema: TURN_HANDOFF_TERMINAL_SCHEMA,
+        ticket_id: ticket.id,
+        status: ticket.status === 'settled' ? 'succeeded' : 'failed',
+        ...(ticket.deliverableFile ? { deliverable_path: join(dir, ticket.deliverableFile) } : {}),
+        ...(ticket.error ? { error: ticket.error } : {}),
+    });
+}
+async function runPlanner(ticket) {
+    const plannerBin = process.env.GOTRY_HANDOFF_PLANNER_BIN ?? join(ROOT, 'bin', 'gotry-inner.js');
+    if (!existsSync(plannerBin)) {
+        return { ok: false, output: '', error: `planner binary unavailable: ${plannerBin}` };
+    }
+    const timeoutMs = Number.parseInt(process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS ?? '', 10) || 900_000;
+    const dshHome = mkdtempSync(join(tmpdir(), 'gotry-handoff-child-dsh-'));
+    const childCwd = mkdtempSync(join(tmpdir(), 'gotry-handoff-child-cwd-'));
+    try {
+        const childEnv = { ...process.env };
+        childEnv.DSH_HOME = dshHome;
+        // 递归防护(核心):子会话唯一出口 converge + 长 leash;同时清掉父进程的
+        // 数值 pin 与工单根,子会话不得再 handoff、也不受测试阈值影响。
+        childEnv.GOTRY_HANDOFF_CHILD = '1';
+        delete childEnv.GOTRY_TURN_DEADLINE_SOFT_MS;
+        delete childEnv.GOTRY_TURN_DEADLINE_HARD_MS;
+        delete childEnv.GOTRY_TURN_HANDOFF_ROOT;
+        // .js/.mjs/.cjs 经当前 node 派生(测试假 planner 无执行位也成立);
+        // 其余(gotry-inner.js 之外的 .bin shim、全局命令)直接执行。
+        const isJsScript = /\.(js|mjs|cjs)$/.test(plannerBin);
+        const child = isJsScript
+            ? spawn(process.execPath, [plannerBin, ticket.userMessage], { cwd: childCwd, env: childEnv, stdio: ['ignore', 'pipe', 'pipe'] })
+            : spawn(plannerBin, [ticket.userMessage], { cwd: childCwd, env: childEnv, stdio: ['ignore', 'pipe', 'pipe'] });
+        let output = '';
+        child.stdout.on('data', chunk => { output += chunk.toString(); });
+        child.stderr.on('data', chunk => { output += chunk.toString(); });
+        const code = await new Promise(resolve => {
+            const timer = setTimeout(() => { child.kill('SIGKILL'); resolve(null); }, timeoutMs);
+            child.once('exit', c => { clearTimeout(timer); resolve(c); });
+        });
+        if (code === null)
+            return { ok: false, output: '', error: `planner timed out after ${timeoutMs}ms` };
+        if (code !== 0)
+            return { ok: false, output: '', error: `planner exited ${code}: ${output.trim().slice(-300)}` };
+        const deliverable = output.trim();
+        if (!deliverable)
+            return { ok: false, output: '', error: 'planner produced empty output' };
+        return { ok: true, output: deliverable };
+    }
+    finally {
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rmSync(dshHome, { recursive: true, force: true });
+        rmSync(childCwd, { recursive: true, force: true });
+    }
+}
+async function collectOne(stateRoot, ticketId) {
+    const ticket = loadTicket(stateRoot, ticketId);
+    if (!ticket) {
+        console.error(`工单 ${ticketId} 不存在(${stateRoot}/gotry-state/turn-handoffs/)`);
+        process.exit(1);
+    }
+    if (ticket.status !== 'open') {
+        console.error(`工单 ${ticketId} 已是终态 ${ticket.status},复诵不重算:`);
+        replay(ticket, stateRoot);
+    }
+    const result = await runPlanner(ticket);
+    const deliverable = result.ok
+        ? `# 后台深度规划交付:${ticket.objective.slice(0, 60)}\n(工单 ${ticket.id},原请求 ${ticket.requestedAt})\n\n${result.output}`
+        : `# 后台深度规划失败:${ticket.objective.slice(0, 60)}\n(工单 ${ticket.id},原请求 ${ticket.requestedAt})\n\n未产出交付物:${result.error ?? '未知原因'}。这趟规划没有完成——请重新发起,失败原因如上,无部分结果可交付。`;
+    const { deliverablePath } = await settleTurnHandoffTicket(stateRoot, ticket, result.ok ? 'settled' : 'failed', deliverable, result.ok ? undefined : result.error);
+    console.error(`工单 ${ticket.id} ${result.ok ? '已交付' : '失败'}:${deliverablePath}`);
+    emitTerminal({
+        schema: TURN_HANDOFF_TERMINAL_SCHEMA,
+        ticket_id: ticket.id,
+        status: result.ok ? 'succeeded' : 'failed',
+        ...(result.ok
+            ? { deliverable_path: deliverablePath }
+            : { error: result.error ?? 'unknown' }),
+    });
+}
+async function collectAll(stateRoot) {
+    const open = (await listTurnHandoffTickets(stateRoot)).filter(t => t.status === 'open');
+    if (open.length === 0) {
+        console.error('无待回收的后台规划工单(open=0)');
+        process.exit(0);
+    }
+    let failed = 0;
+    for (const view of open) {
+        const ticket = loadTicket(stateRoot, view.id);
+        if (!ticket || ticket.status !== 'open')
+            continue;
+        const result = await runPlanner(ticket);
+        const deliverable = result.ok
+            ? `# 后台深度规划交付:${ticket.objective.slice(0, 60)}\n(工单 ${ticket.id},原请求 ${ticket.requestedAt})\n\n${result.output}`
+            : `# 后台深度规划失败:${ticket.objective.slice(0, 60)}\n(工单 ${ticket.id},原请求 ${ticket.requestedAt})\n\n未产出交付物:${result.error ?? '未知原因'}。这趟规划没有完成——请重新发起,失败原因如上,无部分结果可交付。`;
+        const { deliverablePath } = await settleTurnHandoffTicket(stateRoot, ticket, result.ok ? 'settled' : 'failed', deliverable, result.ok ? undefined : result.error);
+        console.error(`工单 ${ticket.id} ${result.ok ? '已交付' : '失败'}:${deliverablePath}`);
+        if (!result.ok)
+            failed += 1;
+    }
+    console.log(JSON.stringify({
+        schema: TURN_HANDOFF_TERMINAL_SCHEMA,
+        ticket_id: `--all(${open.length})`,
+        status: failed === 0 ? 'succeeded' : 'failed',
+        error: failed === 0 ? undefined : `${failed}/${open.length} 张工单回收失败`,
+    }));
+    process.exit(failed === 0 ? 0 : 2);
+}
+const [target, stateRootArg] = process.argv.slice(2);
+const stateRoot = stateRootArg ?? '.';
+if (target === '--all') {
+    await collectAll(stateRoot);
+}
+else if (target) {
+    await collectOne(stateRoot, target);
+}
+else {
+    console.error('用法:npx tsx scripts/turn-handoff-collect.ts <ticketId|--all> [stateRoot]');
+    process.exit(1);
+}

package/dist/scripts/turn-policy-tests.js

@@ -0,0 +1,55 @@
+/**
+ * Turn routing & policy table tests (ADR-24 v2).
+ * 分类器是纯函数(Tier 0,零 LLM 零 IO),表测锁定 v1 规则面;
+ * 首条 fixture 是 2026-09-02 失败轨迹的用户原文——canonical 深规划
+ * case 必须命中 deep-planning,这是整个重设计的回归锚点。
+ */
+import assert from 'node:assert/strict';
+import { classifyTurn, extractTurnSignals, TURN_POLICIES, turnPolicyFor, } from '../src/turn-policy.js';
+// ---- 分类表(规则面快照) ---------------------------------------------------
+// 失败轨迹原文:13 天行程 + 10.3 婚礼 + 请假 + IRW → 必须转后台。
+const TRAJECTORY_MESSAGE = '2026年我还有6天IRW额度 ,我准备再请几天假,在国内待个十几天。'
+    + '其中10.3要去湖南衡阳参加同学婚礼。其他我没有特别的要求,请根据我的实际情况,偏好,外部环境等因素,给我安排行程';
+assert.equal(classifyTurn(TRAJECTORY_MESSAGE), 'deep-planning');
+assert.equal(classifyTurn('9.26到10.12在国内玩,中间要参加同学婚礼'), 'deep-planning'); // 双绝对日期+约束,跨度16天
+assert.equal(classifyTurn('国庆请假带父母去新疆,大概十几天'), 'deep-planning'); // 跨度词+双约束
+assert.equal(classifyTurn('帮我查一下明天深圳的天气'), 'quick');
+assert.equal(classifyTurn('你好'), 'quick');
+assert.equal(classifyTurn('帮我看看10.1去杭州的高铁票'), 'sync-planning'); // 单日期零约束 → 默认中间档
+assert.equal(classifyTurn('3天后出发,帮我查下天气'), 'sync-planning'); // 短跨度词 → 不进 quick 也不进 deep
+assert.equal(classifyTurn('把这段翻译成英文:会议纪要如下……省略若干字'.repeat(3)), 'sync-planning'); // 长但零信号
+// ---- 信号提取 ---------------------------------------------------------------
+const full = extractTurnSignals('2026-10-03 出发');
+assert.deepEqual(full.absoluteDates, [{ year: 2026, month: 10, day: 3 }]);
+const md = extractTurnSignals('10月3日到衡阳,10.5回深圳');
+assert.equal(md.absoluteDates.length, 2);
+assert.equal(md.spanDays, 2);
+assert.deepEqual(md.absoluteDates[0], { year: null, month: 10, day: 3 });
+// 无效月/日过滤;时间(冒号)与版本号外的数字不产日期
+assert.equal(extractTurnSignals('13.45 与 22:40 都是数字').absoluteDates.length, 0);
+// 跨度词:按强度取先
+assert.equal(extractTurnSignals('待十几天').spanDays, 12);
+assert.equal(extractTurnSignals('待半个月').spanDays, 15);
+assert.equal(extractTurnSignals('待一个月').spanDays, 30);
+assert.equal(extractTurnSignals('大概两周').spanDays, 14);
+assert.equal(extractTurnSignals('大概一周').spanDays, 7);
+assert.equal(extractTurnSignals('还有6天额度').spanDays, 6);
+assert.equal(extractTurnSignals('没有跨度').spanDays, null);
+// 绝对日期 ≥2 时跨度词不参与
+const both = extractTurnSignals('10.1 到 10.9 玩十几天');
+assert.equal(both.spanDays, 8);
+// 约束词:命中去重、按词表序
+assert.deepEqual(extractTurnSignals('婚礼加IRW,还要请假').constraintHits, ['婚礼', 'IRW', '请假']);
+assert.deepEqual(extractTurnSignals('没有任何约束词在这里').constraintHits, []);
+// user 消息里最常见的误触:quick 判据必须同时满足零日期/零约束/零跨度/短
+assert.equal(classifyTurn('10.3 婚礼那天衡阳天气怎么样?穿什么'), 'sync-planning'); // 有日期+约束 → 不冒进 quick
+// ---- policy 表 ---------------------------------------------------------------
+assert.equal(TURN_POLICIES['deep-planning'].exit, 'handoff');
+assert.equal(TURN_POLICIES['sync-planning'].exit, 'converge');
+assert.equal(TURN_POLICIES['quick'].exit, 'converge');
+for (const policy of Object.values(TURN_POLICIES)) {
+    assert.ok(policy.hardMs > policy.softMs, 'hard must exceed soft');
+    assert.ok(policy.softMs > 0 && policy.hardMs > 0);
+}
+assert.deepEqual(turnPolicyFor('quick'), TURN_POLICIES['quick']);
+console.log('turn policy tests: OK (routing table incl. trajectory verbatim, date/span extraction, policy shape)');