mustflow 2.70.0 → 2.74.1

package/dist/core/active-run-locks.js

@@ -6,6 +6,7 @@ import { readUtf8FileInsideWithoutSymlinks, writeJsonFileInsideWithoutSymlinks,
 const ACTIVE_LOCK_SCHEMA_VERSION = '1';
 const ACTIVE_LOCK_KIND = 'active_run_lock';
 const LOCK_ROOT_RELATIVE_PATH = '.mustflow/state/locks';
+export const ACTIVE_RUN_LOCK_ID_ENV = 'MUSTFLOW_ACTIVE_RUN_LOCK_ID';
 const LOCK_MUTEX_STALE_MS = 30_000;
 const LOCK_MUTEX_WAIT_MS = 1_000;
 const LOCK_MUTEX_SLEEP_MS = 25;
@@ -462,7 +463,12 @@ export function acquireActiveRunLock(projectRoot, contract, intentName, options
             }
         }
         const staleRecordIds = new Set(staleRecords.map((stale) => stale.runId));
-        const liveRecords = records.filter((record) => !staleRecordIds.has(record.run_id));
+        const liveRecords = records.filter((record) => {
+            if (staleRecordIds.has(record.run_id)) {
+                return false;
+            }
+            return record.run_id !== options.ignoreRunId || record.pid !== options.ignorePid;
+        });
         const conflicts = findConflicts(intentName, effects, liveRecords);
         if (conflicts.length > 0) {
             return { ok: false, conflicts, recoveredStaleRecords: staleRecords };

package/dist/core/change-verification.js

@@ -4,6 +4,7 @@ import { classifyVerificationCandidate, createVerificationPlan, } from './verifi
 import { createVerificationDecisionGraph, } from './verification-decision-graph.js';
 import { createVerificationSchedule, } from './verification-scheduler.js';
 import { createProjectTestSelectionPlan, } from './test-selection.js';
+import { createVerificationRiskAssessment, } from './risk-priced-evidence.js';
 export const CHANGE_VERIFICATION_SCHEMA_VERSION = '1';
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left.localeCompare(right));
@@ -328,6 +329,14 @@ export function createChangeVerificationReport(classificationReport, commandCont
     const gaps = requirements
         .map((requirement) => gapForRequirement(requirement, candidates))
         .filter((gap) => gap !== null);
+    const riskAssessment = createVerificationRiskAssessment({
+        classificationSummary: classificationReport.summary,
+        requirements,
+        candidates,
+        gaps,
+        commandContract,
+        selectedIntents: schedule.entries.map((entry) => entry.intent),
+    });
     return {
         schema_version: CHANGE_VERIFICATION_SCHEMA_VERSION,
         source: classificationReport.source,
@@ -336,6 +345,7 @@ export function createChangeVerificationReport(classificationReport, commandCont
         requirements,
         candidates,
         gaps,
+        risk_assessment: riskAssessment,
         schedule,
         decision_graph: createVerificationDecisionGraph(commandContract, requirements, candidates, gaps, schedule),
         test_selection: testSelectionPlan.report,

package/dist/core/completion-verdict.js

@@ -10,6 +10,7 @@ function createRiskEvidence(input) {
         receipt_binding: input.receiptBindingRiskCount ?? 0,
         stale_receipt: input.staleReceiptCount ?? 0,
         plan_mismatch: input.planMismatchCount ?? 0,
+        risk_priced_evidence: input.riskPricedEvidenceRiskCount ?? 0,
     };
 }
 function emptyReceiptBindingEvidence() {
@@ -158,6 +159,9 @@ function verifyStatus(input) {
     if ((input.externalEvidenceRiskCount ?? 0) > 0) {
         downgradeLimitations.push('external_evidence_requires_review');
     }
+    if ((input.riskPricedEvidenceRiskCount ?? 0) > 0) {
+        downgradeLimitations.push('risk_priced_evidence_requires_review');
+    }
     if (downgradeLimitations.length > 0) {
         return {
             status: 'partially_verified',
@@ -175,7 +179,9 @@ function verifyStatus(input) {
                                     ? 'stale_receipt_review_required'
                                     : (input.reproEvidenceRiskCount ?? 0) > 0
                                         ? 'repro_evidence_missing'
-                                        : 'external_evidence_review_required',
+                                        : (input.externalEvidenceRiskCount ?? 0) > 0
+                                            ? 'external_evidence_review_required'
+                                            : 'risk_priced_evidence_review_required',
             blockers: [],
             contradictions: [],
             limitations: downgradeLimitations,
@@ -230,6 +236,7 @@ export function createVerifyCompletionVerdict(input) {
             receipt_binding_risk_count: normalizedInput.receiptBindingRiskCount ?? 0,
             stale_receipt_count: normalizedInput.staleReceiptCount ?? 0,
             plan_mismatch_count: normalizedInput.planMismatchCount ?? 0,
+            risk_priced_evidence_risk_count: normalizedInput.riskPricedEvidenceRiskCount ?? 0,
             risks,
             receipt_binding: receiptBinding,
             latest_run_status: null,
@@ -269,6 +276,11 @@ export function createDashboardCompletionVerdict(input) {
         primaryReason = 'scope_diff_review_required';
         limitations.push('scope_diff_risk_requires_review');
     }
+    else if ((input.riskPricedEvidenceRiskCount ?? 0) > 0) {
+        status = 'partially_verified';
+        primaryReason = 'risk_priced_evidence_review_required';
+        limitations.push('risk_priced_evidence_requires_review');
+    }
     else if (input.gapCount > 0) {
         status = 'blocked';
         primaryReason = 'verification_gaps_present';
@@ -331,6 +343,7 @@ export function createDashboardCompletionVerdict(input) {
             receipt_binding_risk_count: input.receiptBindingRiskCount ?? 0,
             stale_receipt_count: input.staleReceiptCount ?? 0,
             plan_mismatch_count: input.planMismatchCount ?? 0,
+            risk_priced_evidence_risk_count: input.riskPricedEvidenceRiskCount ?? 0,
             risks,
             receipt_binding: receiptBinding,
             latest_run_status: input.latestRunStatus,

package/dist/core/complexity-budget.js

@@ -0,0 +1,206 @@
+export const COMPLEXITY_BUDGET_DEFAULTS = {
+    scoreBudget: 12,
+    maxConfigSurfaces: 2,
+    maxSchemaSurfaces: 2,
+    maxPathsPerRisk: 8,
+};
+const CHANGE_KIND_FAMILY_BY_KIND = {
+    documentation: 'documentation',
+    example: 'documentation',
+    translation: 'documentation',
+    workflow: 'workflow',
+    host_instruction: 'workflow',
+    installed_template: 'template',
+    package_metadata: 'release',
+    schema: 'contract',
+    test: 'test',
+    test_fixture: 'test',
+    implementation: 'implementation',
+    unknown: 'unknown',
+};
+const DEPENDENCY_SURFACE_FILENAMES = new Set([
+    'package.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'bun.lock',
+    'bun.lockb',
+    'yarn.lock',
+    'Cargo.toml',
+    'Cargo.lock',
+    'go.mod',
+    'go.sum',
+    'pyproject.toml',
+    'pom.xml',
+    'build.gradle',
+    'deno.json',
+    'deno.jsonc',
+]);
+const CONFIG_SURFACE_FILENAMES = new Set(['Makefile', 'justfile', 'Dockerfile']);
+const CONFIG_FILE_PATTERN = /(?:config|rc)\.(?:cjs|cts|js|json|mjs|mts|toml|ts|yaml|yml)$/u;
+const HELPER_FILE_PATTERN = /.*(?:helper|helpers|util|utils|manager|common|misc).*\.(?:cjs|cts|go|java|js|jsx|kt|mjs|mts|php|ps1|py|rb|rs|swift|ts|tsx)$/u;
+const REQUIREMENTS_FILE_PATTERN = /^requirements(?:-[^/]*)?\.txt$/u;
+const TSCONFIG_FILE_PATTERN = /^tsconfig[^/]*\.json$/u;
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function changeKindFamily(kind) {
+    return CHANGE_KIND_FAMILY_BY_KIND[kind] ?? kind;
+}
+function baseName(file) {
+    const slashIndex = file.lastIndexOf('/');
+    return slashIndex === -1 ? file : file.slice(slashIndex + 1);
+}
+function isDependencySurface(file) {
+    const name = baseName(file);
+    return DEPENDENCY_SURFACE_FILENAMES.has(name) || REQUIREMENTS_FILE_PATTERN.test(name);
+}
+function isConfigurationSurface(file) {
+    const name = baseName(file);
+    return (file.startsWith('.github/') ||
+        file.startsWith('.mustflow/config/') ||
+        CONFIG_SURFACE_FILENAMES.has(name) ||
+        CONFIG_FILE_PATTERN.test(name) ||
+        TSCONFIG_FILE_PATTERN.test(name));
+}
+function isHelperContainer(file) {
+    return HELPER_FILE_PATTERN.test(baseName(file));
+}
+function isSchemaSurface(file) {
+    return file.startsWith('schemas/') && file.endsWith('.schema.json');
+}
+function matchingPaths(files, predicate) {
+    return files.filter(predicate);
+}
+function firstPaths(paths) {
+    return paths.slice(0, COMPLEXITY_BUDGET_DEFAULTS.maxPathsPerRisk);
+}
+function metric(name, value, weight) {
+    return {
+        name,
+        value,
+        weight,
+        weighted_score: value * weight,
+    };
+}
+function scoreMetrics(input) {
+    const families = uniqueSorted(input.summary.changeKinds.map(changeKindFamily));
+    const dependencySurfaces = matchingPaths(input.files, isDependencySurface);
+    const configSurfaces = matchingPaths(input.files, isConfigurationSurface);
+    const helperContainers = matchingPaths(input.files, isHelperContainer);
+    const schemaSurfaces = matchingPaths(input.files, isSchemaSurface);
+    return [
+        metric('changed_files', input.summary.fileCount, 1),
+        metric('public_surfaces', input.summary.publicSurfaceCount, 2),
+        metric('change_kind_families_beyond_one', Math.max(0, families.length - 1), 2),
+        metric('dependency_surfaces', dependencySurfaces.length, 5),
+        metric('configuration_surfaces', configSurfaces.length, 3),
+        metric('helper_containers', helperContainers.length, 3),
+        metric('schema_surfaces', schemaSurfaces.length, 2),
+    ];
+}
+function risk(input) {
+    return {
+        code: input.code,
+        severity: 'warning',
+        detail: input.detail,
+        count: input.count,
+        limit: input.limit,
+        paths: firstPaths(input.paths),
+    };
+}
+function createComplexityBudgetRisks(input, score) {
+    const dependencySurfaces = matchingPaths(input.files, isDependencySurface);
+    const configSurfaces = matchingPaths(input.files, isConfigurationSurface);
+    const helperContainers = matchingPaths(input.files, isHelperContainer);
+    const schemaSurfaces = matchingPaths(input.files, isSchemaSurface);
+    const risks = [];
+    if (score > COMPLEXITY_BUDGET_DEFAULTS.scoreBudget) {
+        risks.push(risk({
+            code: 'complexity_score_budget_exceeded',
+            detail: `Complexity score ${score} exceeds the review budget of ${COMPLEXITY_BUDGET_DEFAULTS.scoreBudget}.`,
+            count: score,
+            limit: COMPLEXITY_BUDGET_DEFAULTS.scoreBudget,
+            paths: input.files,
+        }));
+    }
+    if (dependencySurfaces.length > 0) {
+        risks.push(risk({
+            code: 'dependency_surface_requires_justification',
+            detail: [
+                'Dependency or package manifest changes add operational cost;',
+                'justify the dependency boundary and rollback path.',
+            ].join(' '),
+            count: dependencySurfaces.length,
+            limit: 0,
+            paths: dependencySurfaces,
+        }));
+    }
+    if (helperContainers.length > 0) {
+        risks.push(risk({
+            code: 'helper_container_requires_justification',
+            detail: [
+                'Helper, util, common, manager, or misc files tend to hide broad abstractions;',
+                'justify why the new surface reduces net complexity.',
+            ].join(' '),
+            count: helperContainers.length,
+            limit: 0,
+            paths: helperContainers,
+        }));
+    }
+    if (configSurfaces.length > COMPLEXITY_BUDGET_DEFAULTS.maxConfigSurfaces) {
+        risks.push(risk({
+            code: 'configuration_surface_budget_exceeded',
+            detail: [
+                `Configuration surface count ${configSurfaces.length}`,
+                `exceeds the review budget of ${COMPLEXITY_BUDGET_DEFAULTS.maxConfigSurfaces}.`,
+            ].join(' '),
+            count: configSurfaces.length,
+            limit: COMPLEXITY_BUDGET_DEFAULTS.maxConfigSurfaces,
+            paths: configSurfaces,
+        }));
+    }
+    if (schemaSurfaces.length > COMPLEXITY_BUDGET_DEFAULTS.maxSchemaSurfaces) {
+        risks.push(risk({
+            code: 'schema_surface_budget_exceeded',
+            detail: [
+                `Schema surface count ${schemaSurfaces.length}`,
+                `exceeds the review budget of ${COMPLEXITY_BUDGET_DEFAULTS.maxSchemaSurfaces}.`,
+            ].join(' '),
+            count: schemaSurfaces.length,
+            limit: COMPLEXITY_BUDGET_DEFAULTS.maxSchemaSurfaces,
+            paths: schemaSurfaces,
+        }));
+    }
+    return risks;
+}
+function reviewPrompts(risks) {
+    if (risks.length === 0) {
+        return [];
+    }
+    return [
+        'Explain why this added complexity is necessary for the requested outcome.',
+        'Name the simpler alternative that was rejected and why it is not enough.',
+        'Identify the rollback or removal path if the added surface proves unnecessary.',
+    ];
+}
+export function createComplexityBudgetReport(input) {
+    const metrics = scoreMetrics(input);
+    const score = metrics.reduce((total, entry) => total + entry.weighted_score, 0);
+    const risks = createComplexityBudgetRisks(input, score);
+    return {
+        schema_version: '1',
+        source: 'change_classification',
+        status: risks.length > 0 ? 'review_required' : 'within_budget',
+        score,
+        budget: COMPLEXITY_BUDGET_DEFAULTS.scoreBudget,
+        metrics,
+        risks,
+        review_prompts: reviewPrompts(risks),
+    };
+}
+export function createComplexityBudgetReportFromVerification(report) {
+    return createComplexityBudgetReport({
+        files: report.files,
+        summary: report.classification_summary,
+    });
+}

package/dist/core/conflict-ledger.js

@@ -0,0 +1,122 @@
+import { createHash } from 'node:crypto';
+function hashConflictIdentity(value) {
+    return `conflict:${createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 16)}`;
+}
+function uniqueSorted(values) {
+    return [...new Set([...values].filter((value) => typeof value === 'string' && value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function remainingRiskSeverity(severity) {
+    if (severity === 'critical') {
+        return 'critical';
+    }
+    if (severity === 'high' || severity === 'error') {
+        return 'error';
+    }
+    if (severity === 'medium' || severity === 'warning') {
+        return 'warning';
+    }
+    return 'info';
+}
+function createConflictItem(input) {
+    return {
+        id: hashConflictIdentity({
+            kind: input.kind,
+            summary: input.summary,
+            detail: input.detail,
+            sources: input.sources,
+        }),
+        status: 'open',
+        owner: 'user_or_maintainer',
+        expires_at: null,
+        ...input,
+    };
+}
+function verdictItem(kind, key) {
+    const contradiction = kind === 'contradiction';
+    return createConflictItem({
+        kind,
+        severity: contradiction ? 'critical' : 'error',
+        summary: key,
+        detail: contradiction
+            ? `Completion evidence is contradicted by ${key}.`
+            : `Completion is blocked by ${key}.`,
+        sources: [
+            {
+                kind: 'completion_verdict',
+                authority: 'verdict',
+                key,
+                paths: [],
+                surfaces: [],
+            },
+        ],
+        affected_paths: [],
+        affected_surfaces: [],
+        blocks_completion: true,
+        resolution: contradiction
+            ? 'Resolve the contradictory evidence and rerun verification before claiming completion.'
+            : 'Resolve the blocker and provide fresh verification evidence before claiming completion.',
+    });
+}
+function gapItem(gap) {
+    const key = gap.reason ?? gap.intent ?? gap.status ?? 'verification_gap';
+    return createConflictItem({
+        kind: 'verification_gap',
+        severity: 'error',
+        summary: key,
+        detail: gap.detail ?? 'Verification coverage is missing for this requirement.',
+        sources: [
+            {
+                kind: 'verification_gap',
+                authority: 'verification_plan',
+                key,
+                paths: uniqueSorted(gap.files),
+                surfaces: uniqueSorted(gap.surfaces),
+            },
+        ],
+        affected_paths: uniqueSorted(gap.files),
+        affected_surfaces: uniqueSorted(gap.surfaces),
+        blocks_completion: true,
+        resolution: 'Add or run an allowed verification intent that covers this gap, then refresh the evidence model.',
+    });
+}
+function riskItem(risk) {
+    const severity = remainingRiskSeverity(risk.severity);
+    return createConflictItem({
+        kind: 'remaining_risk',
+        severity,
+        summary: risk.code,
+        detail: risk.detail,
+        sources: [
+            {
+                kind: 'remaining_risk',
+                authority: 'evidence_model',
+                key: risk.code,
+                paths: [],
+                surfaces: [],
+            },
+        ],
+        affected_paths: [],
+        affected_surfaces: [],
+        blocks_completion: severity === 'error' || severity === 'critical',
+        resolution: 'Review the remaining risk and attach stronger evidence or an explicit acceptance decision.',
+    });
+}
+export function createConflictLedger(input) {
+    const items = [
+        ...input.verdict.blockers.map((blocker) => verdictItem('blocker', blocker)),
+        ...input.verdict.contradictions.map((contradiction) => verdictItem('contradiction', contradiction)),
+        ...input.gaps.map(gapItem),
+        ...input.remainingRisks.map(riskItem),
+    ];
+    const blockingCount = items.filter((item) => item.blocks_completion).length;
+    const contradictionCount = items.filter((item) => item.kind === 'contradiction').length;
+    return {
+        schema_version: '1',
+        source: 'verification_evidence_model',
+        status: items.length > 0 ? 'open' : 'clear',
+        item_count: items.length,
+        blocking_count: blockingCount,
+        contradiction_count: contradictionCount,
+        items,
+    };
+}

package/dist/core/failure-replay-capsule.js

@@ -0,0 +1,213 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+function stableJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+        return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function sha256(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function sha256Json(value) {
+    return sha256(stableJson(value));
+}
+function uniqueSorted(values) {
+    return [...new Set([...values].filter((value) => typeof value === 'string' && value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function numberArray(values) {
+    return [...new Set([...values].filter((value) => typeof value === 'number' && Number.isFinite(value)))]
+        .sort((left, right) => left - right);
+}
+function objectField(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function numberField(record, key) {
+    const value = record?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function booleanField(record, key) {
+    return record?.[key] === true;
+}
+function stringArrayField(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string' && entry.length > 0) : [];
+}
+function hashTail(output) {
+    const tail = stringField(output, 'tail');
+    return tail === null ? null : sha256(tail);
+}
+function isFailedResult(result) {
+    return (!result.skipped &&
+        result.intent !== null &&
+        (result.status === 'failed' ||
+            result.status === 'timed_out' ||
+            result.status === 'start_failed' ||
+            result.status === 'output_limit_exceeded'));
+}
+function createFailedResult(result) {
+    const receipt = result.receipt;
+    const performance = objectField(receipt?.performance);
+    const resultSummary = objectField(performance?.result_summary);
+    const stdout = objectField(receipt?.stdout);
+    const stderr = objectField(receipt?.stderr);
+    const stdoutTruncated = booleanField(stdout, 'truncated');
+    const stderrTruncated = booleanField(stderr, 'truncated');
+    const intent = result.intent;
+    return {
+        intent,
+        status: result.status,
+        exit_code: result.exit_code,
+        exit_code_class: stringField(resultSummary, 'exit_code_class'),
+        error_kind: stringField(resultSummary, 'error_kind'),
+        timed_out: result.status === 'timed_out' || booleanField(resultSummary, 'timed_out'),
+        receipt_path: result.receipt_path,
+        receipt_sha256: result.receipt_sha256,
+        command_fingerprint: stringField(performance, 'command_fingerprint'),
+        contract_fingerprint: stringField(performance, 'contract_fingerprint'),
+        stdout_tail_hash: hashTail(stdout),
+        stderr_tail_hash: hashTail(stderr),
+        output_truncated: stdoutTruncated || stderrTruncated,
+        replay_command: `mf run ${intent}`,
+    };
+}
+function fileFingerprint(projectRoot, relativePath) {
+    const normalized = relativePath.split(path.sep).join('/');
+    const absolute = path.resolve(projectRoot, ...normalized.split('/'));
+    const relativeToRoot = path.relative(projectRoot, absolute);
+    if (relativeToRoot.startsWith('..') || path.isAbsolute(relativeToRoot)) {
+        return {
+            path: normalized,
+            status: 'outside_root',
+            sha256: null,
+            bytes: null,
+        };
+    }
+    if (!existsSync(absolute)) {
+        return {
+            path: normalized,
+            status: 'missing',
+            sha256: null,
+            bytes: null,
+        };
+    }
+    try {
+        const stats = statSync(absolute);
+        if (!stats.isFile()) {
+            return {
+                path: normalized,
+                status: 'unreadable',
+                sha256: null,
+                bytes: null,
+            };
+        }
+        const content = readFileSync(absolute);
+        return {
+            path: normalized,
+            status: 'present',
+            sha256: sha256(content),
+            bytes: content.byteLength,
+        };
+    }
+    catch {
+        return {
+            path: normalized,
+            status: 'unreadable',
+            sha256: null,
+            bytes: null,
+        };
+    }
+}
+function changedFileFingerprints(projectRoot, report) {
+    return uniqueSorted(report.files)
+        .map((filePath) => fileFingerprint(projectRoot, filePath))
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+function redactionSummary(results) {
+    const redactionRecords = results
+        .map((result) => objectField(result.receipt?.redaction))
+        .filter((record) => record !== null);
+    const redactionCount = redactionRecords.reduce((sum, record) => sum + (numberField(record, 'redaction_count') ?? 0), 0);
+    return {
+        raw_output_included: false,
+        env_values_included: false,
+        receipt_paths_only: true,
+        redacted: redactionRecords.some((record) => booleanField(record, 'redacted')),
+        redaction_count: redactionCount,
+        redaction_kinds: uniqueSorted(redactionRecords.flatMap((record) => stringArrayField(record, 'redaction_kinds'))),
+        redaction_fields: uniqueSorted(redactionRecords.flatMap((record) => stringArrayField(record, 'fields'))),
+    };
+}
+function environmentSummary(results) {
+    const receipts = results.map((result) => result.receipt).filter((receipt) => receipt !== null);
+    const runners = receipts
+        .map((receipt) => objectField(objectField(receipt.performance)?.runner))
+        .filter((runner) => runner !== null);
+    return {
+        platform_family: uniqueSorted(runners.map((runner) => stringField(runner, 'platform_family')))[0] ?? null,
+        arch_family: uniqueSorted(runners.map((runner) => stringField(runner, 'arch_family')))[0] ?? null,
+        runtimes: uniqueSorted(runners.map((runner) => {
+            const runtime = stringField(runner, 'runtime');
+            const major = numberField(runner, 'runtime_major');
+            return runtime === null ? null : `${runtime}${major === null ? '' : `@${major}`}`;
+        })),
+        env_policies: uniqueSorted(receipts.map((receipt) => stringField(receipt, 'env_policy'))),
+        env_allowlist: uniqueSorted(receipts.flatMap((receipt) => stringArrayField(receipt, 'env_allowlist'))),
+        timeout_seconds: numberArray(receipts.map((receipt) => numberField(receipt, 'timeout_seconds'))),
+    };
+}
+function riskCodes(report) {
+    return uniqueSorted([
+        ...report.risk_assessment.reasons,
+        ...report.risk_assessment.blocking_gaps,
+        ...report.gaps.map((gap) => gap.reason),
+    ]);
+}
+export function createFailureReplayCapsule(input) {
+    const failedResults = input.results.filter(isFailedResult).map(createFailedResult);
+    if (failedResults.length === 0) {
+        return null;
+    }
+    const affectedFiles = changedFileFingerprints(input.projectRoot, input.report);
+    const affectedSurfaces = uniqueSorted(input.report.requirements.flatMap((requirement) => requirement.surfaces));
+    const replayCommands = uniqueSorted([
+        ...failedResults.map((result) => result.replay_command),
+        `mf verify --reason ${input.reasons[0] ?? 'unknown'} --json`,
+    ]);
+    const base = {
+        schema_version: '1',
+        source: 'mf_verify_failure',
+        authority: 'replay_supporting_evidence',
+        created_at: (input.createdAt ?? new Date()).toISOString(),
+        verification_plan_id: input.verificationPlanId,
+        failure_fingerprint: input.failureFingerprint?.fingerprint ?? null,
+        reasons: uniqueSorted(input.reasons),
+        status: input.status,
+        replay_commands: replayCommands,
+        failed_results: failedResults,
+        affected_files: affectedFiles,
+        affected_surfaces: affectedSurfaces,
+        risk_codes: riskCodes(input.report),
+        environment: environmentSummary(input.results),
+        privacy: redactionSummary(input.results),
+    };
+    return {
+        ...base,
+        hashes: {
+            capsule_fingerprint: sha256Json(base),
+            changed_files_hash: sha256Json(affectedFiles),
+            failed_results_hash: sha256Json(failedResults),
+            command_fingerprints_hash: sha256Json(failedResults.map((result) => result.command_fingerprint)),
+            output_tails_hash: sha256Json(failedResults.flatMap((result) => [result.stdout_tail_hash, result.stderr_tail_hash])),
+        },
+    };
+}

package/dist/core/public-json-contracts.js

@@ -207,6 +207,33 @@ const PUBLIC_JSON_SCHEMA_CONTRACTS = [
         installedCommand: ['mf', 'quality', 'check', '--json'],
         expectedExitCodes: [0, 1],
     },
+    {
+        id: 'script-pack-catalog',
+        schemaFile: 'script-pack-catalog.schema.json',
+        producer: 'mf script-pack list --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'script-pack', 'list', '--json'],
+    },
+    {
+        id: 'text-budget-report',
+        schemaFile: 'text-budget-report.schema.json',
+        producer: 'mf script-pack run core/text-budget check <path...> --json',
+        packaged: true,
+        documented: true,
+        installedCommand: [
+            'mf',
+            'script-pack',
+            'run',
+            'core/text-budget',
+            'check',
+            'AGENTS.md',
+            '--max',
+            '1000000',
+            '--json',
+        ],
+        expectedExitCodes: [0, 1],
+    },
     {
         id: 'skill-route-report',
         schemaFile: 'skill-route-report.schema.json',