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

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)');

package/dist/scripts/typed-contract-canary.js

@@ -0,0 +1,176 @@
+/**
+ * D-30 普通模型 canary 运行器(issue #112 验收,tool-orchestration-design §4⑥)。
+ *
+ * 量什么:普通 LLM 面对投影后的工具 JSON Schema,能否**一次成型**产出合法参数——
+ * 这是 typed 参数契约迁移(D-30)要解决的核心问题(blob 时代强弱模型差距全部
+ * 暴露在「猜参数形状」上)。
+ *
+ * 怎么量:真实 LLM(env 三件套 LLM_API_KEY/LLM_BASE_URL/LLM_MODEL,或仓库 .env)
+ * + 工具投影 schema(defineTool 后的 parameters,与模型所见完全一致)+ tool_choice
+ * 强制单工具 → 模型出参 → `validateJsonSchemaValue`(与 dsh defineTool execute 前
+ * 同款校验)→ 违例为零 = 该例一次成型。
+ *
+ * 不执行工具:零检索副作用、零站点请求——canary 只量参数形态,不量业务结果。
+ *
+ * 达标线:工具调用一次成型率 ≥90%(10 例容 1 失);语义正确性(城市/日期/kind)
+ * 作为二级信号同报,不进门。
+ *
+ * 运行(在仓根或 ts/):LLM 三件套已配 → npx tsx ts/scripts/typed-contract-canary.ts
+ */
+import assert from 'node:assert/strict';
+import { readFileSync, existsSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validateJsonSchemaValue } from '@deepseek-ai/dsh-tools';
+import { apply } from '../src/index.js';
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+// --- LLM 三件套:env 优先,回退仓库 .env(只取值,永不回显) ---
+function loadEnvTriple() {
+    const env = process.env;
+    let key = env.LLM_API_KEY ?? '';
+    let base = env.LLM_BASE_URL ?? '';
+    let model = env.LLM_MODEL ?? '';
+    const envFile = join(ROOT, '.env');
+    if (existsSync(envFile)) {
+        for (const line of readFileSync(envFile, 'utf-8').split('\n')) {
+            const m = /^([A-Z_]+)=(.*)$/.exec(line.trim());
+            if (!m)
+                continue;
+            const [, k, v] = m;
+            if (k === 'LLM_API_KEY' && !key)
+                key = v.trim();
+            if (k === 'LLM_BASE_URL' && !base)
+                base = v.trim();
+            if (k === 'LLM_MODEL' && !model)
+                model = v.trim();
+        }
+    }
+    assert.ok(key && base && model, 'LLM_API_KEY/LLM_BASE_URL/LLM_MODEL 必须已配(env 或 .env)');
+    return { key, base, model };
+}
+// --- 捕获插件注册表(隔离 stateRoot:canary 不写任何共享状态;sessionAccess=off 免审批) ---
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-canary-state-'));
+const registered = [];
+const ctx = {
+    tools: { register: (t) => registered.push(t) },
+    systemPrompt: { variable: () => () => '' },
+    on: () => () => { },
+};
+apply(ctx, { stateRoot, timeoutMs: 30_000, hbcliBin: 'hbcli-not-on-path', sessionAccess: 'off' });
+const byName = (n) => {
+    const t = registered.find(x => x.name === n);
+    assert.ok(t, `工具 ${n} 应已注册`);
+    return t;
+};
+const CASES = [
+    { label: '机·票(城市对+日期)', tool: 'gotry_flyai_search', prompt: '帮我查一下 10 月 1 日从上海飞丽江的机票' },
+    { label: '火车票', tool: 'gotry_flyai_search', prompt: '10 月 1 日上海到昆明的火车票帮我查一下' },
+    { label: '酒店(带档期)', tool: 'gotry_flyai_search', prompt: '查一下大理 10 月 1 日入住、10 月 3 日退房的酒店' },
+    { label: '酒店(摸底,无档期)', tool: 'gotry_flyai_search', prompt: '先看看大理有哪些酒店' },
+    { label: '天气预报', tool: 'gotry_weather_check', prompt: '大理这几天天气怎么样' },
+    { label: '酒店实时源(hbcli)', tool: 'gotry_hotel_search', prompt: '查一下大理的酒店,入住下周五,住三晚' },
+    { label: '会话面机票(登录态)', tool: 'gotry_session_search', prompt: '用我的携程账号查 10 月 1 日上海到丽江的机票' },
+    { label: '目的地候选库', tool: 'gotry_anything_search', prompt: '大连在你们的目的地库里吗?帮我查一下' },
+    { label: 'GitHub 搜索', tool: 'gotry_github_search', prompt: '在 GitHub 上搜一下 agent-reach 这个项目' },
+    { label: '网页读取', tool: 'gotry_web_search', prompt: '帮我读一下 https://example.com 这个页面的内容' },
+];
+async function callLlmMessages(cfg, toolName, messages) {
+    const tool = byName(toolName);
+    const url = `${cfg.base.replace(/\/+$/, '')}/chat/completions`;
+    const body = {
+        model: cfg.model,
+        messages,
+        tools: [{ type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.parameters } }],
+        tool_choice: { type: 'function', function: { name: tool.name } },
+        temperature: 0,
+    };
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${cfg.key}` },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(60_000),
+    });
+    const bodyText = await res.text();
+    assert.equal(res.status, 200, `LLM HTTP ${res.status}: ${bodyText.slice(0, 200)}`);
+    const j = JSON.parse(bodyText);
+    const msg = j.choices?.[0]?.message;
+    const tc = msg.tool_calls?.[0];
+    if (!tc?.function?.arguments) {
+        const text = String(msg.content ?? '');
+        assert.ok(/年份|日期|确认|2024|2025|2026/.test(text), `模型既未调工具也未按拒绝指引向用户确认: ${text.slice(0, 120)}`);
+        return { args: undefined, callId: 'text-reply', text, textReply: true };
+    }
+    return { args: JSON.parse(tc.function.arguments), callId: tc.id ?? 'canary-call', textReply: false };
+}
+async function main() {
+    const cfg = loadEnvTriple();
+    console.log(`typed-contract canary:model=${cfg.model} 已配(值不回显);用例 ${CASES.length} 条,达标线 ≥90% 一次成型\n`);
+    let pass = 0;
+    const failures = [];
+    for (const c of CASES) {
+        const tool = byName(c.tool);
+        process.stdout.write(`- ${c.label} → ${c.tool} … `);
+        try {
+            const { args } = await callLlmMessages(cfg, c.tool, [
+                { role: 'system', content: '你是 GoTry 旅行助手。需要查数据时必须调用提供的工具,参数从用户话里取,不要编造。' },
+                { role: 'user', content: c.prompt },
+            ]);
+            const violations = validateJsonSchemaValue(tool.parameters, args);
+            if (violations.length === 0) {
+                pass++;
+                console.log(`PASS 一次成型 ${JSON.stringify(args).slice(0, 120)}`);
+            }
+            else {
+                failures.push(`${c.label}: schema 违例 ${violations.join(';')}`);
+                console.log(`FAIL schema 违例: ${violations.join(';').slice(0, 160)}`);
+            }
+        }
+        catch (e) {
+            failures.push(`${c.label}: ${e.message.slice(0, 160)}`);
+            console.log(`FAIL ${e.message.slice(0, 140)}`);
+        }
+    }
+    // ---------------------------------------------------------------
+    // 验收②(issue #140):畸形/越界调用被宿主权拒绝后,模型按 violations 自纠。
+    // 确定性播种:预置一次带过去日期的被拒调用与结构化拒绝结果(tool 角色),
+    // 验证模型从拒绝中自纠出「schema 合规 + 日期非过去」的参数。只校验不执行(零副作用)。
+    // ---------------------------------------------------------------
+    {
+        const tool = byName('gotry_flyai_search');
+        const today = new Date().toISOString().slice(0, 10);
+        try {
+            const messages = [
+                { role: 'system', content: '你是 GoTry 旅行助手。需要查数据时必须调用提供的工具,参数从用户话里取,不要编造。' },
+                { role: 'user', content: '帮我查一下 10 月 1 日从上海飞丽江的机票' },
+                { role: 'assistant', content: null, tool_calls: [{ id: 'seed-reject', type: 'function', function: { name: 'gotry_flyai_search', arguments: JSON.stringify({ kind: 'flight', from: '上海', to: '丽江', date: '2024-10-01' }) } }] },
+                { role: 'tool', tool_call_id: 'seed-reject', content: JSON.stringify({ ok: false, verdict: 'error', summary: `未发起查询:日期 2024-10-01 已是过去(今天 ${today}),过去不存在在售机票。多为用户时间表达未带年份所致——向用户确认年份(或按未来最近的同月日修正)后再查。` }) },
+            ];
+            const reply = await callLlmMessages(cfg, 'gotry_flyai_search', messages);
+            const violations = reply.args ? validateJsonSchemaValue(tool.parameters, reply.args) : [];
+            if (reply.textReply) {
+                assert.match(reply.text ?? '', /年份|日期|确认/, '文字形态应向用户确认年份/日期(契约允许的自纠)');
+                console.log('自纠回路(验收②):模型按拒绝指引转为向用户确认年份(文字形态,契约允许)');
+            }
+            else {
+                assert.equal(violations.length, 0, `自纠出参 schema 违例: ${violations.join(';')}`);
+                assert.ok(reply.args && reply.args.date && reply.args.date >= today, `自纠后日期应为今天或未来,实际 ${JSON.stringify(reply.args).slice(0, 80)}`);
+                console.log(`自纠回路(验收②):模型按拒绝自纠出参 → PASS(${JSON.stringify(reply.args).slice(0, 100)})`);
+            }
+        }
+        catch (e) {
+            failures.push(`验收② 自纠回路异常: ${e.message.slice(0, 140)}`);
+            console.log(`FAIL 自纠回路异常(计入失败,不中断报告): ${e.message.slice(0, 140)}`);
+        }
+    }
+    const rate = Math.round((pass / CASES.length) * 100);
+    console.log(`\n一次成型率:${pass}/${CASES.length} = ${rate}%(达标线 90%)`);
+    if (failures.length)
+        console.log('失败明细:\n' + failures.map(f => `  - ${f}`).join('\n'));
+    if (rate < 90) {
+        console.error('TYPED CONTRACT CANARY FAIL(不达标不合入)');
+        process.exit(1);
+    }
+    console.log('TYPED CONTRACT CANARY OK');
+}
+await main();

package/dist/scripts/tz-resolver-sanity.js

@@ -0,0 +1,50 @@
+// Quick sanity check for tz-resolver. Run with: TZ=UTC npx tsx scripts/tz-resolver-sanity.ts
+import { resolveOffsetForLocalDate } from '../src/tz-resolver.js';
+const cases = [
+    // Asia/Shanghai has no DST throughout the year
+    ['Asia/Shanghai', '2026-07-18', '14:45', 480],
+    ['Asia/Shanghai', '2026-01-01', '09:00', 480],
+    ['Asia/Tokyo', '2026-07-04', '09:00', 540],
+    ['Asia/Hong_Kong', '2026-07-18', '14:45', 480],
+    ['Asia/Bangkok', '2026-08-09', '23:55', 420],
+    ['Asia/Singapore', '2026-08-09', '23:55', 480],
+    ['Asia/Dubai', '2026-07-18', '00:45', 240],
+    // America/New_York DST: EST = -5, EDT = -4. 2026 spring-forward = 2026-03-08, fall-back = 2026-11-01
+    ['America/New_York', '2026-03-07', '14:00', -300], // day before spring forward -> EST
+    ['America/New_York', '2026-03-09', '14:00', -240], // day after spring forward -> EDT
+    ['America/New_York', '2026-06-15', '09:00', -240], // summer -> EDT
+    ['America/New_York', '2026-12-15', '09:00', -300], // winter -> EST
+    ['America/Los_Angeles', '2026-06-15', '14:00', -420],
+    ['UTC', '2026-07-18', '12:00', 0],
+    ['Europe/London', '2026-06-15', '14:00', 60],
+    ['Europe/London', '2026-01-15', '14:00', 0],
+];
+let ok = 0, fail = 0;
+for (const [zone, ymd, hhmm, expected] of cases) {
+    const r = resolveOffsetForLocalDate(zone, ymd, hhmm);
+    const pass = r.ok && r.offsetMin === expected;
+    if (pass)
+        ok++;
+    else {
+        fail++;
+        console.log('FAIL', zone, ymd, hhmm, 'expected', expected, 'got', r.ok ? r.offsetMin : r);
+    }
+}
+const negatives = [
+    ['Foo/Bar', '2026-07-18', '14:45', 'unknown_zone'],
+    ['America/New_York', '2026-03-08', '02:30', 'gap_nonexistent'], // spring forward day
+    ['America/New_York', '2026-11-01', '01:30', 'overlap_ambiguous'], // fall back day
+];
+for (const [zone, ymd, hhmm, expected] of negatives) {
+    const r = resolveOffsetForLocalDate(zone, ymd, hhmm);
+    const pass = !r.ok && r.kind === expected;
+    if (pass)
+        ok++;
+    else {
+        fail++;
+        console.log('FAIL', zone, ymd, hhmm, 'expected', expected, 'got', r.ok ? `ok(${r.offsetMin})` : r.kind);
+    }
+}
+console.log(`\n${ok}/${ok + fail} sanity ok`);
+if (fail > 0)
+    process.exit(1);