@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

package/dist/scripts/sf-summary.js

@@ -1,93 +1,475 @@
-import { mkdirSync, writeFileSync, readdirSync, readFileSync } from 'node:fs';
+/**
+ * Rebuild the offline sf-01..08 evidence summary from one coherent batch.
+ *
+ * The default root is retained for humans, while tests and proofs must pass
+ * --evidence-root explicitly so no shared founder state is read or written.
+ */
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 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: []
+export const EXPECTED_QUERY_IDS = Array.from({ length: 8 }, (_, index) => `sf-${(index + 1).toString().padStart(2, '0')}`);
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function nestedString(value, ...keys) {
+    let current = value;
+    for (const key of keys) {
+        if (!isObject(current))
+            return null;
+        current = current[key];
+    }
+    return stringValue(current);
+}
+function firstString(record, paths) {
+    for (const path of paths) {
+        const value = path.length === 1 ? record[path[0]] : nestedString(record, ...path);
+        const result = stringValue(value);
+        if (result !== null)
+            return result;
+    }
+    return null;
+}
+function parseTime(value) {
+    if (value === null)
+        return Number.NEGATIVE_INFINITY;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
+}
+function canonicalFilename(file) {
+    // sf-live-benchmark uses runStartedAt.replace(/[:.]/g, '-') for every
+    // evidence filename. Only that exact ISO-with-safe-time-punctuation form
+    // is a legacy batch identity; arbitrary filenames remain unknown.
+    const match = /^(\d{4}-\d{2}-\d{2}T\d{2})-(\d{2})-(\d{2})-(\d{3})Z\.json$/.exec(file);
+    if (match === null)
+        return null;
+    const captureAt = `${match[1]}:${match[2]}:${match[3]}.${match[4]}Z`;
+    const chronologyMs = parseTime(captureAt);
+    if (!Number.isFinite(chronologyMs))
+        return null;
+    return { stem: file.slice(0, -'.json'.length), captureAt, chronologyMs };
+}
+function captureAt(record) {
+    return firstString(record, [
+        ['evidence_captured_at'],
+        ['captured_at'],
+        ['capture_time'],
+        ['evidence_capture_time'],
+        ['official_captured_at'],
+        ['evidence', 'captured_at'],
+    ]);
+}
+function startedAt(record) {
+    return firstString(record, [
+        ['started_at'],
+        ['evidence', 'started_at'],
+    ]);
+}
+function sessionFetchedAt(record) {
+    return nestedString(record.session, 'fetched_at');
+}
+function explicitBatch(record) {
+    const values = [
+        stringValue(record.batch_id),
+        stringValue(record.batchId),
+        stringValue(record.run_id),
+        stringValue(record.runId),
+        nestedString(record.batch, 'id'),
+        nestedString(record.batch, 'batch_id'),
+    ].filter((value) => value !== null);
+    const unique = Array.from(new Set(values));
+    const capture = firstString(record, [
+        ['batch_captured_at'],
+        ['batch_capture_at'],
+        ['batch_started_at'],
+        ['run_started_at'],
+        ['batch', 'captured_at'],
+        ['batch', 'started_at'],
+    ]);
+    const validCapture = capture !== null && Number.isFinite(parseTime(capture)) ? capture : null;
+    return {
+        id: unique[0] ?? null,
+        captureAt: validCapture,
+        conflict: unique.length > 1 ? `conflicting explicit batch IDs: ${unique.join(', ')}` : null,
     };
-    for(let i = 1; i <= 8; i += 1){
-        const q = `sf-${i.toString().padStart(2, '0')}`;
-        const qDir = join(evidenceRoot, q);
+}
+function recordChronology(record, captured, started) {
+    return Math.max(parseTime(captured), parseTime(started), parseTime(sessionFetchedAt(record)));
+}
+function relativePath(root, path) {
+    return path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path;
+}
+function inventoryFiles(evidenceRoot) {
+    const files = [];
+    const invalidRecords = [];
+    const canonicalGroups = new Map();
+    for (const queryId of EXPECTED_QUERY_IDS) {
+        const queryDir = join(evidenceRoot, queryId);
+        let names;
         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 (!statSync(queryDir).isDirectory()) {
+                invalidRecords.push({ query_id: queryId, file: queryId, reason: 'query path is not a directory' });
+                continue;
+            }
+            names = readdirSync(queryDir).filter((name) => name.endsWith('.json')).sort();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            invalidRecords.push({ query_id: queryId, file: queryId, reason: error instanceof Error ? error.message : String(error) });
+            continue;
+        }
+        for (const name of names) {
+            const entry = {
+                queryId,
+                file: relativePath(evidenceRoot, join(queryDir, name)),
+                absolutePath: join(queryDir, name),
+                canonical: canonicalFilename(name),
+            };
+            files.push(entry);
+            if (entry.canonical !== null) {
+                const group = canonicalGroups.get(entry.canonical.stem) ?? [];
+                group.push(entry);
+                canonicalGroups.set(entry.canonical.stem, group);
             }
-            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
+        }
+    }
+    const candidates = Array.from(canonicalGroups.entries()).map(([stem, group]) => {
+        const canonical = group.find((entry) => entry.canonical !== null)?.canonical ?? null;
+        return {
+            id: stem,
+            identitySource: 'canonical_filename',
+            captureAt: canonical?.captureAt ?? null,
+            chronologyMs: canonical?.chronologyMs ?? Number.NEGATIVE_INFINITY,
+            files: group,
+            records: [],
+            conflictReason: null,
+        };
+    });
+    return { files, candidates, invalidRecords };
+}
+function readRecords(inventory) {
+    const records = [];
+    const malformedRecords = [];
+    const invalidRecords = [];
+    const unknownBatchRecords = [];
+    for (const file of inventory) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(file.absolutePath, 'utf8'));
+        }
+        catch (error) {
+            malformedRecords.push({ query_id: file.queryId, file: file.file, reason: error instanceof Error ? error.message : String(error) });
+            continue;
+        }
+        if (!isObject(parsed)) {
+            invalidRecords.push({ query_id: file.queryId, file: file.file, reason: 'record must be a JSON object' });
+            continue;
+        }
+        if (parsed.query_id !== file.queryId) {
+            invalidRecords.push({ query_id: file.queryId, file: file.file, reason: `query_id must be ${file.queryId}` });
+            continue;
+        }
+        const explicit = explicitBatch(parsed);
+        if (explicit.conflict !== null) {
+            invalidRecords.push({ query_id: file.queryId, file: file.file, reason: explicit.conflict });
+            continue;
+        }
+        const captured = captureAt(parsed);
+        const started = startedAt(parsed);
+        const loaded = {
+            ...file,
+            record: parsed,
+            explicitBatchId: explicit.id,
+            explicitBatchCaptureAt: explicit.captureAt,
+            captureAt: captured,
+            startedAt: started,
+            chronologyMs: recordChronology(parsed, captured, started),
+        };
+        records.push(loaded);
+        if (file.canonical === null && (explicit.id === null || explicit.captureAt === null)) {
+            unknownBatchRecords.push({
+                query_id: file.queryId,
+                file: file.file,
+                reason: explicit.id === null ? 'missing defensible batch identity' : 'explicit batch ID lacks a valid batch capture timestamp',
             });
-        } catch  {}
+        }
+    }
+    return { records, malformedRecords, invalidRecords, unknownBatchRecords };
+}
+function completeCandidates(initial, records) {
+    const candidates = initial.map((candidate) => {
+        const members = records.filter((record) => record.canonical?.stem === candidate.id);
+        const explicitIds = Array.from(new Set(members.map((record) => record.explicitBatchId).filter((value) => value !== null)));
+        const conflictReason = explicitIds.length > 1 ? `conflicting explicit batch IDs in filename batch: ${explicitIds.join(', ')}` : null;
+        const explicitCaptureTimes = Array.from(new Set(members.map((record) => record.explicitBatchCaptureAt).filter((value) => value !== null)));
+        const captureAt = candidate.captureAt;
+        return {
+            ...candidate,
+            id: conflictReason === null && explicitIds.length === 1 ? explicitIds[0] : candidate.id,
+            identitySource: conflictReason === null && explicitIds.length === 1 ? 'explicit_batch_id+canonical_filename' : candidate.identitySource,
+            captureAt,
+            records: members,
+            conflictReason: conflictReason ?? (explicitCaptureTimes.length > 1 ? `conflicting explicit batch capture times: ${explicitCaptureTimes.join(', ')}` : null),
+        };
+    });
+    const canonicalStems = new Set(initial.flatMap((candidate) => candidate.files.map((file) => file.canonical?.stem).filter((value) => value !== undefined)));
+    const explicitOnly = new Map();
+    for (const record of records) {
+        if (record.canonical !== null || record.explicitBatchId === null || record.explicitBatchCaptureAt === null)
+            continue;
+        const group = explicitOnly.get(record.explicitBatchId) ?? [];
+        group.push(record);
+        explicitOnly.set(record.explicitBatchId, group);
+    }
+    for (const [id, members] of explicitOnly) {
+        if (canonicalStems.has(members[0].canonical?.stem ?? ''))
+            continue;
+        const captureTimes = Array.from(new Set(members.map((record) => record.explicitBatchCaptureAt).filter((value) => value !== null)));
+        const captureAt = captureTimes[0] ?? null;
+        candidates.push({
+            id,
+            identitySource: 'explicit_batch_id',
+            captureAt,
+            chronologyMs: parseTime(captureAt),
+            files: members,
+            records: members,
+            conflictReason: captureTimes.length > 1 ? `conflicting explicit batch capture times: ${captureTimes.join(', ')}` : null,
+        });
     }
-    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);
+    return candidates;
+}
+function chooseBatch(candidates) {
+    return candidates.slice().sort((left, right) => {
+        if (right.chronologyMs !== left.chronologyMs)
+            return right.chronologyMs - left.chronologyMs;
+        if (right.files.length !== left.files.length)
+            return right.files.length - left.files.length;
+        return right.id.localeCompare(left.id);
+    })[0] ?? null;
+}
+function selectBatchRecords(batch) {
+    const selected = new Map();
+    for (const record of batch.records) {
+        const previous = selected.get(record.queryId);
+        if (previous === undefined || record.chronologyMs > previous.chronologyMs || (record.chronologyMs === previous.chronologyMs && record.file > previous.file))
+            selected.set(record.queryId, record);
+    }
+    return selected;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function sourceFields(record) {
+    const requested = stringValue(record.requested_source);
+    const effective = stringValue(record.effective_source) ?? stringValue(record.official_source) ?? nestedString(record.official, 'source');
+    return {
+        official: stringValue(record.official_source) ?? effective,
+        requested,
+        effective,
+        fallback: stringValue(record.fallback_reason),
+    };
+}
+function sourceBucket(record) {
+    const normalizedRequested = record.requested_source?.toLowerCase();
+    const normalizedEffective = record.effective_source?.toLowerCase() ?? '';
+    if (normalizedRequested === 'static' || normalizedEffective.startsWith('static'))
+        return 'static_query_ids';
+    if (normalizedEffective === 'manual-golden' || normalizedEffective === 'manual')
+        return 'manual_golden_query_ids';
+    if (normalizedEffective === 'flyai' || normalizedEffective.startsWith('flyai'))
+        return 'flyai_query_ids';
+    return 'unknown_query_ids';
+}
+function toSummaryRecord(item, batchId, batchIdentitySource) {
+    const record = item.record;
+    const fields = sourceFields(record);
+    const session = isObject(record.session) ? record.session : null;
+    const soft = isObject(record.softScore) ? record.softScore : null;
+    const segments = session && Array.isArray(session.route_segments) ? session.route_segments : [];
+    const firstSegment = isObject(segments[0]) ? segments[0] : null;
+    const verdict = stringValue(session?.verdict) ?? stringValue(record.sessionVerdict);
+    const price = numberValue(session?.price);
+    const sessionFlight = verdict === 'hit' && firstSegment !== null
+        ? {
+            flight_no: stringValue(firstSegment.transport_number) ?? '',
+            dep: stringValue(firstSegment.departure_at) ?? '',
+            arr: stringValue(firstSegment.arrival_at) ?? '',
+            price: price ?? 0,
+        }
+        : null;
+    const sessionFetched = sessionFetchedAt(record);
+    const softScore = soft === null ? null : {
+        accuracy: numberValue(soft.accuracy) ?? 0,
+        pass: soft.pass === true,
+        missing: Array.isArray(soft.missing) ? soft.missing.filter((value) => typeof value === 'string') : [],
+        incorrect: Array.isArray(soft.incorrect) ? soft.incorrect.filter((value) => typeof value === 'string') : [],
+    };
+    return {
+        query_id: item.queryId,
+        expected: record.expected ?? null,
+        official_source: fields.official,
+        requested_source: fields.requested,
+        effective_source: fields.effective,
+        fallback_reason: fields.fallback,
+        batch_id: batchId,
+        batch_identity_source: batchIdentitySource,
+        evidence_captured_at: item.captureAt,
+        started_at: item.startedAt,
+        capture: {
+            evidence_captured_at: item.captureAt,
+            started_at: item.startedAt,
+            session_fetched_at: sessionFetched,
+        },
+        official_provenance: record.official_provenance ?? null,
+        manifest_provenance: record.manifest_provenance ?? record.manifest ?? null,
+        manifest_sha256: stringValue(record.manifest_sha256) ?? nestedString(record.manifest_provenance, 'sha256'),
+        manifest_hash: stringValue(record.manifest_hash) ?? nestedString(record.manifest_provenance, 'hash'),
+        batch_provenance: record.batch_provenance ?? null,
+        session_verdict: verdict,
+        session_flight: sessionFlight,
+        soft_score: softScore,
+        session_latency_ms: numberValue(record.sessionLatencyMs),
+        session_error: stringValue(record.sessionError),
+    };
+}
+function buildErrors(summary, conflictReason) {
+    const errors = [];
+    if (summary.selected_batch.batch_id === null)
+        errors.push('no defensible batch identity found');
+    if (conflictReason !== null)
+        errors.push(conflictReason);
+    if (summary.missing_query_ids.length > 0)
+        errors.push(`missing query IDs: ${summary.missing_query_ids.join(', ')}`);
+    if (summary.selected_malformed_records.length > 0)
+        errors.push(`malformed JSON: ${summary.selected_malformed_records.map((item) => item.file).join(', ')}`);
+    if (summary.selected_invalid_records.length > 0)
+        errors.push(`invalid records: ${summary.selected_invalid_records.map((item) => item.file).join(', ')}`);
+    return errors;
+}
+export function parseCliArgs(args) {
+    let evidenceRoot = null;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--evidence-root') {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith('--'))
+                throw new Error('--evidence-root requires a path');
+            evidenceRoot = value;
+            index += 1;
+        }
+        else if (arg.startsWith('--evidence-root=')) {
+            const value = arg.slice('--evidence-root='.length);
+            if (value.length === 0)
+                throw new Error('--evidence-root requires a path');
+            evidenceRoot = value;
+        }
+        else {
+            throw new Error(`unknown argument: ${arg}`);
+        }
     }
