@danceiny/gotry 0.0.1-rc.17 → 0.0.1-rc.19

package/dist/scripts/channel-probe-tests.js

@@ -0,0 +1,148 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile, mkdir, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { evaluateProbeResults, defaultProbes, parseArgs, main } from './channel-probe.js';
+import { readLatestChannelEvents, recordChannelEvent } from '../capabilities/channel-health.js';
+import { aggregateChannels } from './build-metrics-report.js';
+const tmp = await mkdtemp(join(tmpdir(), 'gotry-probe-test-'));
+const probes = defaultProbes();
+const hb = probes.find((p)=>p.channel === 'hbcli-hotel');
+const om = probes.find((p)=>p.channel === 'open-meteo');
+const fly = probes.find((p)=>p.channel === 'flyai');
+const now = new Date('2026-09-07T12:00:00Z');
+const evs = evaluateProbeResults([
+    {
+        probe: hb,
+        result: {
+            ok: false,
+            reason: 'auth-denied',
+            ms: 5
+        }
+    },
+    {
+        probe: om,
+        result: {
+            ok: true,
+            ms: 100
+        }
+    },
+    {
+        probe: fly,
+        result: {
+            ok: true,
+            ms: 0
+        }
+    }
+], new Set([
+    'open-meteo'
+]), now);
+assert.equal(evs.length, 2, `fail→down + ok恢复→'ok' 共 2 条,实际 ${evs.length}`);
+assert.deepEqual({
+    channel: evs[0].channel,
+    state: evs[0].state,
+    reason: evs[0].reason
+}, {
+    channel: 'hbcli-hotel',
+    state: 'down',
+    reason: 'auth-denied'
+}, 'fail 应产 down 事件带 reason');
+assert.deepEqual({
+    channel: evs[1].channel,
+    state: evs[1].state
+}, {
+    channel: 'open-meteo',
+    state: 'ok'
+}, 'ok 且此前 down 应产 ok 恢复事件');
+const noWrites = evaluateProbeResults([
+    {
+        probe: om,
+        result: {
+            ok: true,
+            ms: 90
+        }
+    }
+], new Set(), now);
+assert.equal(noWrites.length, 0, 'ok 且此前健康 → 零写放大');
+const stateRoot = join(tmp, 'state');
+await mkdir(join(stateRoot, 'gotry-state'), {
+    recursive: true
+});
+const jsonl = join(stateRoot, 'gotry-state', 'channel-health.jsonl');
+await writeFile(jsonl, [
+    JSON.stringify({
+        channel: 'opensky',
+        state: 'down',
+        reason: 'http-503',
+        at: '2026-09-07T10:00:00.000Z'
+    }),
+    JSON.stringify({
+        channel: 'opensky',
+        state: 'ok',
+        at: '2026-09-07T11:00:00.000Z'
+    }),
+    JSON.stringify({
+        channel: 'hbcli-hotel',
+        state: 'down',
+        reason: 'auth-denied',
+        at: '2026-09-07T10:30:00.000Z'
+    }),
+    'not-json-garbage',
+    ''
+].join('\n'), 'utf-8');
+const latest = await readLatestChannelEvents(stateRoot, {
+    now: Date.parse('2026-09-07T12:00:00Z')
+});
+assert.equal(latest.get('opensky')?.state, 'ok', "'ok' 应超越同通道更早的 down");
+assert.equal(latest.get('hbcli-hotel')?.state, 'down', '未恢复通道保持 down');
+assert.equal(latest.size, 2, '坏行跳过,latest 只含两通道');
+const openskyEv = latest.get('opensky');
+assert.ok(openskyEv && openskyEv.state !== 'down', 'doctor 的 down 判定应不再命中已恢复通道');
+const rows = (await readFile(jsonl, 'utf-8')).split('\n').filter((l)=>l.trim()).flatMap((l)=>{
+    try {
+        return [
+            JSON.parse(l)
+        ];
+    } catch  {
+        return [];
+    }
+});
+const stats = aggregateChannels(rows, {
+    now: new Date('2026-09-07T12:00:00Z'),
+    windowDays: 30
+});
+const openskyStat = stats.latest.find((c)=>c.channel === 'opensky');
+assert.equal(openskyStat, undefined, 'ok 超越的通道不应出现在当前 down/cooldown newest 面');
+const hbStat = stats.latest.find((c)=>c.channel === 'hbcli-hotel');
+assert.ok(hbStat && hbStat.state === 'down', '未恢复通道仍在 newest 面');
+const listed = defaultProbes();
+assert.ok(listed.find((p)=>p.channel === 'flyai')?.probeable === false, 'flyai 默认不探(共享额度)');
+assert.ok(listed.filter((p)=>p.channel.startsWith('session:')).every((p)=>!p.probeable), 'session:* 全部 skip');
+assert.deepEqual(parseArgs([
+    '--state-root',
+    '/tmp/x',
+    '--only',
+    'a, b',
+    '--dry-run'
+]), {
+    stateRoot: '/tmp/x',
+    only: [
+        'a',
+        'b'
+    ],
+    dryRun: true,
+    list: false
+}, 'parseArgs 解析');
+const rcList = await main([
+    '--list'
+]);
+assert.equal(rcList, 0, '--list exit 0');
+const rcBad = await main([
+    '--only',
+    'no-such-channel'
+]);
+assert.equal(rcBad, 2, '--only 未匹配 exit 2');
+console.log('CHANNEL PROBE TESTS: 5/5 OK(evaluate 纯函数 / latest-wins 恢复 / doctor 口径 / metrics 超越 / CLI 面)');
+
+
+//# sourceURL=ts/scripts/channel-probe-tests.ts

