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

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

package/dist/scripts/doctor-tests.js

@@ -0,0 +1,121 @@
+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 { runDoctorChecks, renderDoctorReportMd, nodeOk } from '../capabilities/doctor.js';
+import { apply } from '../src/index.js';
+const tmp = await mkdtemp(join(tmpdir(), 'gotry-doctor-test-'));
+const emptyRepo = join(tmp, 'repo-empty');
+const emptyHome = join(tmp, 'home-empty');
+await mkdir(emptyRepo, {
+    recursive: true
+});
+await mkdir(emptyHome, {
+    recursive: true
+});
+const r1 = await runDoctorChecks({
+    repoRoot: emptyRepo,
+    homeDir: emptyHome,
+    env: {}
+});
+const byId = (id)=>r1.items.find((i)=>i.id === id);
+assert.ok(byId('agent-reach'), 'agent-reach 项存在');
+assert.equal(byId('agent-reach').status, 'missing', `空仓 agent-reach=missing,实际 ${byId('agent-reach').status}`);
+assert.match(byId('agent-reach').fix ?? '', /npx gotry doctor --fix/, 'missing 项带精确补装指引');
+assert.equal(byId('extension').status, 'missing', '空 home 扩展=missing');
+assert.equal(byId('flyai').status, 'degraded', '无 key flyai=degraded(有共享试用,非缺失)');
+assert.equal(byId('llm-key').status, 'ok', 'LLM key 恒 ok(让渡面)');
+assert.equal(r1.ok, false, '有 missing 项时报告 ok=false');
+assert.match(r1.summary, /待处理/, 'summary 指明待处理项');
+console.log('1. 空 tmp 环境 → missing/degraded 分级正确,LLM key 让渡 OK');
+const repoPartial = join(tmp, 'repo-partial');
+await mkdir(join(repoPartial, '.venv/bin'), {
+    recursive: true
+});
+await writeFile(join(repoPartial, '.venv/bin/python'), '#!/bin/sh\n', {
+    mode: 0o755
+});
+const r2a = await runDoctorChecks({
+    repoRoot: repoPartial,
+    homeDir: emptyHome,
+    env: {}
+});
+assert.equal(r2a.items.find((i)=>i.id === 'agent-reach').status, 'degraded', '只 python → degraded(半可用显式区分)');
+const repoFull = join(tmp, 'repo-full');
+await mkdir(join(repoFull, '.venv/bin'), {
+    recursive: true
+});
+await writeFile(join(repoFull, '.venv/bin/python'), '#!/bin/sh\n', {
+    mode: 0o755
+});
+await writeFile(join(repoFull, '.venv/bin/agent-reach'), '#!/bin/sh\n', {
+    mode: 0o755
+});
+const r2b = await runDoctorChecks({
+    repoRoot: repoFull,
+    homeDir: emptyHome,
+    env: {}
+});
+assert.equal(r2b.items.find((i)=>i.id === 'agent-reach').status, 'ok', 'python+agent-reach 齐 → ok');
+console.log('2. .venv 三态(missing/degraded/ok)分级 OK');
+const r3 = await runDoctorChecks({
+    repoRoot: emptyRepo,
+    homeDir: emptyHome,
+    env: {
+        FLYAI_API_KEY: 'test-key'
+    }
+});
+assert.equal(r3.items.find((i)=>i.id === 'flyai').status, 'ok', '有正式 key → flyai=ok');
+console.log('3. FLYAI_API_KEY 注入 → flyai ok OK');
+assert.equal(nodeOk('22.14.0'), false, '22.14 不足');
+assert.equal(nodeOk('22.15.0'), true, '22.15 达标');
+assert.equal(nodeOk('23.0.0'), true, '23.x 达标');
+console.log('4. nodeOk 边界 OK');
+const md = renderDoctorReportMd(r1);
+assert.match(md, /# GoTry 依赖体检报告/, '报告标题');
+assert.match(md, /`npx gotry doctor --fix`/, '命令类 fix 加反引号');
+assert.match(md, /flyai\.open\.fliggy\.com 控制台申请正式 key/, 'prose 类 fix 原样呈现');
+assert.ok(!md.includes('`到 flyai'), 'prose 类 fix 不应整体包反引号');
+assert.match(md, /LLM key/, '让渡面(LLM key)照常入表');
+console.log('5. 报告渲染 OK');
+const smokeRoot = await mkdtemp(join(tmpdir(), 'gotry-doctor-state-'));
+const registered = [];
+const ctx = {
+    tools: {
+        register: (t)=>registered.push(t)
+    },
+    systemPrompt: {
+        variable: ()=>{}
+    },
+    on: ()=>()=>{}
+};
+apply(ctx, {
+    stateRoot: smokeRoot,
+    timeoutMs: 30_000,
+    hbcliBin: 'hbcli-not-on-path',
+    sessionAccess: 'ask'
+});
+const doctorTool = registered.find((t)=>t.name === 'gotry_doctor');
+assert.ok(doctorTool, 'gotry_doctor 已注册');
+const out = await doctorTool.execute({
+    query: {}
+}, null);
+assert.equal(out.ok, true, '体检工具 ok=true(体检本身成功,与依赖是否缺失无关)');
+assert.equal(out.verdict, 'needs-attention', '注入环境外仍能出 verdict(本机真实状态,不判 all-clear)');
+assert.ok(Array.isArray(out.items) && out.items.length >= 6, 'items 齐全');
+assert.ok(out.report_path && out.report_path.includes(smokeRoot), `报告落在 isolated stateRoot: ${out.report_path}`);
+const reportMd = await readFile(out.report_path, 'utf-8');
+assert.match(reportMd, /# GoTry 依赖体检报告/, '落盘报告可预览');
+await rm(tmp, {
+    recursive: true,
+    force: true
+});
+await rm(smokeRoot, {
+    recursive: true,
+    force: true
+});
+console.log('6. gotry_doctor 工具面 + 报告落盘 OK');
+console.log('doctor-tests: 全部通过');
+
+
+//# sourceURL=ts/scripts/doctor-tests.ts