mustflow 2.22.5 → 2.22.9

package/dist/cli/lib/local-index/source-index.js

@@ -0,0 +1,137 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { isRecord, readStringArray } from '../command-contract.js';
+import { readMustflowTomlFile } from '../toml.js';
+import { listSourceAnchorFiles } from '../../../core/source-anchors.js';
+import { INDEX_CONFIG_RELATIVE_PATH, LATEST_RUN_STATE_RELATIVE_PATH, MUSTFLOW_RELATIVE_PATH, SOURCE_INDEX_MAX_FILE_BYTES, } from './constants.js';
+import { sha256Bytes, sha256Text } from './hashing.js';
+import { getExistingIndexablePaths } from './workflow-documents.js';
+function readIndexToml(projectRoot) {
+    const indexConfigPath = path.join(projectRoot, ...INDEX_CONFIG_RELATIVE_PATH.split('/'));
+    if (!existsSync(indexConfigPath)) {
+        return undefined;
+    }
+    const parsed = readMustflowTomlFile(projectRoot, INDEX_CONFIG_RELATIVE_PATH);
+    return isRecord(parsed) ? parsed : undefined;
+}
+function readNestedTable(table, key) {
+    if (!table || !isRecord(table[key])) {
+        return undefined;
+    }
+    return table[key];
+}
+function readOptionalStringArray(table, key) {
+    return table ? readStringArray(table, key) ?? null : null;
+}
+function readBoolean(table, key) {
+    const value = table?.[key];
+    return typeof value === 'boolean' ? value : undefined;
+}
+function readPositiveInteger(table, key) {
+    const value = table?.[key];
+    if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
+        return null;
+    }
+    return value;
+}
+export function readMustflowToml(projectRoot) {
+    const mustflowPath = path.join(projectRoot, ...MUSTFLOW_RELATIVE_PATH.split('/'));
+    if (!existsSync(mustflowPath)) {
+        return undefined;
+    }
+    const parsed = readMustflowTomlFile(projectRoot, MUSTFLOW_RELATIVE_PATH);
+    return isRecord(parsed) ? parsed : undefined;
+}
+export function readLocalIndexSourceConfig(projectRoot) {
+    const sourceIndexTable = readNestedTable(readIndexToml(projectRoot), 'source_index');
+    const configuredMaxFileBytes = readPositiveInteger(sourceIndexTable, 'max_file_bytes');
+    return {
+        enabledByDefault: readBoolean(sourceIndexTable, 'enabled_by_default') === true,
+        include: readOptionalStringArray(sourceIndexTable, 'include') ?? [],
+        exclude: readOptionalStringArray(sourceIndexTable, 'exclude') ?? [],
+        maxFileBytes: Math.min(configuredMaxFileBytes ?? SOURCE_INDEX_MAX_FILE_BYTES, SOURCE_INDEX_MAX_FILE_BYTES),
+        allowedExtensions: readOptionalStringArray(sourceIndexTable, 'allowed_extensions') ?? [],
+    };
+}
+export function getSourceScopeHash(includeSource, sourceConfig) {
+    return sha256Text(JSON.stringify({
+        includeSource,
+        sourceConfig,
+    }));
+}
+export function normalizeIndexedFileSourceScope(value) {
+    if (value === 'source_anchor' || value === 'state') {
+        return value;
+    }
+    return 'workflow';
+}
+export function readIndexedFileRecord(projectRoot, relativePath, sourceScope, contentHash = null) {
+    const metadata = readIndexedFileMetadataRecord(projectRoot, relativePath, sourceScope);
+    return {
+        ...metadata,
+        contentHash: contentHash ?? sha256Bytes(readFileSync(path.join(projectRoot, ...relativePath.split('/')))),
+    };
+}
+function hashIndexedFileMetadataRecord(projectRoot, metadata) {
+    return {
+        ...metadata,
+        contentHash: sha256Bytes(readFileSync(path.join(projectRoot, ...metadata.path.split('/')))),
+    };
+}
+export function hashIndexedFileMetadataRecords(projectRoot, metadataRecords) {
+    return metadataRecords.map((metadata) => hashIndexedFileMetadataRecord(projectRoot, metadata));
+}
+export function readIndexedFileMetadataRecord(projectRoot, relativePath, sourceScope) {
+    const fullPath = path.join(projectRoot, ...relativePath.split('/'));
+    const stats = statSync(fullPath);
+    return {
+        path: relativePath,
+        sourceScope,
+        sizeBytes: stats.size,
+        mtimeMs: Math.round(stats.mtimeMs),
+    };
+}
+export function collectIndexedFileRecords(projectRoot, documents, sourceAnchors, sourceAnchorCandidatePaths = []) {
+    const records = new Map();
+    for (const document of documents) {
+        records.set(document.path, readIndexedFileRecord(projectRoot, document.path, 'workflow', document.contentHash));
+    }
+    const sourcePaths = new Set([...sourceAnchorCandidatePaths, ...sourceAnchors.map((anchor) => anchor.path)]);
+    for (const anchorPath of [...sourcePaths].sort((left, right) => left.localeCompare(right))) {
+        if (!records.has(anchorPath)) {
+            records.set(anchorPath, readIndexedFileRecord(projectRoot, anchorPath, 'source_anchor'));
+        }
+    }
+    if (existsSync(path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/')))) {
+        records.set(LATEST_RUN_STATE_RELATIVE_PATH, readIndexedFileRecord(projectRoot, LATEST_RUN_STATE_RELATIVE_PATH, 'state'));
+    }
+    return [...records.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+export function collectSourceAnchorCandidatePaths(projectRoot, sourceConfig) {
+    return listSourceAnchorFiles(projectRoot, {
+        ...sourceConfig,
+        excludeGeneratedOrVendor: true,
+    });
+}
+export function collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSource, sourceConfig) {
+    const records = new Map();
+    for (const relativePath of getExistingIndexablePaths(projectRoot)) {
+        records.set(relativePath, readIndexedFileMetadataRecord(projectRoot, relativePath, 'workflow'));
+    }
+    if (includeSource) {
+        try {
+            for (const sourcePath of collectSourceAnchorCandidatePaths(projectRoot, sourceConfig)) {
+                if (!records.has(sourcePath)) {
+                    records.set(sourcePath, readIndexedFileMetadataRecord(projectRoot, sourcePath, 'source_anchor'));
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    if (existsSync(path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/')))) {
+        records.set(LATEST_RUN_STATE_RELATIVE_PATH, readIndexedFileMetadataRecord(projectRoot, LATEST_RUN_STATE_RELATIVE_PATH, 'state'));
+    }
+    return [...records.values()].sort((left, right) => left.path.localeCompare(right.path));
+}

package/dist/cli/lib/local-index/verification-evidence.js

@@ -0,0 +1,451 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { MUSTFLOW_JSON_MAX_BYTES, readMustflowTextFile } from '../mustflow-read.js';
+import { LATEST_RUN_STATE_RELATIVE_PATH } from './constants.js';
+import { sha256Bytes, sha256Text } from './hashing.js';
+const VALIDATION_RATCHET_RISK_CODES = new Set([
+    'related_test_deleted',
+    'skip_or_only_marker_present',
+    'todo_or_pending_marker_added',
+    'assertion_count_decreased',
+    'assertion_matcher_weakened',
+    'negative_assertion_removed',
+    'exception_assertion_removed',
+    'snapshot_mass_updated',
+    'golden_output_replaced',
+    'verification_intent_disabled',
+    'verification_required_after_removed',
+    'success_exit_codes_widened',
+    'command_allows_no_tests',
+    'command_forces_snapshot_update',
+    'command_hides_failure',
+    'coverage_threshold_lowered',
+    'test_selection_narrowed',
+]);
+function emptyVerificationEvidenceIndex() {
+    return {
+        summaries: [],
+        verificationPlans: [],
+        acceptanceCriteria: [],
+        criterionCoverage: [],
+        receipts: [],
+        commandReceiptSummaries: [],
+        coverageStates: [],
+        riskSignals: [],
+        validationRatchetSignals: [],
+        completionVerdictSummaries: [],
+        failureFingerprints: [],
+        reproRoutes: [],
+        reproObservations: [],
+        failureFingerprintReadModels: [],
+    };
+}
+function isJsonRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readJsonRecord(projectRoot, relativePath) {
+    try {
+        const content = readMustflowTextFile(projectRoot, relativePath, { maxBytes: MUSTFLOW_JSON_MAX_BYTES });
+        const parsed = JSON.parse(content);
+        return isJsonRecord(parsed) ? { content, value: parsed } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === 'string' ? value : null;
+}
+function booleanField(record, key) {
+    return record?.[key] === true;
+}
+function numberField(record, key) {
+    const value = record?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function recordField(record, key) {
+    const value = record?.[key];
+    return isJsonRecord(value) ? value : null;
+}
+function recordArrayField(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value.filter(isJsonRecord) : [];
+}
+function stringArrayField(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function hashJson(value) {
+    return sha256Text(JSON.stringify(value));
+}
+function stringListHash(values) {
+    const normalized = values.filter((value) => typeof value === 'string' && value.length > 0);
+    return normalized.length > 0 ? hashJson([...normalized].sort((left, right) => left.localeCompare(right))) : null;
+}
+function reproObservation(routeId, phase, evidence) {
+    const status = stringField(evidence, 'status');
+    const outcome = stringField(evidence, 'outcome') ?? status;
+    const receiptHash = stringField(evidence, 'receipt_sha256');
+    const diagnosticFingerprint = stringField(evidence, 'diagnostic_fingerprint') ??
+        stringField(evidence, 'diagnostic_hash') ??
+        hashJson({
+            phase,
+            status,
+            outcome,
+            summary: stringField(evidence, 'summary'),
+            reason: stringField(evidence, 'reason'),
+        });
+    return {
+        routeId,
+        phase,
+        outcome,
+        receiptHash,
+        diagnosticFingerprint,
+    };
+}
+function evidenceStatusForRunReceipt(latest) {
+    return stringField(latest, 'status') ?? (booleanField(latest, 'timed_out') ? 'timed_out' : 'unknown');
+}
+function failedIntentsFromReceipts(receipts) {
+    return receipts
+        .filter((receipt) => ['failed', 'timed_out', 'start_failed'].includes(receipt.status))
+        .map((receipt) => receipt.intent)
+        .filter((intent) => typeof intent === 'string' && intent.length > 0)
+        .sort((left, right) => left.localeCompare(right));
+}
+function createFailureFingerprint(input) {
+    if (input.status === 'passed' ||
+        input.status === 'verified' ||
+        (input.failedIntents.length === 0 && input.riskCodes.length === 0 && input.timedOut !== true && !input.errorKind)) {
+        return null;
+    }
+    return sha256Text(JSON.stringify({
+        command: input.command,
+        status: input.status,
+        verificationPlanId: input.verificationPlanId,
+        primaryReason: input.primaryReason,
+        failedIntents: [...input.failedIntents].sort((left, right) => left.localeCompare(right)),
+        riskCodes: [...input.riskCodes].sort((left, right) => left.localeCompare(right)),
+        runIntent: input.runIntent ?? null,
+        timedOut: input.timedOut === true,
+        exitCodeClass: input.exitCodeClass ?? null,
+        errorKind: input.errorKind ?? null,
+    }));
+}
+export function createVerificationEvidenceIndex(projectRoot) {
+    const latestPath = path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/'));
+    if (!existsSync(latestPath)) {
+        return emptyVerificationEvidenceIndex();
+    }
+    const latestRecord = readJsonRecord(projectRoot, LATEST_RUN_STATE_RELATIVE_PATH);
+    if (!latestRecord) {
+        return emptyVerificationEvidenceIndex();
+    }
+    const latest = latestRecord.value;
+    const sourceHash = sha256Bytes(Buffer.from(latestRecord.content));
+    const command = stringField(latest, 'command') ?? 'unknown';
+    const kind = stringField(latest, 'kind') ?? (command === 'verify' ? 'verify_run_summary' : 'run_receipt');
+    const evidenceModel = recordField(latest, 'evidence_model');
+    const completionVerdict = recordField(latest, 'completion_verdict');
+    const completionEvidence = recordField(completionVerdict, 'evidence');
+    const verificationPlanId = stringField(latest, 'verification_plan_id') ?? stringField(evidenceModel, 'verification_plan_id');
+    const primaryReason = stringField(completionVerdict, 'primary_reason');
+    const status = stringField(latest, 'status') ?? stringField(completionVerdict, 'status') ?? 'unknown';
+    const completionStatus = stringField(completionVerdict, 'status');
+    const rawReceipts = recordArrayField(evidenceModel, 'receipts');
+    const rawCoverage = recordArrayField(evidenceModel, 'coverage_matrix');
+    const rawRequirements = recordArrayField(evidenceModel, 'requirements');
+    const rawRisks = recordArrayField(evidenceModel, 'remaining_risks');
+    const recordedFailureFingerprintRecord = recordField(latest, 'failure_fingerprint');
+    const repeatedFailureSummary = recordField(latest, 'repeated_failure_summary');
+    const reproEvidence = recordField(latest, 'repro_evidence') ?? recordField(evidenceModel, 'repro_evidence');
+    const reproductionRoute = recordField(reproEvidence, 'reproduction_route');
+    const recordedFailureFingerprint = stringField(recordedFailureFingerprintRecord, 'fingerprint');
+    const receipts = rawReceipts.length > 0
+        ? rawReceipts.map((receipt, index) => ({
+            sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
+            ordinal: index + 1,
+            intent: stringField(receipt, 'intent'),
+            status: stringField(receipt, 'status') ?? 'unknown',
+            skipped: booleanField(receipt, 'skipped'),
+            verificationPlanId: stringField(receipt, 'verification_plan_id'),
+            receiptPath: stringField(receipt, 'receipt_path'),
+            receiptSha256: stringField(receipt, 'receipt_sha256'),
+            commandFingerprint: stringField(receipt, 'command_fingerprint'),
+            contractFingerprint: stringField(receipt, 'contract_fingerprint'),
+            currentStateHash: stringField(receipt, 'head_tree_hash') ??
+                stringField(receipt, 'changed_files_hash') ??
+                stringField(receipt, 'changed_file_hash'),
+            writeDriftStatus: stringField(receipt, 'write_drift_status'),
+        }))
+        : [
+            {
+                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
+                ordinal: 1,
+                intent: stringField(latest, 'intent'),
+                status: evidenceStatusForRunReceipt(latest),
+                skipped: false,
+                verificationPlanId: null,
+                receiptPath: stringField(latest, 'receipt_path') ?? LATEST_RUN_STATE_RELATIVE_PATH,
+                receiptSha256: sourceHash,
+                commandFingerprint: stringField(recordField(latest, 'performance'), 'command_fingerprint'),
+                contractFingerprint: stringField(recordField(latest, 'performance'), 'contract_fingerprint'),
+                currentStateHash: stringField(latest, 'head_tree_hash') ?? stringField(latest, 'changed_files_hash'),
+                writeDriftStatus: stringField(recordField(latest, 'write_drift'), 'status'),
+            },
+        ];
+    const coverageStates = rawCoverage.map((coverage) => {
+        const evidence = recordField(coverage, 'evidence');
+        return {
+            sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
+            criterionId: stringField(coverage, 'criterion_id') ?? 'unknown',
+            source: stringField(coverage, 'source') ?? 'unknown',
+            status: stringField(coverage, 'status') ?? 'unknown',
+            requirementReason: stringField(coverage, 'requirement_reason'),
+            intents: stringArrayField(evidence, 'intents'),
+            receiptCount: stringArrayField(evidence, 'receipt_paths').length,
+            gapCount: stringArrayField(evidence, 'gap_reasons').length,
+            sourceAnchorCount: stringArrayField(evidence, 'source_anchor_ids').length,
+        };
+    });
+    const riskSignals = rawRisks.map((risk, index) => ({
+        sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
+        ordinal: index + 1,
+        code: stringField(risk, 'code') ?? 'unknown',
+        severity: stringField(risk, 'severity') ?? 'unknown',
+        detailHash: sha256Text(stringField(risk, 'detail') ?? ''),
+    }));
+    const validationRatchetSignals = rawRisks
+        .map((risk, index) => {
+        const code = stringField(risk, 'code') ?? 'unknown';
+        if (!VALIDATION_RATCHET_RISK_CODES.has(code)) {
+            return null;
+        }
+        const severity = stringField(risk, 'severity') ?? 'unknown';
+        const pathValue = stringField(risk, 'path');
+        const detailHash = sha256Text(stringField(risk, 'detail') ?? '');
+        const pathHash = pathValue === null ? hashJson({ code, detailHash }) : sha256Text(pathValue);
+        const beforeHash = stringField(risk, 'before_hash') ?? stringField(risk, 'before_digest');
+        const afterHash = stringField(risk, 'after_hash') ?? stringField(risk, 'after_digest');
+        return {
+            signalId: hashJson({
+                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
+                ordinal: index + 1,
+                planId: verificationPlanId,
+                code,
+                pathHash,
+                beforeHash,
+                afterHash,
+            }),
+            planId: verificationPlanId,
+            code,
+            severity,
+            pathHash,
+            beforeHash,
+            afterHash,
+        };
+    })
+        .filter((signal) => signal !== null);
+    const verificationPlans = verificationPlanId === null
+        ? []
+        : [
+            {
+                planId: verificationPlanId,
+                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
+                classificationHash: rawRequirements.length > 0 || rawCoverage.length > 0
+                    ? hashJson({
+                        requirements: rawRequirements.map((requirement) => ({
+                            id: stringField(requirement, 'requirement_id') ?? stringField(requirement, 'id'),
+                            reason: stringField(requirement, 'reason'),
+                            source: stringField(requirement, 'source'),
+                        })),
+                        coverage: rawCoverage.map((coverage) => ({
+                            id: stringField(coverage, 'criterion_id'),
+                            reason: stringField(coverage, 'requirement_reason'),
+                            source: stringField(coverage, 'source'),
+                            status: stringField(coverage, 'status'),
+                        })),
+                    })
+                    : null,
+                commandContractHash: stringListHash(receipts.map((receipt) => receipt.contractFingerprint)),
+                selectedIntentsHash: stringListHash(receipts.map((receipt) => receipt.intent)),
+                createdAt: stringField(latest, 'started_at') ?? stringField(latest, 'created_at'),
+                sourceHash,
+            },
+        ];
+    const acceptanceCriteria = verificationPlanId === null
+        ? []
+        : rawCoverage.map((coverage) => {
+            const evidence = recordField(coverage, 'evidence');
+            const pathRefs = [
+                ...stringArrayField(evidence, 'paths'),
+                ...stringArrayField(evidence, 'changed_paths'),
+                ...stringArrayField(evidence, 'source_anchor_ids'),
+            ];
+            return {
+                criterionId: stringField(coverage, 'criterion_id') ?? 'unknown',
+                planId: verificationPlanId,
+                source: stringField(coverage, 'source') ?? 'unknown',
+                statementHash: stringField(coverage, 'statement') ? sha256Text(stringField(coverage, 'statement') ?? '') : null,
+                reason: stringField(coverage, 'requirement_reason'),
+                surface: stringField(coverage, 'surface'),
+                pathHash: pathRefs.length > 0 ? stringListHash(pathRefs) : null,
+            };
+        });
+    const criterionCoverage = verificationPlanId === null
+        ? []
+        : coverageStates.map((coverage) => ({
+            criterionId: coverage.criterionId,
+            planId: verificationPlanId,
+            status: coverage.status,
+            receiptCount: coverage.receiptCount,
+            gapCount: coverage.gapCount,
+            riskCount: coverage.sourceAnchorCount,
+        }));
+    const commandReceiptSummaries = verificationPlanId === null
+        ? []
+        : receipts
+            .filter((receipt) => receipt.verificationPlanId === verificationPlanId || receipt.verificationPlanId === null)
+            .map((receipt) => ({
+            receiptHash: receipt.receiptSha256 ??
+                hashJson({
+                    sourcePath: receipt.sourcePath,
+                    ordinal: receipt.ordinal,
+                    intent: receipt.intent,
+                    status: receipt.status,
+                    verificationPlanId,
+                }),
+            planId: verificationPlanId,
+            intent: receipt.intent,
+            status: receipt.status,
+            commandFingerprint: receipt.commandFingerprint,
+            contractFingerprint: receipt.contractFingerprint,
+            currentStateHash: receipt.currentStateHash,
+            writeDriftStatus: receipt.writeDriftStatus,
+        }));
+    const completionVerdictSummaries = verificationPlanId === null || completionStatus === null
+        ? []
+        : [
+            {
+                claimId: hashJson({
+                    sourceHash,
+                    verificationPlanId,
+                    completionStatus,
+                    primaryReason,
+                }),
+                planId: verificationPlanId,
+                status: completionStatus,
+                primaryReason,
+                riskCount: riskSignals.length,
+                contradictionCount: stringArrayField(completionVerdict, 'contradictions').length,
+                blockerCount: stringArrayField(completionVerdict, 'blockers').length,
+            },
+        ];
+    const failedIntents = failedIntentsFromReceipts(receipts);
+    const failureFingerprint = recordedFailureFingerprint ??
+        createFailureFingerprint({
+            command,
+            status: completionStatus ?? status,
+            verificationPlanId,
+            primaryReason,
+            failedIntents,
+            riskCodes: riskSignals.map((risk) => risk.code),
+            runIntent: stringField(latest, 'intent'),
+            timedOut: booleanField(latest, 'timed_out'),
+            exitCodeClass: stringField(recordField(recordField(latest, 'performance'), 'result_summary'), 'exit_code_class'),
+            errorKind: stringField(recordField(recordField(latest, 'performance'), 'result_summary'), 'error_kind'),
+        });
+    const failureFingerprints = failureFingerprint === null
+        ? []
+        : [
+            {
+                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
+                fingerprint: failureFingerprint,
+                verificationPlanId,
+                status: completionStatus ?? status,
+                failedIntents,
+                primaryReason,
+                failedIntentsHash: stringField(recordedFailureFingerprintRecord, 'failed_intents_hash') ??
+                    stringField(repeatedFailureSummary, 'failed_intents_hash'),
+                riskCodesHash: stringField(recordedFailureFingerprintRecord, 'risk_codes_hash') ??
+                    stringField(repeatedFailureSummary, 'risk_codes_hash'),
+                affectedSurfacesHash: stringField(recordedFailureFingerprintRecord, 'affected_surfaces_hash') ??
+                    stringField(repeatedFailureSummary, 'affected_surfaces_hash'),
+                firstSeenAt: stringField(repeatedFailureSummary, 'first_seen_at'),
+                lastSeenAt: stringField(repeatedFailureSummary, 'last_seen_at'),
+                seenCount: Math.max(1, numberField(repeatedFailureSummary, 'seen_count')),
+                requiresNewEvidence: booleanField(repeatedFailureSummary, 'requires_new_evidence'),
+            },
+        ];
+    const routeId = stringField(reproductionRoute, 'route_id');
+    const reproRoutes = routeId === null || reproEvidence === null
+        ? []
+        : [
+            {
+                routeId,
+                taskHash: hashJson({
+                    reported_symptom: stringField(reproEvidence, 'reported_symptom'),
+                    expected_behavior: stringField(reproEvidence, 'expected_behavior'),
+                    observed_behavior: stringField(reproEvidence, 'observed_behavior'),
+                }),
+                routeDigest: stringField(reproductionRoute, 'route_digest'),
+                routeKind: stringField(reproductionRoute, 'route_kind'),
+                failureOracleHash: stringField(reproductionRoute, 'failure_oracle_hash'),
+            },
+        ];
+    const reproObservations = routeId === null || reproEvidence === null
+        ? []
+        : [
+            reproObservation(routeId, 'before_fix', recordField(reproEvidence, 'before_fix')),
+            reproObservation(routeId, 'after_fix', recordField(reproEvidence, 'after_fix')),
+            reproObservation(routeId, 'regression_guard', recordField(reproEvidence, 'regression_guard')),
+        ];
+    const failureFingerprintReadModels = failureFingerprints.map((fingerprint) => ({
+        fingerprint: fingerprint.fingerprint,
+        planId: fingerprint.verificationPlanId,
+        failedIntentsHash: fingerprint.failedIntentsHash ?? stringListHash(fingerprint.failedIntents),
+        riskCodesHash: fingerprint.riskCodesHash,
+        seenCount: fingerprint.seenCount,
+        firstSeenAt: fingerprint.firstSeenAt,
+        lastSeenAt: fingerprint.lastSeenAt,
+    }));
+    return {
+        summaries: [
+            {
+                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
+                sourceHash,
+                command,
+                kind,
+                status,
+                runDir: stringField(latest, 'run_dir'),
+                manifestPath: stringField(latest, 'manifest_path'),
+                verificationPlanId,
+                completionStatus,
+                primaryReason,
+                matchedIntents: numberField(completionEvidence, 'matched_intents'),
+                ranIntents: numberField(completionEvidence, 'ran_intents'),
+                passedIntents: numberField(completionEvidence, 'passed_intents'),
+                failedIntents: numberField(completionEvidence, 'failed_intents'),
+                skippedIntents: numberField(completionEvidence, 'skipped_intents'),
+                receiptCount: receipts.length,
+                coverageCount: coverageStates.length,
+                remainingRiskCount: riskSignals.length,
+                failureFingerprint,
+            },
+        ],
+        verificationPlans,
+        acceptanceCriteria,
+        criterionCoverage,
+        receipts,
+        commandReceiptSummaries,
+        coverageStates,
+        riskSignals,
+        validationRatchetSignals,
+        completionVerdictSummaries,
+        failureFingerprints,
+        reproRoutes,
+        reproObservations,
+        failureFingerprintReadModels,
+    };
+}