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

package/dist/scripts/sf-live-benchmark.js

@@ -0,0 +1,338 @@
+import { mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { evaluateDoubleSource, SESSION_FIELD_ACCURACY_THRESHOLD } from '../capabilities/session/benchmark.js';
+import { sessionFlightSearch } from '../capabilities/session-search.js';
+import { flyaiSearch } from '../capabilities/flyai.js';
+import { loadStaticFlightSnapshot, parseGoldenSource, resolveStaticGolden } from '../capabilities/session/static-flight-golden.js';
+import { scoreSessionAgainstGoldenBand } from '../capabilities/session/golden-score.js';
+function loadFlightQueries() {
+    const golden = JSON.parse(readFileSync(join(import.meta.dirname, '..', 'data', 'session-golden-20.json'), 'utf8'));
+    return golden.queries.filter((q)=>q.id.startsWith('sf-')).slice(0, 8);
+}
+function loadManualGolden() {
+    return JSON.parse(readFileSync(join(import.meta.dirname, '..', 'data', 'sf-golden-manifest.json'), 'utf8'));
+}
+function manualToRecord(m, sample) {
+    return {
+        query_id: m.query_id,
+        route_segments: [
+            {
+                from: m.from,
+                to: m.to,
+                departure_at: `${m.date}T${sample.depTime}:00+08:00`,
+                arrival_at: `${m.date}T${sample.arrTime}:00+08:00`,
+                transport_number: sample.flightNo
+            }
+        ],
+        journey_type: 'direct',
+        currency: 'CNY',
+        price: sample.price,
+        source: 'manual-golden',
+        fetched_at: new Date().toISOString(),
+        verdict: 'hit',
+        latency_ms: 0,
+        read_guard_blocked: 0
+    };
+}
+async function flyaiOfficial(q) {
+    const started = Date.now();
+    try {
+        const r = await flyaiSearch({
+            kind: 'flight',
+            origin: q.from,
+            destination: q.to,
+            depDate: q.date,
+            timeoutMs: 30_000
+        });
+        const latencyMs = Date.now() - started;
+        if (r.ok && r.options && r.options.length > 0) {
+            const sorted = r.options.slice().sort((a, b)=>Date.parse(a.depDateTime) - Date.parse(b.depDateTime));
+            const opt = sorted[0];
+            const rec = {
+                query_id: q.id,
+                route_segments: [
+                    {
+                        from: q.from,
+                        to: q.to,
+                        departure_at: opt.depDateTime,
+                        arrival_at: opt.arrDateTime,
+                        transport_number: opt.no
+                    }
+                ],
+                journey_type: 'direct',
+                currency: 'CNY',
+                price: opt.price,
+                source: 'flyai',
+                fetched_at: new Date().toISOString(),
+                verdict: 'hit',
+                latency_ms: latencyMs,
+                read_guard_blocked: 0
+            };
+            return {
+                record: rec,
+                latencyMs
+            };
+        }
+        return {
+            record: {
+                ...emptyOfficialRecord(q, 'flyai'),
+                latency_ms: latencyMs,
+                verdict: 'error'
+            },
+            latencyMs,
+            error: r.error ?? 'no options'
+        };
+    } catch (e) {
+        return {
+            record: emptyOfficialRecord(q, 'flyai'),
+            latencyMs: Date.now() - started,
+            error: e instanceof Error ? e.message : String(e)
+        };
+    }
+}
+function manualOfficial(q, manifest) {
+    const started = Date.now();
+    const m = manifest.matches.find((x)=>x.query_id === q.id);
+    if (!m) return {
+        record: emptyOfficialRecord(q, 'manual-golden'),
+        latencyMs: Date.now() - started
+    };
+    const depMedian = hhmmMid(m.window_dep_local.earliest, m.window_dep_local.latest);
+    const arrMedian = hhmmMid(m.window_arr_local.earliest, m.window_arr_local.latest);
+    const priceMedian = Math.round((m.price_cny.min + m.price_cny.max) / 2);
+    return {
+        record: manualToRecord(m, {
+            depTime: depMedian,
+            arrTime: arrMedian,
+            flightNo: m.known_flights[0] ?? '',
+            price: priceMedian
+        }),
+        latencyMs: Date.now() - started
+    };
+}
+function hhmmMid(a, b) {
+    const aMin = parseInt(a.split(':')[0], 10) * 60 + parseInt(a.split(':')[1], 10);
+    const bMin = parseInt(b.split(':')[0], 10) * 60 + parseInt(b.split(':')[1], 10);
+    const mid = Math.round((aMin + bMin) / 2);
+    return `${Math.floor(mid / 60).toString().padStart(2, '0')}:${(mid % 60).toString().padStart(2, '0')}`;
+}
+function emptyOfficialRecord(q, source) {
+    return {
+        query_id: q.id,
+        route_segments: [],
+        journey_type: 'direct',
+        currency: '',
+        price: 0,
+        source,
+        fetched_at: new Date().toISOString(),
+        verdict: 'error',
+        latency_ms: 0,
+        read_guard_blocked: 0
+    };
+}
+async function runOne(q, requestedSource, manifest, staticContext) {
+    const startedAt = new Date().toISOString();
+    let official = null;
+    let officialLatencyMs = null;
+    let effectiveSource = requestedSource === 'manual' ? 'manual-golden' : requestedSource;
+    let fallbackReason = null;
+    let estimatedFields = [];
+    let officialProvenance = null;
+    if (requestedSource === 'manual') {
+        const m = manualOfficial(q, manifest);
+        official = m.record;
+        officialLatencyMs = m.latencyMs;
+    } else if (requestedSource === 'flyai') {
+        const r = await flyaiOfficial(q);
+        official = r.record;
+        officialLatencyMs = r.latencyMs;
+    } else {
+        const started = Date.now();
+        const manual = manualOfficial(q, manifest);
+        const resolution = resolveStaticGolden({
+            query: q,
+            manualRecord: manual.record ?? emptyOfficialRecord(q, 'manual-golden'),
+            snapshot: staticContext.snapshot,
+            snapshotError: staticContext.error,
+            warn: (message)=>console.error(message)
+        });
+        official = resolution.record;
+        officialLatencyMs = Date.now() - started;
+        effectiveSource = resolution.effective_source;
+        fallbackReason = resolution.fallback_reason ?? null;
+        estimatedFields = resolution.estimated_fields;
+        officialProvenance = resolution.provenance;
+    }
+    const sessStarted = Date.now();
+    const sessRes = await sessionFlightSearch({
+        from: q.from,
+        to: q.to,
+        date: q.date,
+        timeoutMs: 25_000
+    });
+    const sessionLatencyMs = Date.now() - sessStarted;
+    const sessionVerdict = sessRes.verdict;
+    const sessionError = sessRes.error;
+    let session = null;
+    if (sessRes.verdict === 'hit' && sessRes.options && sessRes.options.length > 0) {
+        const sorted = sessRes.options.slice().sort((a, b)=>Date.parse(a.depDateTime) - Date.parse(b.depDateTime));
+        const opt = sorted[0];
+        session = {
+            query_id: q.id,
+            route_segments: [
+                {
+                    from: q.from,
+                    to: q.to,
+                    departure_at: opt.depDateTime,
+                    arrival_at: opt.arrDateTime,
+                    transport_number: opt.flightNo
+                }
+            ],
+            journey_type: 'direct',
+            currency: 'CNY',
+            price: opt.price,
+            source: 'ctrip-flight',
+            fetched_at: new Date().toISOString(),
+            verdict: 'hit',
+            latency_ms: sessionLatencyMs,
+            read_guard_blocked: 0
+        };
+    } else {
+        session = {
+            query_id: q.id,
+            route_segments: [],
+            journey_type: 'direct',
+            currency: '',
+            price: 0,
+            source: 'ctrip-flight',
+            fetched_at: new Date().toISOString(),
+            verdict: sessRes.verdict === 'hit' || sessRes.verdict === 'miss' ? sessRes.verdict : 'error',
+            latency_ms: sessionLatencyMs,
+            read_guard_blocked: 0
+        };
+    }
+    const doubleSource = evaluateDoubleSource({
+        official: official ?? undefined,
+        session: session ?? undefined
+    });
+    let softResult = null;
+    const m = manifest.matches.find((x)=>x.query_id === q.id);
+    if (session?.verdict === 'hit' && m) {
+        softResult = scoreSessionAgainstGoldenBand(session, m, effectiveSource);
+    }
+    return {
+        query_id: q.id,
+        expected: {
+            from: q.from,
+            to: q.to,
+            date: q.date,
+            kind: q.kind
+        },
+        requested_source: requestedSource,
+        effective_source: effectiveSource,
+        fallback_reason: fallbackReason,
+        estimated_fields: estimatedFields,
+        official_provenance: officialProvenance,
+        official,
+        official_source: effectiveSource,
+        session,
+        doubleSource,
+        softScore: softResult,
+        officialLatencyMs,
+        sessionLatencyMs,
+        sessionVerdict: String(sessionVerdict),
+        sessionError,
+        started_at: startedAt
+    };
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const requestedSource = parseGoldenSource(args);
+    const queries = loadFlightQueries();
+    if (queries.length < 8) {
+        console.error(`金标准 sf-* 不足 8 条(实际 ${queries.length})`);
+        process.exit(1);
+    }
+    const manifest = loadManualGolden();
+    const staticContext = {};
+    if (requestedSource === 'static') {
+        try {
+            staticContext.snapshot = loadStaticFlightSnapshot();
+        } catch (error) {
+            staticContext.error = error instanceof Error ? error.message : String(error);
+        }
+    }
+    const sourceDescription = requestedSource === 'manual' ? '手工 golden (sf-golden-manifest.json,零网络零 vendor)' : requestedSource === 'flyai' ? 'flyai (FlyAI 官方)' : 'static (OpenFlights route/carrier + manual time/price band,估算字段显式标注)';
+    console.log(`[sf-live-benchmark] requested official source = ${sourceDescription}`);
+    console.log(`[sf-live-benchmark] 阈值:字段准确率 ≥${SESSION_FIELD_ACCURACY_THRESHOLD * 100}%(软命中)`);
+    const runStartedAt = new Date().toISOString();
+    const runStartedMs = Date.now();
+    const records = [];
+    for (const q of queries){
+        if (records.length > 0) await new Promise((r)=>setTimeout(r, 35_000));
+        console.log(`\n[sf-live-benchmark] ${q.id} ${q.from}→${q.to} ${q.date}`);
+        const rec = await runOne(q, requestedSource, manifest, staticContext);
+        records.push(rec);
+        const evPath = join(homedir(), '.gotry', 'evidence', 'session', q.id, `${runStartedAt.replace(/[:.]/g, '-')}.json`);
+        mkdirSync(dirname(evPath), {
+            recursive: true
+        });
+        writeFileSync(evPath, JSON.stringify(rec, null, 2));
+        console.log(`  official(requested=${rec.requested_source},effective=${rec.effective_source}): verdict=${rec.official?.verdict ?? '-'} latency=${rec.officialLatencyMs ?? 0}ms${rec.fallback_reason ? ` fallback=${rec.fallback_reason}` : ''}`);
+        console.log(`  session(ctrip): verdict=${rec.sessionVerdict} latency=${rec.sessionLatencyMs ?? 0}ms${rec.sessionError ? ` err=${rec.sessionError.slice(0, 80)}` : ''}`);
+        console.log(`  doubleSource: state=${rec.doubleSource.state} quota=${rec.doubleSource.quota_disposition} price_delta=${rec.doubleSource.price_delta ?? '-'} mismatches=${rec.doubleSource.mismatches.length}`);
+        if (rec.softScore) {
+            console.log(`  soft score: ${(rec.softScore.accuracy * 100).toFixed(1)}% (${rec.softScore.correct}/${rec.softScore.total}) ${rec.softScore.pass ? '✅' : '❌'} missing=${JSON.stringify(rec.softScore.missing)} incorrect=${JSON.stringify(rec.softScore.incorrect)}`);
+        }
+    }
+    const accuracy_pass = records.filter((r)=>r.softScore?.pass === true).length;
+    const comparable = records.filter((r)=>r.doubleSource.state === 'comparable').length;
+    const hit = records.filter((r)=>r.sessionVerdict === 'hit').length;
+    const challenge = records.filter((r)=>r.sessionVerdict === 'challenged' || r.doubleSource.state === 'challenge_stop' || r.doubleSource.state === 'guard_violation').length;
+    const no_data = records.filter((r)=>r.official?.verdict !== 'hit' || r.sessionVerdict !== 'hit' && r.sessionVerdict !== 'challenged').length;
+    const live_under_15s = records.filter((r)=>r.sessionLatencyMs !== null && r.sessionVerdict === 'hit' && r.sessionLatencyMs < 15_000).length;
+    const effectiveSources = Array.from(new Set(records.map((record)=>record.effective_source)));
+    const fallbackCount = records.filter((record)=>record.fallback_reason !== null).length;
+    const summary = {
+        started_at: runStartedAt,
+        duration_ms: Date.now() - runStartedMs,
+        threshold: SESSION_FIELD_ACCURACY_THRESHOLD,
+        total: records.length,
+        accuracy_pass,
+        comparable,
+        hit,
+        challenge,
+        no_data,
+        live_under_15s,
+        requested_source: requestedSource,
+        effective_sources: effectiveSources,
+        fallback_count: fallbackCount,
+        golden_source: requestedSource === 'manual' ? 'manual-golden' : requestedSource,
+        records
+    };
+    const summaryPath = join(homedir(), '.gotry', 'evidence', 'session', 'sf-summary', `${runStartedAt.replace(/[:.]/g, '-')}.json`);
+    mkdirSync(dirname(summaryPath), {
+        recursive: true
+    });
+    writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
+    console.log(`\n──── sf-live-benchmark 汇总 ────`);
+    console.log(`golden requested = ${summary.requested_source}`);
+    console.log(`golden effective = ${summary.effective_sources.join(',')};fallback=${summary.fallback_count}`);
+    console.log(`跑批 query 数: ${records.length}`);
+    console.log(`verdict=hit: ${hit}/${records.length}`);
+    console.log(`双源合同=comparable: ${comparable}/${records.length}`);
+    console.log(`字段准确率 ≥${SESSION_FIELD_ACCURACY_THRESHOLD * 100}% (软命中): ${accuracy_pass}/${records.filter((r)=>r.softScore !== null).length}`);
+    console.log(`live <15s (hit): ${live_under_15s}/${hit || 0}`);
+    console.log(`challenge/guard 触发: ${challenge}`);
+    console.log(`总耗时: ${summary.duration_ms}ms`);
+    process.exit(0);
+}
+main().catch((e)=>{
+    console.error(`[sf-live-benchmark] 异常: ${e instanceof Error ? e.message : String(e)}`);
+    console.error(e instanceof Error ? e.stack : '');
+    process.exit(1);
+});
+
+
+//# sourceURL=ts/scripts/sf-live-benchmark.ts

package/dist/scripts/sf-live-cli-tests.js

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+const tsxCli = join(import.meta.dirname, '..', 'node_modules', 'tsx', 'dist', 'cli.mjs');
+const runner = join(import.meta.dirname, 'sf-live-benchmark.ts');
+const unknown = spawnSync(process.execPath, [
+    tsxCli,
+    runner,
+    '--golden=ctrip-open'
+], {
+    cwd: join(import.meta.dirname, '..'),
+    encoding: 'utf8',
+    timeout: 5_000
+});
+assert.equal(unknown.status, 1, `未知 vendor 应在网络调用前 exit 1，实际 status=${unknown.status} error=${unknown.error?.message ?? '-'}`);
+assert.match(unknown.stderr, /不支持的 golden vendor: ctrip-open/);
+assert.equal(unknown.stdout.includes('sf-01 上海→丽江'), false, 'fail-closed 前不得启动任何 query');
+console.log('SF LIVE CLI TESTS: unknown vendor fail-closed before network OK');
+
+
+//# sourceURL=ts/scripts/sf-live-cli-tests.ts

package/dist/scripts/sf-soft-score-tests.js

@@ -0,0 +1,108 @@
+import assert from 'node:assert/strict';
+const modulePath = '../capabilities/session/golden-score.js';
+const scorer = await import(modulePath).catch(()=>({}));
+assert.equal(typeof scorer.scoreSessionAgainstGoldenBand, 'function', 'soft score 必须从 live runner 抽出，static provider 才能走同一离线评分合同');
+const band = {
+    query_id: 'sf-01',
+    from: '上海',
+    to: '丽江',
+    date: '2026-10-01',
+    window_dep_local: {
+        earliest: '06:00',
+        latest: '22:00'
+    },
+    window_arr_local: {
+        earliest: '10:00',
+        latest: '23:59'
+    },
+    duration_min: {
+        min: 180,
+        max: 720
+    },
+    price_cny: {
+        min: 800,
+        max: 4000
+    },
+    transport_hint: '公开班期承运提示',
+    known_flights: [
+        'HO5577',
+        'MU6145',
+        '9C8779'
+    ]
+};
+const session = {
+    query_id: 'sf-01',
+    route_segments: [
+        {
+            from: '上海',
+            to: '丽江',
+            departure_at: '2026-10-01T06:45:00+08:00',
+            arrival_at: '2026-10-01T10:15:00+08:00',
+            transport_number: 'MU6145'
+        }
+    ],
+    journey_type: 'direct',
+    currency: 'CNY',
+    price: 1200,
+    source: 'ctrip-flight',
+    fetched_at: '2026-08-30T12:00:00.000Z',
+    verdict: 'hit',
+    latency_ms: 1200,
+    read_guard_blocked: 0
+};
+const score = scorer.scoreSessionAgainstGoldenBand(session, band, 'static-openflights+manual-band');
+assert.deepEqual(score, {
+    pass: true,
+    total: 13,
+    correct: 13,
+    accuracy: 1,
+    missing: [],
+    incorrect: [],
+    golden_source: 'static-openflights+manual-band'
+});
+const wrongOrigin = scorer.scoreSessionAgainstGoldenBand({
+    ...session,
+    route_segments: [
+        {
+            ...session.route_segments[0],
+            from: '广州'
+        }
+    ]
+}, band, 'static-openflights+manual-band');
+assert.equal(wrongOrigin.accuracy, 12 / 13);
+assert.equal(wrongOrigin.pass, false, 'from/to 是硬字段；高于 90% 也不能放过错误 OD');
+assert.deepEqual(wrongOrigin.incorrect, [
+    'route_segments[0].from'
+]);
+const missingPrice = scorer.scoreSessionAgainstGoldenBand({
+    ...session,
+    price: 0
+}, band, 'static-openflights+manual-band');
+assert.equal(missingPrice.total, 13, '价格缺失不能靠缩小分母抬高准确率');
+assert.equal(missingPrice.pass, false);
+assert.deepEqual(missingPrice.missing, [
+    'price'
+]);
+const wrongDate = scorer.scoreSessionAgainstGoldenBand({
+    ...session,
+    route_segments: [
+        {
+            ...session.route_segments[0],
+            departure_at: '2026-10-02T06:45:00+08:00',
+            arrival_at: '2026-10-02T10:15:00+08:00'
+        }
+    ]
+}, band, 'static-openflights+manual-band');
+assert.equal(wrongDate.pass, false, '仅 HH:mm 落窗但服务日期错误时必须 fail-closed');
+assert.ok(wrongDate.incorrect.includes('route_segments[0].departure_at.date'));
+assert.ok(wrongDate.incorrect.includes('route_segments[0].arrival_at.date'));
+const wrongSessionSource = scorer.scoreSessionAgainstGoldenBand({
+    ...session,
+    source: 'manual-golden'
+}, band, 'static-openflights+manual-band');
+assert.equal(wrongSessionSource.pass, false, 'golden 自身不能冒充待核验的 Ctrip session 来源');
+assert.ok(wrongSessionSource.incorrect.includes('source'));
+console.log('SF SOFT SCORE TESTS: fixed 13-field score + hard OD/date/session-source fail-closed OK');
+
+
+//# sourceURL=ts/scripts/sf-soft-score-tests.ts

package/dist/scripts/sf-summary.js

@@ -0,0 +1,93 @@
+import { mkdirSync, writeFileSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { SESSION_FIELD_ACCURACY_THRESHOLD } from '../capabilities/session/benchmark.js';
+const evidenceRoot = join(homedir(), '.gotry', 'evidence', 'session');
+function main() {
+    const out = {
+        started_at: new Date().toISOString(),
+        total: 0,
+        threshold: SESSION_FIELD_ACCURACY_THRESHOLD,
+        accuracy_pass: 0,
+        accuracy_eligible: 0,
+        comparable: 0,
+        hit: 0,
+        challenge: 0,
+        live_under_15s: 0,
+        sources: {
+            manual_golden_query_ids: [],
+            flyai_query_ids: []
+        },
+        records: []
+    };
+    for(let i = 1; i <= 8; i += 1){
+        const q = `sf-${i.toString().padStart(2, '0')}`;
+        const qDir = join(evidenceRoot, q);
+        try {
+            const files = readdirSync(qDir).sort();
+            if (files.length === 0) continue;
+            const manualGoldens = files.filter((f)=>{
+                try {
+                    const r = JSON.parse(readFileSync(join(qDir, f), 'utf8'));
+                    return r.official_source === 'manual-golden' || r.official?.source === 'manual-golden';
+                } catch  {
+                    return false;
+                }
+            });
+            const fileName = manualGoldens.length > 0 ? manualGoldens[manualGoldens.length - 1] : files[files.length - 1];
+            const r = JSON.parse(readFileSync(join(qDir, fileName), 'utf8'));
+            out.total += 1;
+            if (r.doubleSource?.state === 'comparable') out.comparable += 1;
+            if (r.session?.verdict === 'hit') out.hit += 1;
+            if (r.session?.verdict === 'challenged') out.challenge += 1;
+            if (r.softScore) {
+                out.accuracy_eligible += 1;
+                if (r.softScore.pass) out.accuracy_pass += 1;
+            }
+            if (r.sessionLatencyMs !== null && r.session?.verdict === 'hit' && r.sessionLatencyMs < 15_000) out.live_under_15s += 1;
+            const seg0 = r.session?.verdict === 'hit' && r.session.route_segments?.length ? r.session.route_segments[0] : null;
+            const sessionFlight = seg0 ? {
+                flight_no: seg0.transport_number,
+                dep: seg0.departure_at,
+                arr: seg0.arrival_at,
+                price: r.session.price
+            } : null;
+            out.records.push({
+                query_id: q,
+                expected: r.expected,
+                official_source: r.official_source,
+                session_verdict: r.session?.verdict,
+                session_flight: sessionFlight,
+                soft_score: r.softScore ? {
+                    accuracy: r.softScore.accuracy,
+                    pass: r.softScore.pass,
+                    missing: r.softScore.missing,
+                    incorrect: r.softScore.incorrect
+                } : null,
+                session_latency_ms: r.sessionLatencyMs,
+                session_error: r.sessionError
+            });
+        } catch  {}
+    }
+    for (const r of out.records){
+        if (r.official_source === 'manual-golden') out.sources.manual_golden_query_ids.push(r.query_id);
+        else out.sources.flyai_query_ids.push(r.query_id);
+    }
+    const summaryPath = join(evidenceRoot, 'sf-summary', `${out.started_at.replace(/[:.]/g, '-')}.json`);
+    mkdirSync(join(evidenceRoot, 'sf-summary'), {
+        recursive: true
+    });
+    writeFileSync(summaryPath, JSON.stringify(out, null, 2));
+    console.log(`──── sf-summary (unified,8 query) ────`);
+    console.log(`total: ${out.total}`);
+    console.log(`verdict=hit: ${out.hit}/${out.total}`);
+    console.log(`soft score ≥${out.threshold * 100}%: ${out.accuracy_pass}/${out.accuracy_eligible}`);
+    console.log(`live <15s (hit): ${out.live_under_15s}/${out.hit}`);
+    console.log(`manual golden query_ids: ${out.sources.manual_golden_query_ids.join(', ') || '(none)'}`);
+    console.log(`flyai query_ids: ${out.sources.flyai_query_ids.join(', ') || '(none)'}`);
+    console.log(`summary: ${summaryPath}`);
+}
+main();
+
+
+//# sourceURL=ts/scripts/sf-summary.ts

package/dist/scripts/skeleton-check.js

@@ -34,4 +34,4 @@ if (isMain && process.argv[2] && process.argv[3]) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/skeleton-check.ts
+//# sourceURL=ts/scripts/skeleton-check.ts

package/dist/scripts/skeleton-integration-test.js

@@ -19,4 +19,4 @@ assert.ok((r.skeleton_notes ?? []).some((n)=>n.includes('HKG') && n.includes('
 console.log(`骨架集成 OK:EK329 在枢纽否定下存活,标注=[${r.skeleton_notes?.join(' | ')}]`);
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/skeleton-integration-test.ts
+//# sourceURL=ts/scripts/skeleton-integration-test.ts

package/dist/scripts/skills-contract-tests.js

@@ -82,4 +82,4 @@ main().catch((e)=>{
 });
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/skills-contract-tests.ts
+//# sourceURL=ts/scripts/skills-contract-tests.ts

package/dist/scripts/smoke-session-gate-tests.js

@@ -0,0 +1,29 @@
+import { gatedSessionFlightSearch, offlineSessionFlightResult, sessionLiveEnabled } from '../capabilities/session-search.js';
+let calls = 0;
+const query = {
+    from: '上海',
+    to: '丽江',
+    date: '2026-10-01'
+};
+if (sessionLiveEnabled({
+    GOTRY_SESSION_LIVE: '0'
+})) throw new Error('GOTRY_SESSION_LIVE=0 must be offline');
+if (sessionLiveEnabled({
+    GOTRY_SESSION_LIVE: undefined
+})) throw new Error('unset GOTRY_SESSION_LIVE must be offline');
+const offline = await gatedSessionFlightSearch(query, async ()=>{
+    calls += 1;
+    throw new Error('live transport must not be called');
+}, {
+    GOTRY_SESSION_LIVE: '0'
+});
+if (calls !== 0) throw new Error(`offline gate invoked live transport ${calls} time(s)`);
+if (offline.verdict !== 'error' || offline.ok || !offline.error?.includes('GOTRY_SESSION_LIVE=1') || !offline.evidence.includes('live transport not invoked')) {
+    throw new Error(`offline result is not explicit: ${JSON.stringify(offline)}`);
+}
+const direct = offlineSessionFlightResult();
+if (direct.verdict !== 'error' || direct.ok || !direct.evidence.includes('offline')) throw new Error('offline helper contract drifted');
+console.log('SMOKE SESSION GATE: GOTRY_SESSION_LIVE!=1 makes zero live calls and returns explicit offline error');
+
+
+//# sourceURL=ts/scripts/smoke-session-gate-tests.ts