-    const summaryPath = join(evidenceRoot, 'sf-summary', `${out.started_at.replace(/[:.]/g, '-')}.json`);
-    mkdirSync(join(evidenceRoot, 'sf-summary'), {
-        recursive: true
+    return { evidenceRoot: resolve(evidenceRoot ?? join(homedir(), '.gotry', 'evidence', 'session')) };
+}
+export function buildSummary(evidenceRoot, generatedAt = new Date().toISOString()) {
+    const root = resolve(evidenceRoot);
+    const inventory = inventoryFiles(root);
+    const loaded = readRecords(inventory.files);
+    const candidates = completeCandidates(inventory.candidates, loaded.records);
+    const batch = chooseBatch(candidates);
+    const selected = batch === null ? new Map() : selectBatchRecords(batch);
+    const selectedRecords = EXPECTED_QUERY_IDS.flatMap((queryId) => {
+        const item = selected.get(queryId);
+        return item === undefined || batch === null ? [] : [toSummaryRecord(item, batch.id, batch.identitySource)];
     });
-    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
+    const selectedFiles = new Set(batch?.files.map((file) => file.file) ?? []);
+    const selectedMalformed = loaded.malformedRecords.filter((item) => selectedFiles.has(item.file));
+    const selectedInvalid = [...inventory.invalidRecords, ...loaded.invalidRecords].filter((item) => selectedFiles.has(item.file));
+    const missingQueryIds = EXPECTED_QUERY_IDS.filter((queryId) => !selected.has(queryId));
+    const batchCaptureAt = batch?.captureAt ?? null;
+    const summary = {
+        schema_version: 'gotry_sf_summary_v2',
+        generated_at: generatedAt,
+        started_at: batchCaptureAt,
+        batch_capture_at: batchCaptureAt,
+        selected_batch: {
+            batch_id: batch?.id ?? null,
+            identity_source: batch?.identitySource ?? null,
+            started_at: batchCaptureAt,
+            record_count: selectedRecords.length,
+            query_ids: selectedRecords.map((record) => record.query_id),
+        },
+        status: 'fail_closed',
+        total: selectedRecords.length,
+        threshold: SESSION_FIELD_ACCURACY_THRESHOLD,
+        accuracy_pass: selectedRecords.filter((record) => record.soft_score?.pass === true).length,
+        accuracy_eligible: selectedRecords.filter((record) => record.soft_score !== null).length,
+        comparable: selectedRecords.filter((record) => {
+            const item = selected.get(record.query_id);
+            return item !== undefined && isObject(item.record.doubleSource) && item.record.doubleSource.state === 'comparable';
+        }).length,
+        hit: selectedRecords.filter((record) => record.session_verdict === 'hit').length,
+        challenge: selectedRecords.filter((record) => record.session_verdict === 'challenged').length,
+        live_under_15s: selectedRecords.filter((record) => record.session_verdict === 'hit' && record.session_latency_ms !== null && record.session_latency_ms < 15_000).length,
+        missing_query_ids: missingQueryIds,
+        malformed_records: loaded.malformedRecords,
+        invalid_records: [...inventory.invalidRecords, ...loaded.invalidRecords],
+        selected_malformed_records: selectedMalformed,
+        selected_invalid_records: selectedInvalid,
+        unknown_batch_records: loaded.unknownBatchRecords,
+        sources: {
+            manual_golden_query_ids: [],
+            static_query_ids: [],
+            flyai_query_ids: [],
+            unknown_query_ids: [],
+        },
+        records: selectedRecords,
+        errors: [],
+    };
+    for (const record of summary.records)
+        summary.sources[sourceBucket(record)].push(record.query_id);
+    summary.errors = buildErrors(summary, batch?.conflictReason ?? (batch === null ? null : null));
+    summary.status = summary.errors.length === 0 ? 'ok' : 'fail_closed';
+    const summaryPath = join(root, 'sf-summary', `${generatedAt.replace(/[:.]/g, '-')}.json`);
+    mkdirSync(dirname(summaryPath), { recursive: true });
+    writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
+    return { summary, summaryPath };
+}
+export function main(args = process.argv.slice(2)) {
+    try {
+        const options = parseCliArgs(args);
+        const { summary, summaryPath } = buildSummary(options.evidenceRoot);
+        console.log('──── sf-summary (coherent offline batch) ────');
+        console.log(`status: ${summary.status}`);
+        console.log(`selected batch: ${summary.selected_batch.batch_id ?? '(none)'}`);
+        console.log(`batch capture: ${summary.batch_capture_at ?? '(unknown)'}`);
+        console.log(`generated at: ${summary.generated_at}`);
+        console.log(`total: ${summary.total}/${EXPECTED_QUERY_IDS.length}`);
+        console.log(`verdict=hit: ${summary.hit}/${summary.total}`);
+        console.log(`soft score ≥${summary.threshold * 100}%: ${summary.accuracy_pass}/${summary.accuracy_eligible}`);
+        console.log(`manual golden query_ids: ${summary.sources.manual_golden_query_ids.join(', ') || '(none)'}`);
+        console.log(`static query_ids: ${summary.sources.static_query_ids.join(', ') || '(none)'}`);
+        console.log(`flyai query_ids: ${summary.sources.flyai_query_ids.join(', ') || '(none)'}`);
+        console.log(`unknown source query_ids: ${summary.sources.unknown_query_ids.join(', ') || '(none)'}`);
+        if (summary.missing_query_ids.length > 0)
+            console.error(`missing query IDs: ${summary.missing_query_ids.join(', ')}`);
+        if (summary.selected_malformed_records.length > 0)
+            console.error(`malformed JSON: ${summary.selected_malformed_records.map((item) => item.file).join(', ')}`);
+        if (summary.selected_invalid_records.length > 0)
+            console.error(`invalid records: ${summary.selected_invalid_records.map((item) => item.file).join(', ')}`);
+        if (summary.malformed_records.length > summary.selected_malformed_records.length)
+            console.error(`diagnostic malformed JSON outside selected batch: ${summary.malformed_records.length - summary.selected_malformed_records.length}`);
+        console.log(`summary: ${summaryPath}`);
+        return summary.status === 'ok' ? 0 : 1;
+    }
+    catch (error) {
+        console.error(`[sf-summary] fail-closed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}
+const invokedPath = process.argv[1] === undefined ? null : resolve(process.argv[1]);
+if (invokedPath !== null && invokedPath === fileURLToPath(import.meta.url))
+    process.exitCode = main();

package/dist/scripts/skeleton-check.js

@@ -1,3 +1,9 @@
+/**
+ * OpenFlights 骨架校验(M2 段 3,§7-1 骨架层):引擎候选集的通航性合法性校验。
+ * 数据源:data/openflights-skeleton.json(OpenFlights ODbL,枢纽间 168 对)。
+ * 语义:「查不到≠不可达」(骨架只含枢纽间),但「查到」= 候选集强证据。
+ * 运行:cd ts && npx tsx scripts/skeleton-check.ts HKG HKT
+ */
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 let cached = null;
@@ -9,29 +15,25 @@ async function load() {
 }
 export async function checkConnectivity(a, b) {
     const skeleton = await load();
-    const key = [
-        a.toUpperCase(),
-        b.toUpperCase()
-    ].sort().join('-');
+    const key = [a.toUpperCase(), b.toUpperCase()].sort().join('-');
     const airlines = skeleton.pairs[key];
     if (airlines) {
-        return {
-            connected: true,
-            airlines,
-            evidence: `[骨架:openflights] ✅ ${a}↔${b} 直飞(${airlines.length}+ 航司:${airlines.join(',')})`
-        };
+        return { connected: true, airlines, evidence: `[骨架:openflights] ✅ ${a}↔${b} 直飞(${airlines.length}+ 航司:${airlines.join(',')})` };
     }
-    const inHub = skeleton.meta.hub_filter.includes(a.toUpperCase()) && skeleton.meta.hub_filter.includes(b.toUpperCase());
+    const inHub = skeleton.meta.hub_filter.includes(a.toUpperCase())
+        && skeleton.meta.hub_filter.includes(b.toUpperCase());
     return {
         connected: false,
-        evidence: inHub ? `[骨架:openflights] ❌ ${a}↔${b} 枢纽间无直飞记录——引擎应将此候选降权或要求中转` : `[骨架:openflights] ○ ${a}或${b}不在枢纽集,骨架不覆盖(不作否定结论)`
+        evidence: inHub
+            ? `[骨架:openflights] ❌ ${a}↔${b} 枢纽间无直飞记录——引擎应将此候选降权或要求中转`
+            : `[骨架:openflights] ○ ${a}或${b}不在枢纽集,骨架不覆盖(不作否定结论)`,
     };
 }
+// CLI 直跑
+// 仅作为直接 CLI 入口时执行(被 import 时不触发:此前 dsh 子进程的
+// argv[2]/[3](--profile headless)恰好真值,每次启动白跑一次探测还污染 stdout)
 import { pathToFileURL } from 'node:url';
 const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
 if (isMain && process.argv[2] && process.argv[3]) {
     console.log((await checkConnectivity(process.argv[2], process.argv[3])).evidence);
 }
-
-
-//# sourceURL=ts/scripts/skeleton-check.ts

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

@@ -1,3 +1,8 @@
+/**
+ * 骨架层集成验证(§7-1 消费面):开 skeletonHub + 带 route 的段 → 结果带三值标注;
+ * 枢纽间否定只标注不排除——EK329(数据集滞后的新航线)必须存活。
+ * 运行(在 ts/ 下):npx tsx scripts/skeleton-integration-test.ts
+ */
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -6,17 +11,13 @@ const pack = JSON.parse(await readFile(join('..', 'data', 'flights_2026.json'),
 const spec = parseFlightPackToSpec(pack);
 spec.budgetCny = 9000;
 spec.skeletonHub = true;
-spec.segments.forEach((s)=>{
-    if (s.id === 'f5') s.route = 'SZX->DXB';
-    if (s.id === 'f1') s.route = 'HKG->HKT';
-});
+spec.segments.forEach(s => { if (s.id === 'f5')
+    s.route = 'SZX->DXB'; if (s.id === 'f1')
+    s.route = 'HKG->HKT'; });
 const r = await solveUnified(spec);
 assert.equal(r.feasible, true, '骨架否定不排除——EK329 必须仍在');
-const f5 = r.legs.find((l)=>l.leg === 'f5');
+const f5 = r.legs.find(l => l.leg === 'f5');
 assert.equal(f5?.service, 'EK329', 'EK329 存活(骨架滞后容错)');
-assert.ok((r.skeleton_notes ?? []).some((n)=>n.includes('SZX') && n.includes('❌')), `枢纽否定标注在: ${r.skeleton_notes}`);
-assert.ok((r.skeleton_notes ?? []).some((n)=>n.includes('HKG') && n.includes('✅')), '正向标注在');
+assert.ok((r.skeleton_notes ?? []).some(n => n.includes('SZX') && n.includes('❌')), `枢纽否定标注在: ${r.skeleton_notes}`);
+assert.ok((r.skeleton_notes ?? []).some(n => n.includes('HKG') && n.includes('✅')), '正向标注在');
 console.log(`骨架集成 OK:EK329 在枢纽否定下存活,标注=[${r.skeleton_notes?.join(' | ')}]`);
-
-
-//# sourceURL=ts/scripts/skeleton-integration-test.ts