package/dist/scripts/channel-probe.js

@@ -0,0 +1,252 @@
+import { recordChannelEvent, readLatestChannelEvents } from '../capabilities/channel-health.js';
+function timeout(ms) {
+    return AbortSignal.timeout(ms);
+}
+async function fetchOk(url, what, ms = 8000) {
+    const t0 = Date.now();
+    try {
+        const res = await fetch(url, {
+            signal: timeout(ms),
+            headers: {
+                Accept: 'application/json'
+            }
+        });
+        if (res.ok) return {
+            ok: true,
+            ms: Date.now() - t0
+        };
+        return {
+            ok: false,
+            reason: `${what}-http-${res.status}`,
+            ms: Date.now() - t0
+        };
+    } catch (err) {
+        const msg = err instanceof Error ? err.name : String(err);
+        return {
+            ok: false,
+            reason: msg === 'TimeoutError' ? 'timeout' : 'unreachable',
+            ms: Date.now() - t0
+        };
+    }
+}
+function spawnOk(cmd, args, what, ms = 10000) {
+    return async ()=>{
+        const t0 = Date.now();
+        try {
+            const { spawn } = await import('node:child_process');
+            const child = spawn(cmd, args, {
+                stdio: [
+                    'ignore',
+                    'ignore',
+                    'ignore'
+                ]
+            });
+            const code = await new Promise((resolve, reject)=>{
+                const timer = setTimeout(()=>{
+                    child.kill('SIGKILL');
+                    reject(new Error('timeout'));
+                }, ms);
+                child.on('exit', (c)=>{
+                    clearTimeout(timer);
+                    resolve(c ?? 1);
+                });
+                child.on('error', (e)=>{
+                    clearTimeout(timer);
+                    reject(e);
+                });
+            });
+            return code === 0 ? {
+                ok: true,
+                ms: Date.now() - t0
+            } : {
+                ok: false,
+                reason: `${what}-exit-${code}`,
+                ms: Date.now() - t0
+            };
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                ok: false,
+                reason: msg === 'timeout' ? 'timeout' : 'spawn-failed',
+                ms: Date.now() - t0
+            };
+        }
+    };
+}
+export function defaultProbes() {
+    return [
+        {
+            channel: 'hbcli-hotel',
+            probeable: true,
+            run: spawnOk('hbcli', [
+                'auth',
+                'whoami'
+            ], 'auth-denied')
+        },
+        {
+            channel: 'open-meteo',
+            probeable: true,
+            run: ()=>fetchOk('https://api.open-meteo.com/v1/forecast?latitude=25.2048&longitude=55.2708&current=temperature_2m', 'weather')
+        },
+        {
+            channel: 'opensky',
+            probeable: true,
+            run: ()=>fetchOk('https://opensky-network.org/api/states/all?lamin=24.0&lomin=53.0&lamax=26.5&lomax=56.5', 'flights', 12000)
+        },
+        {
+            channel: 'flyai',
+            probeable: false,
+            skipReason: 'anonymous-shared-quota——探针烧额度弊大于利;--only flyai 显式选入',
+            run: async ()=>({
+                    ok: true,
+                    ms: 0
+                })
+        },
+        {
+            channel: 'session:ctrip-flight',
+            probeable: false,
+            skipReason: '需用户 Chrome 会话,无头不可探',
+            run: async ()=>({
+                    ok: true,
+                    ms: 0
+                })
+        },
+        {
+            channel: 'session:ctrip-hotel',
+            probeable: false,
+            skipReason: '需用户 Chrome 会话,无头不可探',
+            run: async ()=>({
+                    ok: true,
+                    ms: 0
+                })
+        },
+        {
+            channel: 'session:12306-train',
+            probeable: false,
+            skipReason: '需用户 Chrome 会话,无头不可探',
+            run: async ()=>({
+                    ok: true,
+                    ms: 0
+                })
+        },
+        {
+            channel: 'anything-geo',
+            probeable: false,
+            skipReason: '静态包通道,无远端可探',
+            run: async ()=>({
+                    ok: true,
+                    ms: 0
+                })
+        },
+        {
+            channel: 'static-hotel',
+            probeable: false,
+            skipReason: '静态包通道,无远端可探',
+            run: async ()=>({
+                    ok: true,
+                    ms: 0
+                })
+        },
+        {
+            channel: 'web-read',
+            probeable: false,
+            skipReason: '依赖 agent-reach 装配态,探测意义低;--only 显式选入可探',
+            run: async ()=>({
+                    ok: true,
+                    ms: 0
+                })
+        }
+    ];
+}
+export function evaluateProbeResults(results, priorDown, now = new Date()) {
+    const events = [];
+    for (const { probe, result } of results){
+        if (!probe.probeable) continue;
+        if (result.ok) {
+            if (priorDown.has(probe.channel)) {
+                events.push({
+                    channel: probe.channel,
+                    state: 'ok',
+                    at: now.toISOString()
+                });
+            }
+            continue;
+        }
+        events.push({
+            channel: probe.channel,
+            state: 'down',
+            reason: result.reason,
+            at: now.toISOString()
+        });
+    }
+    return events;
+}
+export function parseArgs(argv) {
+    let stateRoot;
+    let only;
+    let dryRun = false;
+    let list = false;
+    for(let i = 0; i < argv.length; i += 1){
+        const a = argv[i];
+        if (a === '--state-root') stateRoot = argv[++i];
+        else if (a === '--only') only = (argv[++i] ?? '').split(',').map((s)=>s.trim()).filter(Boolean);
+        else if (a === '--dry-run') dryRun = true;
+        else if (a === '--list') list = true;
+    }
+    return {
+        stateRoot,
+        only,
+        dryRun,
+        list
+    };
+}
+export async function main(argv) {
+    const args = parseArgs(argv);
+    const all = defaultProbes();
+    if (args.list) {
+        for (const p of all){
+            console.log(`${p.probeable ? 'probe' : 'skip '}  ${p.channel}${p.skipReason ? `  # ${p.skipReason}` : ''}`);
+        }
+        return 0;
+    }
+    const selected = args.only?.length ? all.filter((p)=>args.only.includes(p.channel)) : all.filter((p)=>p.probeable);
+    if (selected.length === 0) {
+        console.error('[channel-probe] --only 未匹配任何通道;--list 查看探测面');
+        return 2;
+    }
+    const results = [];
+    for (const probe of selected){
+        const result = await probe.run();
+        results.push({
+            probe,
+            result
+        });
+        console.log(`[channel-probe] ${result.ok ? 'ok  ' : 'FAIL'} ${probe.channel} (${result.ms}ms)${result.ok ? '' : ` reason=${result.reason}`}`);
+    }
+    const failures = results.filter((r)=>!r.result.ok).length;
+    if (args.dryRun || !args.stateRoot) {
+        if (!args.stateRoot) console.log('[channel-probe] 未给 --state-root:只探测不落账(等价 --dry-run)');
+        return failures > 0 ? 1 : 0;
+    }
+    let priorDown = new Set();
+    try {
+        const latest = await readLatestChannelEvents(args.stateRoot);
+        priorDown = new Set([
+            ...latest.entries()
+        ].filter(([, ev])=>ev.state === 'down' || ev.state === 'cooldown').map(([ch])=>ch));
+    } catch  {}
+    for (const ev of evaluateProbeResults(results, priorDown)){
+        await recordChannelEvent(args.stateRoot, ev);
+        console.log(`[channel-probe] 记录 ${ev.state} ${ev.channel}${ev.reason ? `(${ev.reason})` : ''}`);
+    }
+    return failures > 0 ? 1 : 0;
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main(process.argv.slice(2)).then((code)=>process.exit(code)).catch((err)=>{
+        console.error('[channel-probe] fatal:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}
+
+
+//# sourceURL=ts/scripts/channel-probe.ts

package/dist/scripts/channel-registry-tests.js

@@ -0,0 +1,262 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile, rm, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CHANNELS, channelsForIntent, routingAdvice, renderRoutingCard, toolRoutingHeadline, INTENT_LABELS } from '../capabilities/channel-registry.js';
+import { noteChannelVerdict, channelState, clearChannel, resetChannelHealth, recordChannelEvent, readLatestChannelEvents } from '../capabilities/channel-health.js';
+import { runDoctorChecks } from '../capabilities/doctor.js';
+import { apply } from '../src/index.js';
+const NOW = 1_700_000_000_000;
+const QUOTA_CLASSES = [
+    'user-session',
+    'user-key',
+    'anonymous-trial',
+    'free-public',
+    'static'
+];
+const TIERS = [
+    'realtime-api',
+    'session',
+    'best-effort',
+    'static'
+];
+const INTENTS = Object.keys(INTENT_LABELS);
+const ids = new Set();
+for (const c of CHANNELS){
+    assert.ok(!ids.has(c.id), `通道 id 重复:${c.id}`);
+    ids.add(c.id);
+    assert.ok(QUOTA_CLASSES.includes(c.quotaClass), `${c.id} quotaClass 越界`);
+    assert.ok(TIERS.includes(c.tier), `${c.id} tier 越界`);
+    assert.ok(c.intents.length > 0 && c.intents.every((i)=>INTENTS.includes(i)), `${c.id} intents 越界`);
+    assert.ok(c.tool.startsWith('gotry_'), `${c.id} 工具名形态`);
+    if (c.quotaClass === 'static') assert.equal(c.routable, false, '静态包不进模型可选路由');
+}
+assert.ok(CHANNELS.length >= 9, '注册表覆盖面(≥9 通道)');
+console.log('1. 注册表封闭性 OK');
+resetChannelHealth();
+assert.deepEqual(channelsForIntent('search-flight').map((c)=>c.id), [
+    'flyai',
+    'session:ctrip-flight',
+    'web-read'
+], '机票顺位');
+assert.deepEqual(channelsForIntent('search-train').map((c)=>c.id), [
+    'flyai',
+    'session:12306-train',
+    'web-read'
+], '火车顺位');
+assert.deepEqual(channelsForIntent('search-hotel').map((c)=>c.id), [
+    'flyai',
+    'hbcli-hotel',
+    'session:ctrip-hotel',
+    'web-read'
+], '酒店顺位');
+assert.deepEqual(channelsForIntent('weather').map((c)=>c.id), [
+    'open-meteo'
+], '单通道意图');
+console.log('2. 意图顺位(证据级 > 效率)OK');
+const base = routingAdvice('search-flight');
+assert.equal(base.alternatives[0].channel, 'flyai', '健康时 flyai 首荐(零 setup 摩擦)');
+assert.ok(base.alternatives[0].why.length > 4 && (base.alternatives[0].setup?.length ?? 0) > 0, 'why/setup 齐备');
+noteChannelVerdict('flyai', 'needs-setup', {
+    now: NOW
+});
+const afterDown = routingAdvice('search-flight', {
+    now: NOW
+});
+assert.ok(!afterDown.alternatives.some((a)=>a.channel === 'flyai'), 'flyai 达限后从建议表排除(#108 病灶)');
+assert.equal(afterDown.alternatives[0].channel, 'session:ctrip-flight', 'session 升首荐(优先级=健康面投影)');
+const excl = routingAdvice('search-flight', {
+    excludeChannel: 'session:ctrip-flight',
+    now: NOW
+});
+assert.ok(!excl.alternatives.some((a)=>a.channel === 'session:ctrip-flight'), '发起通道被排除');
+assert.equal(routingAdvice('search-flight', {
+    limit: 1,
+    now: NOW
+}).alternatives.length, 1, 'limit 截断');
+noteChannelVerdict('flyai', 'hit', {
+    now: NOW
+});
+assert.equal(routingAdvice('search-flight', {
+    now: NOW
+}).alternatives[0].channel, 'flyai', 'hit 即恢复(#107:补 key 不被陈旧状态锁死)');
+console.log('3. routingAdvice(down 排除/发起排除/limit/hit 恢复)OK');
+resetChannelHealth();
+assert.ok(noteChannelVerdict('x', 'needs-setup', {
+    now: NOW
+}), 'needs-setup → down 事件');
+assert.equal(channelState('x', NOW)?.state, 'down');
+assert.equal(noteChannelVerdict('x', 'challenged', {
+    now: NOW
+})?.reason, 'challenged', 'challenged → down');
+assert.equal(noteChannelVerdict('x', 'needs-login', {
+    now: NOW
+})?.reason, 'needs-login', 'needs-login → down');
+assert.equal(noteChannelVerdict('x', 'needs-extension', {
+    now: NOW
+})?.reason, 'needs-extension', 'needs-extension → down');
+assert.equal(noteChannelVerdict('x', 'miss', {
+    now: NOW
+}), undefined, '业务 miss ≠ 通道故障');
+assert.equal(noteChannelVerdict('x', 'error', {
+    now: NOW
+}), undefined, '业务 error ≠ 通道故障');
+clearChannel('x');
+assert.equal(channelState('x', NOW), undefined, '清除后无状态');
+const cd = noteChannelVerdict('y', 'cooldown', {
+    now: NOW,
+    cooldownMs: 30_000
+});
+assert.equal(cd?.state, 'cooldown', 'cooldown → cooldown 事件');
+assert.equal(channelState('y', NOW + 29_999)?.state, 'cooldown', '冷却未满仍在');
+assert.equal(channelState('y', NOW + 30_001), undefined, '冷却满惰性过期');
+console.log('4. noteChannelVerdict 映射闭集 OK');
+const card1 = renderRoutingCard(new Date(NOW));
+const card2 = renderRoutingCard(new Date(NOW));
+assert.equal(card1, card2, '同刻渲染确定');
+assert.match(card1, /检索通道顺位/, '卡头');
+assert.match(card1, /verdict≠hit/, '改道规则在卡内');
+assert.match(card1, /- 机票: .+gotry_flyai_search.+→.+gotry_session_search/, '机票顺位行');
+assert.match(card1, /- 火车: .+12306 公开查询面.+kind=train/, '火车行带 kind 消歧');
+assert.match(card1, /匿名试用=首次体验导流/, '额度口径脚注(D-7)');
+assert.ok(!card1.includes('- 天气'), '单通道意图不上卡');
+console.log('5. persona 路由卡 OK');
+const stateRoot = await mkdtemp(join(tmpdir(), 'gotry-channel-test-'));
+const realNow = Date.now();
+await recordChannelEvent(stateRoot, {
+    channel: 'flyai',
+    state: 'down',
+    reason: 'needs-setup',
+    at: new Date(realNow - 86_400_000).toISOString()
+});
+await recordChannelEvent(stateRoot, {
+    channel: 'flyai',
+    state: 'down',
+    reason: 'needs-setup',
+    at: new Date(realNow).toISOString()
+});
+await recordChannelEvent(stateRoot, {
+    channel: 'session:ctrip-flight',
+    state: 'cooldown',
+    at: new Date(realNow).toISOString()
+});
+const latest = await readLatestChannelEvents(stateRoot);
+assert.equal(latest.get('flyai')?.at, new Date(realNow).toISOString(), '每通道取最新');
+assert.equal(latest.get('session:ctrip-flight')?.state, 'cooldown');
+await recordChannelEvent(stateRoot, {
+    channel: 'legacy',
+    state: 'down',
+    at: new Date(realNow - 40 * 86_400_000).toISOString()
+});
+assert.ok(!(await readLatestChannelEvents(stateRoot)).has('legacy'), '40 天前事件被 limitDays 过滤');
+const raw = `${stateRoot}/gotry-state/channel-health.jsonl`;
+await writeFile(raw, `${await readFile(raw, 'utf-8')}not-json\n{"half":true}\n`, 'utf-8');
+assert.equal((await readLatestChannelEvents(stateRoot)).size, 2, '坏行容忍');
+console.log('6. JSONL 持久面 OK');
+const emptyRepo = join(stateRoot, 'repo');
+const emptyHome = join(stateRoot, 'home');
+await mkdir(emptyRepo, {
+    recursive: true
+});
+await mkdir(join(emptyHome, '.gotry'), {
+    recursive: true
+});
+const calStatePath = join(emptyHome, '.gotry', 'calendar.json');
+const d1 = await runDoctorChecks({
+    repoRoot: emptyRepo,
+    homeDir: emptyHome,
+    env: {},
+    stateRoot
+});
+assert.match(d1.items.find((i)=>i.id === 'flyai').detail, /最近一次试用达限/, '最近达限时间进 doctor(#107 可见性)');
+assert.equal(d1.items.find((i)=>i.id === 'calendar').status, 'ok', 'calendar 默认不挂载=ok(D-9)');
+assert.match(d1.items.find((i)=>i.id === 'calendar').detail, /默认未挂载/, '默认态人话');
+await writeFile(calStatePath, JSON.stringify({
+    enabled: true
+}), 'utf-8');
+const d2 = await runDoctorChecks({
+    repoRoot: emptyRepo,
+    homeDir: emptyHome,
+    env: {}
+});
+assert.equal(d2.items.find((i)=>i.id === 'calendar').status, 'degraded', 'setup 开启但未配置 username=degraded');
+assert.match(d2.items.find((i)=>i.id === 'calendar').fix ?? '', /npx gotry setup calendar/, 'fix 指向 setup 状态面');
+const profileDir = join(emptyHome, '.dsh/profiles/web');
+await mkdir(profileDir, {
+    recursive: true
+});
+await writeFile(join(profileDir, 'cordis.patch.yml'), '- id: dsh-calendar\n  config:\n    username: someone\n', 'utf-8');
+const d3 = await runDoctorChecks({
+    repoRoot: emptyRepo,
+    homeDir: emptyHome,
+    env: {}
+});
+assert.equal(d3.items.find((i)=>i.id === 'calendar').status, 'ok', 'setup 开启且已配置=ok');
+const d4 = await runDoctorChecks({
+    repoRoot: emptyRepo,
+    homeDir: emptyHome,
+    env: {}
+});
+assert.ok(!/最近一次试用达限/.test(d4.items.find((i)=>i.id === 'flyai').detail), '无 stateRoot 不读持久面(向后兼容)');
+const mapItem = d4.items.find((i)=>i.id === 'map-tools');
+const askItem = d4.items.find((i)=>i.id === 'ask-user');
+assert.equal(mapItem.status, 'missing', '隔离环境 map-tools=missing(静默剔除面可见)');
+assert.match(mapItem.detail, /静默剔除/, 'map-tools detail 说明静默剔除语义');
+assert.equal(askItem.status, 'missing', '隔离环境 ask-user=missing');
+assert.match(askItem.detail, /散文追问/, 'ask-user detail 说明退化面');
+console.log('7. doctor 集成(flyai 配额可见 + calendar setup 状态面三态 + 宿主插件两态)OK');
+resetChannelHealth();
+const variables = {};
+const registered = [];
+const ctx = {
+    tools: {
+        register: (t)=>registered.push(t)
+    },
+    systemPrompt: {
+        variable: (name, provider)=>{
+            variables[name] = provider;
+        }
+    },
+    on: ()=>()=>{}
+};
+apply(ctx, {
+    stateRoot,
+    timeoutMs: 30_000,
+    hbcliBin: 'hbcli-not-on-path',
+    sessionAccess: 'ask'
+});
+assert.equal(typeof variables.channel_routing_card, 'function', 'channel_routing_card 变量已注册');
+assert.match(variables.channel_routing_card(), /检索通道顺位/, '卡片可渲染');
+const pastDate = await registered.find((t)=>t.name === 'gotry_flyai_search').execute({
+    kind: 'flight',
+    from: '深圳',
+    to: '普吉',
+    date: '2026-01-01'
+}, null);
+assert.ok(!('routing' in pastDate), '参数级预校验拒绝不带 routing(未发起检索,无改道语义)');
+const legacyBlob = await registered.find((t)=>t.name === 'gotry_flyai_search').execute({
+    query: {
+        kind: 'flight',
+        from: '深圳',
+        to: '普吉',
+        date: '2026-01-01'
+    }
+}, null);
+assert.ok(legacyBlob.ok === false && !('routing' in legacyBlob) && !!legacyBlob.evidence, 'legacy blob → 结构化拒绝(ToolFailure,无 routing)');
+const flyaiTool = registered.find((t)=>t.name === 'gotry_flyai_search');
+const doctorToolDesc = registered.find((t)=>t.name === 'gotry_doctor');
+assert.ok(flyaiTool, 'flyai 工具已注册');
+assert.match(toolRoutingHeadline('gotry_flyai_search'), /机票: 飞猪官方 API\(gotry_flyai_search\) → 携程·用户登录态/, 'flyai 首行卡:机票顺位 flyai 在前(证据级)');
+assert.match(toolRoutingHeadline('gotry_session_search'), /火车: .*12306 公开查询面\(gotry_session_search kind=train\)/, 'session 首行卡带 kind 消歧');
+assert.equal(toolRoutingHeadline('gotry_doctor'), '', '非检索工具无首行卡(原样描述)');
+assert.ok(flyaiTool.description?.startsWith('本工具服务的检索意图与通道顺位'), 'flyai 描述已前置首行卡(接线生效)');
+assert.ok(!doctorToolDesc.description?.startsWith('本工具服务的检索意图'), 'doctor 描述无首行卡(接线不误伤)');
+console.log('8. apply 接线 + 描述首行生成 OK');
+await rm(stateRoot, {
+    recursive: true,
+    force: true
+});
+console.log('channel-registry-tests: 全部通过');
+
+
+//# sourceURL=ts/scripts/channel-registry-tests.ts