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

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

@@ -0,0 +1,67 @@
+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');

package/dist/scripts/sf-summary-tests.js

@@ -0,0 +1,324 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, existsSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { EXPECTED_QUERY_IDS } from './sf-summary.js';
+const tsRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const cliPath = join(tsRoot, 'scripts', 'sf-summary.ts');
+function record(queryId, batch, startedAt, source, verdict = 'hit') {
+    const isStatic = source === 'static';
+    const effective = source === 'manual' ? 'manual-golden' : isStatic ? 'static-openflights+manual-band' : 'vendor-x';
+    return {
+        query_id: queryId,
+        expected: { from: 'SYN', to: 'DST', date: '2026-10-01', kind: 'flight' },
+        requested_source: isStatic ? 'static' : source === 'manual' ? 'manual' : 'vendor-x',
+        effective_source: effective,
+        fallback_reason: isStatic && verdict === 'error' ? 'synthetic static route error' : null,
+        official_source: effective,
+        official_provenance: { source: 'synthetic fixture', batch },
+        manifest_sha256: `sha256:${batch}`,
+        batch_id: batch.startsWith('explicit-') ? batch : undefined,
+        started_at: startedAt,
+        official: { source: effective, verdict, latency_ms: 1 },
+        session: { verdict, price: verdict === 'hit' ? 100 : 0, route_segments: [], fetched_at: startedAt },
+        doubleSource: { state: 'comparable', mismatches: [] },
+        softScore: null,
+        sessionLatencyMs: 100,
+        sessionError: verdict === 'error' ? 'synthetic error' : null,
+    };
+}
+function writeJson(root, queryId, filename, value) {
+    const directory = join(root, queryId);
+    mkdirSync(directory, { recursive: true });
+    writeFileSync(join(directory, filename), JSON.stringify(value, null, 2));
+}
+function writeRaw(root, queryId, filename, value) {
+    const directory = join(root, queryId);
+    mkdirSync(directory, { recursive: true });
+    writeFileSync(join(directory, filename), value);
+}
+function writeBatch(root, filename, batch, source = 'manual', verdict = 'hit') {
+    EXPECTED_QUERY_IDS.forEach((queryId, index) => {
+        const second = (index + 1).toString().padStart(2, '0');
+        writeJson(root, queryId, filename, record(queryId, batch, `2026-09-09T10:00:${second}.000Z`, source, verdict));
+    });
+}
+function runCli(root, scriptPath = cliPath) {
+    mkdirSync(join(root, 'home'), { recursive: true });
+    const result = spawnSync(process.execPath, [scriptPath, '--evidence-root', root], {
+        cwd: tsRoot,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: join(root, 'home'),
+            GOTRY_SESSION_LIVE: '0',
+            GOTRY_HBCLI_LIVE: '0',
+            GOTRY_HOTELBYTE_SKILLS_LIVE: '0',
+        },
+    });
+    const output = `${result.stdout ?? ''}${result.stderr ?? ''}`;
+    const pathMatch = /summary: (.+)/.exec(output);
+    assert.ok(pathMatch, `CLI must print its output path\n${output}`);
+    const summary = JSON.parse(readFileSync(pathMatch[1].trim(), 'utf8'));
+    return { exit: result.status ?? -1, output, summary };
+}
+function runCliArgs(scriptPath, root, extraArgs) {
+    mkdirSync(join(root, 'home'), { recursive: true });
+    const result = spawnSync(process.execPath, [scriptPath, ...extraArgs], {
+        cwd: tsRoot,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: join(root, 'home'),
+            GOTRY_SESSION_LIVE: '0',
+            GOTRY_HBCLI_LIVE: '0',
+            GOTRY_HOTELBYTE_SKILLS_LIVE: '0',
+        },
+    });
+    return { exit: result.status ?? -1, output: `${result.stdout ?? ''}${result.stderr ?? ''}` };
+}
+function makeSymlinkFixtures() {
+    const base = mkdtempSync(join(tmpdir(), 'gotry-sf420-symlink-'));
+    const fileLink = join(base, 'sf-summary-file-link.ts');
+    const dirLink = join(base, 'sf-summary-dir-link');
+    symlinkSync(cliPath, fileLink);
+    symlinkSync(join(tsRoot, 'scripts'), dirLink, 'dir');
+    return { fileLink, dirLink };
+}
+function freshRoot() {
+    return mkdtempSync(join(tmpdir(), 'gotry-sf-summary-e2e-'));
+}
+const roots = [];
+try {
+    // One canonical filename is one legacy batch, even though each producer
+    // record has a different per-query started_at.
+    const coherentRoot = freshRoot();
+    roots.push(coherentRoot);
+    writeBatch(coherentRoot, '2026-09-09T10-00-00-000Z.json', 'manual-batch');
+    const coherent = runCli(coherentRoot);
+    assert.equal(coherent.exit, 0, coherent.output);
+    assert.equal(coherent.summary.status, 'ok');
+    assert.equal(coherent.summary.total, 8);
+    assert.equal(coherent.summary.selected_batch.batch_id, '2026-09-09T10-00-00-000Z');
+    assert.equal(coherent.summary.selected_batch.identity_source, 'canonical_filename');
+    assert.equal(coherent.summary.started_at, '2026-09-09T10:00:00.000Z');
+    assert.notEqual(coherent.summary.generated_at, coherent.summary.started_at);
+    assert.equal(new Set(coherent.summary.records.map((item) => item.started_at)).size, 8);
+    assert.equal(coherent.summary.status_scope, 'batch_integrity_only');
+    assert.equal(coherent.summary.comparable, 8);
+    assert.equal(coherent.summary.live_provider_comparable, 0);
+    assert.ok(coherent.summary.records.every((item) => item.comparator_evidence_scope === 'deterministic_only'));
+    // A complete static batch can be coherent and have eight double-source
+    // comparisons, but its comparator cannot prove live provider inventory.
+    const staticRoot = freshRoot();
+    roots.push(staticRoot);
+    writeBatch(staticRoot, '2026-09-09T11-00-00-000Z.json', 'static-batch', 'static', 'hit');
+    const staticBatch = runCli(staticRoot);
+    assert.equal(staticBatch.summary.status, 'ok');
+    assert.equal(staticBatch.summary.status_scope, 'batch_integrity_only');
+    assert.equal(staticBatch.summary.comparable, 8);
+    assert.equal(staticBatch.summary.live_provider_comparable, 0);
+    assert.ok(staticBatch.summary.records.every((item) => item.comparator_evidence_scope === 'deterministic_only'));
+    assert.match(staticBatch.output, /static\/manual comparator: deterministic only/);
+    const liveRoot = freshRoot();
+    roots.push(liveRoot);
+    EXPECTED_QUERY_IDS.forEach((queryId, index) => {
+        const fixture = record(queryId, 'flyai-batch', `2026-09-09T12:00:${(index + 1).toString().padStart(2, '0')}.000Z`, 'unknown');
+        const effective = index === 7 ? 'manual-golden' : 'flyai';
+        writeJson(liveRoot, queryId, '2026-09-09T12-00-00-000Z.json', {
+            ...fixture, requested_source: 'flyai', effective_source: effective, official_source: effective,
+        });
+    });
+    const liveBatch = runCli(liveRoot);
+    assert.equal(liveBatch.summary.live_provider_comparable, 7);
+    assert.equal(liveBatch.summary.records.filter((item) => item.comparator_evidence_scope === 'live_provider').length, 7);
+    assert.equal(liveBatch.summary.records.find((item) => item.query_id === 'sf-08').comparator_evidence_scope, 'deterministic_only');
+    // A newer static/error batch wins over an older manual hit and remains in
+    // the static bucket. An unsupported source is visible as unknown, never
+    // silently reclassified as FlyAI.
+    const sourceRoot = freshRoot();
+    roots.push(sourceRoot);
+    writeJson(sourceRoot, 'sf-01', '2026-01-01T10-00-00-000Z.json', record('sf-01', 'old-manual', '2026-01-01T10:00:01.000Z', 'manual', 'hit'));
+    writeBatch(sourceRoot, '2026-09-10T10-00-00-000Z.json', 'new-static', 'static', 'error');
+    writeJson(sourceRoot, 'sf-03', '2026-09-10T10-00-00-000Z.json', { ...record('sf-03', 'new-static', '2026-09-09T10:00:03.000Z', 'unknown', 'error'), requested_source: 'vendor-x', effective_source: 'vendor-x', official_source: 'vendor-x' });
+    const source = runCli(sourceRoot);
+    assert.equal(source.exit, 0, source.output);
+    const sourceQ1 = source.summary.records.find((item) => item.query_id === 'sf-01');
+    assert.equal(sourceQ1.effective_source, 'static-openflights+manual-band');
+    assert.equal(sourceQ1.session_verdict, 'error');
+    assert.deepEqual(source.summary.sources.manual_golden_query_ids, []);
+    assert.ok(source.summary.sources.static_query_ids.includes('sf-01'));
+    assert.ok(source.summary.sources.unknown_query_ids.includes('sf-03'));
+    assert.deepEqual(source.summary.sources.flyai_query_ids, []);
+    assert.equal(sourceQ1.requested_source, 'static');
+    assert.equal(sourceQ1.fallback_reason, 'synthetic static route error');
+    assert.deepEqual(sourceQ1.official_provenance, { source: 'synthetic fixture', batch: 'new-static' });
+    assert.equal(sourceQ1.manifest_sha256, 'sha256:new-static');
+    // A newest incomplete/corrupt filename batch is selected before JSON
+    // parsing can discard it; the older complete manual batch is not a fallback.
+    const corruptRoot = freshRoot();
+    roots.push(corruptRoot);
+    writeBatch(corruptRoot, '2026-01-01T10-00-00-000Z.json', 'old-complete', 'manual', 'hit');
+    const newest = '2026-09-11T10-00-00-000Z.json';
+    EXPECTED_QUERY_IDS.slice(0, 7).forEach((queryId, index) => writeJson(corruptRoot, queryId, newest, record(queryId, 'new-incomplete', `2026-09-11T10:00:0${index + 1}.000Z`, 'static', 'error')));
+    writeRaw(corruptRoot, 'sf-08', newest, '{ corrupt json');
+    const corrupt = runCli(corruptRoot);
+    assert.equal(corrupt.exit, 1, corrupt.output);
+    assert.equal(corrupt.summary.status, 'fail_closed');
+    assert.equal(corrupt.summary.selected_batch.batch_id, '2026-09-11T10-00-00-000Z');
+    assert.ok(corrupt.summary.missing_query_ids.includes('sf-08'));
+    assert.ok(corrupt.summary.selected_malformed_records.some((item) => item.file === `sf-08/${newest}`));
+    assert.equal(corrupt.summary.records.find((item) => item.query_id === 'sf-01').effective_source, 'static-openflights+manual-band');
+    // A malformed old batch is diagnostic only when a newer complete batch is
+    // independently reportable.
+    const oldCorruptRoot = freshRoot();
+    roots.push(oldCorruptRoot);
+    writeRaw(oldCorruptRoot, 'sf-01', '2026-01-01T10-00-00-000Z.json', '{ old corrupt');
+    writeBatch(oldCorruptRoot, '2026-09-12T10-00-00-000Z.json', 'new-complete', 'manual', 'hit');
+    const oldCorrupt = runCli(oldCorruptRoot);
+    assert.equal(oldCorrupt.exit, 0, oldCorrupt.output);
+    assert.equal(oldCorrupt.summary.selected_malformed_records.length, 0);
+    assert.equal(oldCorrupt.summary.malformed_records.length, 1);
+    // Historical records without a canonical filename or valid explicit batch
+    // capture time remain visible unmatched and cannot become the batch.
+    const legacyRoot = freshRoot();
+    roots.push(legacyRoot);
+    writeBatch(legacyRoot, '2026-09-13T10-00-00-000Z.json', 'new-complete', 'manual', 'hit');
+    writeJson(legacyRoot, 'sf-01', 'legacy.json', { ...record('sf-01', 'legacy', '2020-01-01T00:00:00.000Z', 'manual', 'hit'), batch_id: undefined, started_at: undefined });
+    const legacy = runCli(legacyRoot);
+    assert.equal(legacy.exit, 0, legacy.output);
+    assert.equal(legacy.summary.selected_batch.batch_id, '2026-09-13T10-00-00-000Z');
+    assert.ok(legacy.summary.unknown_batch_records.some((item) => item.file === 'sf-01/legacy.json'));
+    assert.equal(legacy.summary.records.find((item) => item.query_id === 'sf-01').batch_id, '2026-09-13T10-00-00-000Z');
+    // A complete eight-record batch with structured challenge, legacy top-level challenged, and guard
+    // evidence must still fail closed; zero missing IDs prevents missing-record errors from masking the
+    // new challenge/guard error condition.
+    const challengeRoot = freshRoot();
+    roots.push(challengeRoot);
+    const challengeBatch = '2026-09-14T10-00-00-000Z.json';
+    writeJson(challengeRoot, 'sf-01', challengeBatch, record('sf-01', 'challenge-batch', '2026-09-14T10:00:01.000Z', 'manual', 'hit'));
+    writeJson(challengeRoot, 'sf-02', challengeBatch, {
+        ...record('sf-02', 'challenge-batch', '2026-09-14T10:00:02.000Z', 'manual', 'hit'),
+        session: { verdict: 'challenged', price: 0, route_segments: [], fetched_at: '2026-09-14T10:00:02.000Z' },
+        doubleSource: { state: 'challenge_stop', quota_disposition: 'no_spend_stop', mismatches: [] },
+    });
+    writeJson(challengeRoot, 'sf-03', challengeBatch, {
+        ...record('sf-03', 'challenge-batch', '2026-09-14T10:00:03.000Z', 'manual', 'hit'),
+        session: { verdict: 'error', price: 0, route_segments: [], fetched_at: '2026-09-14T10:00:03.000Z' },
+        sessionVerdict: 'challenged',
+        doubleSource: { state: 'source_unavailable', quota_disposition: 'no_spend_stop', mismatches: [] },
+    });
+    writeJson(challengeRoot, 'sf-04', challengeBatch, {
+        ...record('sf-04', 'challenge-batch', '2026-09-14T10:00:04.000Z', 'manual', 'hit'),
+        session: { verdict: 'error', price: 0, route_segments: [], fetched_at: '2026-09-14T10:00:04.000Z' },
+        doubleSource: { state: 'guard_violation', quota_disposition: 'no_spend_stop', mismatches: [] },
+    });
+    EXPECTED_QUERY_IDS.slice(4).forEach((queryId, index) => {
+        const second = (index + 5).toString().padStart(2, '0');
+        writeJson(challengeRoot, queryId, challengeBatch, record(queryId, 'challenge-batch', `2026-09-14T10:00:${second}.000Z`, 'manual', 'hit'));
+    });
+    const challenge = runCli(challengeRoot);
+    assert.equal(challenge.exit, 1, challenge.output);
+    assert.equal(challenge.summary.status, 'fail_closed');
+    assert.equal(challenge.summary.challenge_stop_detected, true);
+    assert.equal(challenge.summary.total, 8);
+    assert.deepEqual(challenge.summary.missing_query_ids, []);
+    assert.ok(challenge.summary.errors.some((error) => error.includes('challenge/guard stop evidence')));
+    // Issue #420 — symlink-path entrypoint guard: the same Node invocation
+    // through a temporary file symlink and a temporary parent-directory
+    // symlink must reach main() and produce identical results to the canonical
+    // path. The symlinks are real symlinks (not pre-canonicalized); the caller
+    // passes the symlink path itself and Node receives it as argv[1].
+    const symlinkFixture = freshRoot();
+    roots.push(symlinkFixture);
+    const { fileLink, dirLink } = makeSymlinkFixtures();
+    roots.push(resolve(fileLink, '..'));
+    roots.push(resolve(dirLink, '..'));
+    writeBatch(symlinkFixture, '2026-09-15T10-00-00-000Z.json', 'symlink-batch');
+    const coherentCanonical = runCli(symlinkFixture);
+    assert.equal(coherentCanonical.exit, 0, coherentCanonical.output);
+    const coherentFileLink = runCli(symlinkFixture, fileLink);
+    const coherentDirLink = runCli(symlinkFixture, join(dirLink, 'sf-summary.ts'));
+    for (const variant of [coherentFileLink, coherentDirLink]) {
+        assert.equal(variant.exit, 0, variant.output);
+        assert.equal(variant.summary.status, coherentCanonical.summary.status);
+        assert.equal(variant.summary.total, coherentCanonical.summary.total);
+        assert.equal(variant.summary.selected_batch.batch_id, coherentCanonical.summary.selected_batch.batch_id);
+        assert.equal(variant.summary.selected_batch.identity_source, coherentCanonical.summary.selected_batch.identity_source);
+        assert.deepEqual(variant.summary.records.map((record) => record.query_id), coherentCanonical.summary.records.map((record) => record.query_id));
+        assert.deepEqual(variant.summary.records.map((record) => record.soft_score?.pass ?? null), coherentCanonical.summary.records.map((record) => record.soft_score?.pass ?? null));
+    }
+    // Issue #420 — invalid argument must exit nonzero through symlinks too,
+    // with the same closed-vocabulary message as the canonical path.
+    const invalidFileLink = runCliArgs(fileLink, symlinkFixture, ['--definitely-invalid-argument']);
+    assert.equal(invalidFileLink.exit, 1, invalidFileLink.output);
+    assert.match(invalidFileLink.output, /unknown argument: --definitely-invalid-argument/);
+    const invalidDirLink = runCliArgs(join(dirLink, 'sf-summary.ts'), symlinkFixture, ['--definitely-invalid-argument']);
+    assert.equal(invalidDirLink.exit, 1, invalidDirLink.output);
+    assert.match(invalidDirLink.output, /unknown argument: --definitely-invalid-argument/);
+    // Issue #420 — corrupt newest batch must fail closed through symlinks too,
+    // with the same status / missing / selected_malformed_records as the
+    // canonical path. This pins the scoring/aggregation red lines from being
+    // silently bypassed by the symlink guard.
+    const corruptSymlinkRoot = freshRoot();
+    roots.push(corruptSymlinkRoot);
+    writeBatch(corruptSymlinkRoot, '2026-01-01T10-00-00-000Z.json', 'old-complete', 'manual', 'hit');
+    const newestCorrupt = '2026-09-16T10-00-00-000Z.json';
+    EXPECTED_QUERY_IDS.slice(0, 7).forEach((queryId, index) => writeJson(corruptSymlinkRoot, queryId, newestCorrupt, record(queryId, 'new-incomplete', `2026-09-16T10:00:0${index + 1}.000Z`, 'static', 'error')));
+    writeRaw(corruptSymlinkRoot, 'sf-08', newestCorrupt, '{ corrupt json');
+    const corruptCanonical = runCli(corruptSymlinkRoot);
+    assert.equal(corruptCanonical.exit, 1, corruptCanonical.output);
+    const corruptFileLink = runCli(corruptSymlinkRoot, fileLink);
+    assert.equal(corruptFileLink.exit, 1, corruptFileLink.output);
+    assert.equal(corruptFileLink.summary.status, corruptCanonical.summary.status);
+    assert.equal(corruptFileLink.summary.selected_batch.batch_id, corruptCanonical.summary.selected_batch.batch_id);
+    assert.deepEqual(corruptFileLink.summary.missing_query_ids, corruptCanonical.summary.missing_query_ids);
+    assert.deepEqual(corruptFileLink.summary.selected_malformed_records, corruptCanonical.summary.selected_malformed_records);
+    const corruptDirLink = runCli(corruptSymlinkRoot, join(dirLink, 'sf-summary.ts'));
+    assert.equal(corruptDirLink.exit, 1, corruptDirLink.output);
+    assert.equal(corruptDirLink.summary.status, corruptCanonical.summary.status);
+    assert.deepEqual(corruptDirLink.summary.missing_query_ids, corruptCanonical.summary.missing_query_ids);
+    // Issue #420 — module-import inertness: importing the module from a
+    // separate test process must not run main() and must not touch the default
+    // user evidenceRoot under HOME. The library API stays callable.
+    const importRoot = mkdtempSync(join(tmpdir(), 'gotry-sf420-import-'));
+    roots.push(importRoot);
+    const importHome = join(importRoot, 'home');
+    mkdirSync(importHome, { recursive: true });
+    const defaultRoot = join(importHome, '.gotry', 'evidence', 'session');
+    const importerPath = join(importRoot, 'importer.mjs');
+    writeFileSync(importerPath, `
+    import { homedir } from 'node:os'
+    import { existsSync } from 'node:fs'
+    import { join } from 'node:path'
+    const defaultEvidenceRoot = join(homedir(), '.gotry', 'evidence', 'session')
+    if (existsSync(defaultEvidenceRoot)) process.exit(11)
+    const mod = await import(${JSON.stringify(pathToFileURL(cliPath).href)})
+    if (typeof mod.main !== 'function') process.exit(12)
+    if (typeof mod.parseCliArgs !== 'function') process.exit(13)
+    if (typeof mod.buildSummary !== 'function') process.exit(14)
+    if (existsSync(defaultEvidenceRoot)) process.exit(15)
+    process.stdout.write('import-inert OK\\n')
+  `);
+    const importerResult = spawnSync(process.execPath, [importerPath], {
+        cwd: tsRoot,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: importHome,
+            GOTRY_SESSION_LIVE: '0',
+            GOTRY_HBCLI_LIVE: '0',
+            GOTRY_HOTELBYTE_SKILLS_LIVE: '0',
+        },
+    });
+    assert.equal(importerResult.status ?? -1, 0, `${importerResult.stdout ?? ''}${importerResult.stderr ?? ''}`);
+    assert.match(`${importerResult.stdout ?? ''}${importerResult.stderr ?? ''}`, /import-inert OK/);
+    assert.equal(existsSync(defaultRoot), false, `default HOME evidenceRoot must not be created by import`);
+    console.log('SF SUMMARY CLI E2E: coherent filename batch, chronology, source provenance, missing/corrupt fail-closed, legacy unknown, old/new isolation, and challenge-partial fail-closed OK');
+}
+finally {
+    for (const root of roots)
+        rmSync(root, { recursive: true, force: true });
+}