mustflow 1.30.0 → 2.11.0

package/dist/cli/commands/verify.js

@@ -1,14 +1,25 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { createClassifyOutput } from './classify.js';
 import { runRun } from './run.js';
 import { createChangeVerificationReport, } from '../../core/change-verification.js';
+import { createVerifyCompletionVerdict } from '../../core/completion-verdict.js';
+import { createExternalEvidenceRisks, } from '../../core/external-evidence.js';
+import { createRepeatedFailureRisk } from '../../core/repeated-failure.js';
+import { createReproEvidenceRisks, } from '../../core/repro-evidence.js';
+import { createVerifyEvidenceModel } from '../../core/verification-evidence.js';
+import { createScopeDiffRisks } from '../../core/scope-risk.js';
+import { createValidationRatchetRisks } from '../../core/validation-ratchet.js';
 import { readCommandContract } from '../../core/config-loading.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
-import { readLocalCommandEffectGraph, readLocalPathSurfaces, } from '../lib/local-index.js';
+import { readLocalCommandEffectGraph, readLocalPathSurfaces, readLocalSourceAnchorVerdictRisks, } from '../lib/local-index.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 const VERIFY_SCHEMA_VERSION = '1';
+const VERIFY_RUN_DIR = path.join('.mustflow', 'state', 'runs', 'verify-latest');
+const VERIFY_MANIFEST_PATH = path.join(VERIFY_RUN_DIR, 'manifest.json');
+const LATEST_RUN_RECEIPT_PATH = path.join('.mustflow', 'state', 'runs', 'latest.json');
 function createBufferedOutput() {
     const stdout = [];
     const stderr = [];
@@ -31,13 +42,16 @@ function createBufferedOutput() {
 }
 export function getVerifyHelp(lang = 'en') {
     return renderHelp({
-        usage: 'mf verify --reason <event> [options] | mf verify --from-plan <path> [options] | mf verify --changed [options]',
+        usage: 'mf verify --reason <event> [options] | mf verify --from-classification <path> [options] | mf verify --changed [options]',
         summary: t(lang, 'verify.help.summary'),
         options: [
             { label: '--reason <event>', description: t(lang, 'verify.help.option.reason') },
+            { label: '--from-classification <path>', description: t(lang, 'verify.help.option.fromClassification') },
             { label: '--from-plan <path>', description: t(lang, 'verify.help.option.fromPlan') },
             { label: '--changed', description: t(lang, 'verify.help.option.changed') },
             { label: '--write-plan <path>', description: t(lang, 'verify.help.option.writePlan') },
+            { label: '--repro-evidence <path>', description: t(lang, 'verify.help.option.reproEvidence') },
+            { label: '--external-evidence <path>', description: t(lang, 'verify.help.option.externalEvidence') },
             { label: '--plan-only', description: t(lang, 'verify.help.option.planOnly') },
             { label: '--json', description: t(lang, 'cli.option.json') },
             { label: '-h, --help', description: t(lang, 'cli.option.help') },
@@ -46,9 +60,9 @@ export function getVerifyHelp(lang = 'en') {
             'mf verify --reason code_change',
             'mf verify --reason docs_change --json',
             'mf verify --reason docs_change --plan-only --json',
-            'mf verify --from-plan verify-plan.json --json',
+            'mf verify --from-classification .mustflow/state/change-classification.json --json',
+            'mf verify --reason bug_fix --repro-evidence repro-evidence.json --json',
             'mf verify --changed --plan-only --json',
-            'mf verify --changed --write-plan .mustflow/state/change-plan.json --json',
             'mf verify --reason mustflow_docs_change',
         ],
         exitCodes: [
@@ -59,8 +73,11 @@ export function getVerifyHelp(lang = 'en') {
 }
 function parseVerifyArgs(args) {
     let reason;
+    let fromClassification;
     let fromPlan;
     let writePlan;
+    let reproEvidence;
+    let externalEvidence;
     let json = false;
     let planOnly = false;
     let changed = false;
@@ -90,21 +107,86 @@ function parseVerifyArgs(args) {
         if (arg === '--from-plan') {
             const value = args[index + 1];
             if (!value || value.startsWith('-')) {
-                return { json, planOnly, changed, reason, fromPlan, error: 'missing_from_plan_value' };
+                return { json, planOnly, changed, reason, fromClassification, fromPlan, error: 'missing_from_plan_value' };
             }
             fromPlan = value;
             index += 1;
             continue;
         }
+        if (arg === '--from-classification') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('-')) {
+                return {
+                    json,
+                    planOnly,
+                    changed,
+                    reason,
+                    fromClassification,
+                    fromPlan,
+                    error: 'missing_from_classification_value',
+                };
+            }
+            fromClassification = value;
+            index += 1;
+            continue;
+        }
         if (arg === '--write-plan') {
             const value = args[index + 1];
             if (!value || value.startsWith('-')) {
-                return { json, planOnly, changed, reason, fromPlan, writePlan, error: 'missing_write_plan_value' };
+                return {
+                    json,
+                    planOnly,
+                    changed,
+                    reason,
+                    fromClassification,
+                    fromPlan,
+                    writePlan,
+                    error: 'missing_write_plan_value',
+                };
             }
             writePlan = value;
             index += 1;
             continue;
         }
+        if (arg === '--external-evidence') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('-')) {
+                return {
+                    json,
+                    planOnly,
+                    changed,
+                    reason,
+                    fromClassification,
+                    fromPlan,
+                    writePlan,
+                    externalEvidence,
+                    error: 'missing_external_evidence_value',
+                };
+            }
+            externalEvidence = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--repro-evidence') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('-')) {
+                return {
+                    json,
+                    planOnly,
+                    changed,
+                    reason,
+                    fromClassification,
+                    fromPlan,
+                    writePlan,
+                    reproEvidence,
+                    externalEvidence,
+                    error: 'missing_repro_evidence_value',
+                };
+            }
+            reproEvidence = value;
+            index += 1;
+            continue;
+        }
         if (arg.startsWith('--reason=')) {
             const value = arg.slice('--reason='.length);
             if (value.length === 0) {
@@ -116,29 +198,109 @@ function parseVerifyArgs(args) {
         if (arg.startsWith('--from-plan=')) {
             const value = arg.slice('--from-plan='.length);
             if (value.length === 0) {
-                return { json, planOnly, changed, reason, fromPlan, error: 'missing_from_plan_value' };
+                return { json, planOnly, changed, reason, fromClassification, fromPlan, error: 'missing_from_plan_value' };
             }
             fromPlan = value;
             continue;
         }
+        if (arg.startsWith('--from-classification=')) {
+            const value = arg.slice('--from-classification='.length);
+            if (value.length === 0) {
+                return {
+                    json,
+                    planOnly,
+                    changed,
+                    reason,
+                    fromClassification,
+                    fromPlan,
+                    error: 'missing_from_classification_value',
+                };
+            }
+            fromClassification = value;
+            continue;
+        }
         if (arg.startsWith('--write-plan=')) {
             const value = arg.slice('--write-plan='.length);
             if (value.length === 0) {
-                return { json, planOnly, changed, reason, fromPlan, writePlan, error: 'missing_write_plan_value' };
+                return {
+                    json,
+                    planOnly,
+                    changed,
+                    reason,
+                    fromClassification,
+                    fromPlan,
+                    writePlan,
+                    error: 'missing_write_plan_value',
+                };
             }
             writePlan = value;
             continue;
         }
+        if (arg.startsWith('--external-evidence=')) {
+            const value = arg.slice('--external-evidence='.length);
+            if (value.length === 0) {
+                return {
+                    json,
+                    planOnly,
+                    changed,
+                    reason,
+                    fromClassification,
+                    fromPlan,
+                    writePlan,
+                    externalEvidence,
+                    error: 'missing_external_evidence_value',
+                };
+            }
+            externalEvidence = value;
+            continue;
+        }
+        if (arg.startsWith('--repro-evidence=')) {
+            const value = arg.slice('--repro-evidence='.length);
+            if (value.length === 0) {
+                return {
+                    json,
+                    planOnly,
+                    changed,
+                    reason,
+                    fromClassification,
+                    fromPlan,
+                    writePlan,
+                    reproEvidence,
+                    externalEvidence,
+                    error: 'missing_repro_evidence_value',
+                };
+            }
+            reproEvidence = value;
+            continue;
+        }
         if (arg.startsWith('-')) {
-            return { json, planOnly, changed, reason, fromPlan, writePlan, error: arg };
+            return { json, planOnly, changed, reason, fromClassification, fromPlan, writePlan, reproEvidence, externalEvidence, error: arg };
         }
-        return { json, planOnly, changed, reason, fromPlan, writePlan, error: `unexpected:${arg}` };
+        return {
+            json,
+            planOnly,
+            changed,
+            reason,
+            fromClassification,
+            fromPlan,
+            writePlan,
+            reproEvidence,
+            externalEvidence,
+            error: `unexpected:${arg}`,
+        };
     }
-    return { json, planOnly, changed, reason, fromPlan, writePlan };
+    return { json, planOnly, changed, reason, fromClassification, fromPlan, writePlan, reproEvidence, externalEvidence };
 }
 function uniqueStrings(values) {
     return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))];
 }
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function sanitizeIntentFilePart(value) {
+    const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, '_').replace(/^_+|_+$/g, '');
+    return sanitized.length > 0 ? sanitized.slice(0, 80) : 'intent';
+}
 function readStringArray(value) {
     if (!Array.isArray(value)) {
         return [];
@@ -298,6 +460,91 @@ export function readInputFromPlan(projectRoot, inputPath) {
         classificationReport,
     };
 }
+function isExternalEvidenceStatus(value) {
+    return value === 'passed' || value === 'failed' || value === 'cancelled' || value === 'unknown';
+}
+function isReproEvidenceStatus(value) {
+    return value === 'present' || value === 'unavailable' || value === 'missing';
+}
+function readOptionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function readReproEvidenceItem(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            status: 'missing',
+            summary: null,
+            reason: null,
+        };
+    }
+    if (!isReproEvidenceStatus(value.status)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    return {
+        status: value.status,
+        summary: readOptionalString(value.summary),
+        reason: readOptionalString(value.reason),
+    };
+}
+function readReproEvidenceFile(projectRoot, inputPath) {
+    let parsed;
+    const evidencePath = resolvePlanPath(projectRoot, inputPath);
+    try {
+        parsed = JSON.parse(readFileSync(evidencePath, 'utf8'));
+    }
+    catch {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    if (!isPlainRecord(parsed) || parsed.schema_version !== '1' || parsed.command !== 'repro-evidence') {
+        throw new Error('unsupported_repro_evidence_source');
+    }
+    return {
+        source: 'repro_first_debug',
+        authority: 'claim_evidence',
+        reported_symptom: readOptionalString(parsed.reported_symptom),
+        expected_behavior: readOptionalString(parsed.expected_behavior),
+        observed_behavior: readOptionalString(parsed.observed_behavior),
+        original_reproduction: readReproEvidenceItem(parsed.original_reproduction),
+        evidence_before_fix: readReproEvidenceItem(parsed.evidence_before_fix),
+        evidence_after_fix: readReproEvidenceItem(parsed.evidence_after_fix),
+        regression_guard: readReproEvidenceItem(parsed.regression_guard),
+    };
+}
+function readExternalEvidenceFile(projectRoot, inputPath) {
+    let parsed;
+    const evidencePath = resolvePlanPath(projectRoot, inputPath);
+    try {
+        parsed = JSON.parse(readFileSync(evidencePath, 'utf8'));
+    }
+    catch {
+        throw new Error('invalid_external_evidence_file');
+    }
+    if (!isPlainRecord(parsed) || parsed.schema_version !== '1' || parsed.command !== 'external-evidence') {
+        throw new Error('unsupported_external_evidence_source');
+    }
+    if (!Array.isArray(parsed.checks)) {
+        throw new Error('invalid_external_evidence_file');
+    }
+    return parsed.checks.map((check) => {
+        if (!isPlainRecord(check) ||
+            typeof check.provider !== 'string' ||
+            check.provider.length === 0 ||
+            typeof check.name !== 'string' ||
+            check.name.length === 0 ||
+            !isExternalEvidenceStatus(check.status)) {
+            throw new Error('invalid_external_evidence_file');
+        }
+        return {
+            source: 'external_ci',
+            authority: 'supporting_only',
+            provider: check.provider,
+            name: check.name,
+            status: check.status,
+            url: readOptionalString(check.url),
+            summary: readOptionalString(check.summary),
+        };
+    });
+}
 function createInputFromChanged(projectRoot) {
     const plan = createClassifyOutput(projectRoot, 'changed', []);
     return {
@@ -335,6 +582,9 @@ function skippedResult(candidate) {
         reason: candidate.reason,
         detail: candidate.detail,
         exit_code: null,
+        verification_plan_id: null,
+        receipt_path: null,
+        receipt_sha256: null,
         receipt: null,
     };
 }
@@ -343,13 +593,17 @@ function candidateResultKey(candidate) {
         ? `intent:${candidate.intent}`
         : `missing:${candidate.reason}:${candidate.skipReason ?? ''}:${candidate.detail ?? ''}`;
 }
-function createSkippedResults(candidates, scheduledIntents) {
+function createSkippedResults(candidates, scheduledIntents, gaps) {
     const seen = new Set();
     const results = [];
+    const activeGapReasons = new Set(gaps.map((gap) => gap.reason));
     for (const candidate of candidates) {
         if (candidate.status === 'runnable' || (candidate.intent && scheduledIntents.has(candidate.intent))) {
             continue;
         }
+        if (candidate.candidateState === 'gap' && !activeGapReasons.has(candidate.reason)) {
+            continue;
+        }
         const key = candidateResultKey(candidate);
         if (seen.has(key)) {
             continue;
@@ -363,9 +617,19 @@ function createSkippedResults(candidates, scheduledIntents) {
     }
     return results;
 }
-async function runVerificationIntent(intent, lang) {
+function testTargetsByScheduledIntent(report) {
+    return new Map(report.test_selection.selected
+        .filter((candidate) => candidate.status === 'runnable' &&
+        candidate.testTargetsApplied &&
+        candidate.appliedTestTargets.length > 0)
+        .map((candidate) => [candidate.intent, candidate.appliedTestTargets]));
+}
+async function runVerificationIntent(intent, lang, verificationPlanId, testTargets = []) {
     const output = createBufferedOutput();
-    const exitCode = await runRun([intent, '--json'], output.reporter, lang);
+    const exitCode = await runRun([intent, '--json'], output.reporter, lang, {
+        writeLatestReceipt: false,
+        testTargets,
+    });
     const rawStdout = output.stdout().trim();
     let receipt = null;
     let status = exitCode === 0 ? 'passed' : 'failed';
@@ -390,6 +654,9 @@ async function runVerificationIntent(intent, lang) {
         reason: exitCode === 0 ? null : 'run_failed',
         detail: output.stderr().trim() || null,
         exit_code: exitCode,
+        verification_plan_id: verificationPlanId,
+        receipt_path: null,
+        receipt_sha256: null,
         receipt,
     };
 }
@@ -419,31 +686,243 @@ function getVerificationStatus(summary) {
     }
     return 'passed';
 }
-async function createVerifyOutput(input, planSource, projectRoot, lang) {
+function isVerificationStatus(value) {
+    return value === 'passed' || value === 'partial' || value === 'failed' || value === 'blocked';
+}
+function readPreviousVerifyLatestSummary(projectRoot) {
+    try {
+        const parsed = JSON.parse(readFileSync(path.join(projectRoot, LATEST_RUN_RECEIPT_PATH), 'utf8'));
+        if (parsed.command !== 'verify' ||
+            parsed.kind !== 'verify_run_summary' ||
+            typeof parsed.verification_plan_id !== 'string' ||
+            !isVerificationStatus(parsed.status)) {
+            return null;
+        }
+        return {
+            verification_plan_id: parsed.verification_plan_id,
+            status: parsed.status,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function hashTextSha256(content) {
+    return `sha256:${createHash('sha256').update(content).digest('hex')}`;
+}
+function stableJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort((left, right) => left.localeCompare(right))
+            .map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}
+function getCandidateIntentNames(report) {
+    return [...new Set(report.candidates.map((candidate) => candidate.intent).filter((intent) => Boolean(intent)))]
+        .sort((left, right) => left.localeCompare(right));
+}
+function createVerificationPlanId(report, contract) {
+    const relatedIntents = Object.fromEntries(getCandidateIntentNames(report).map((intent) => [intent, contract.intents[intent] ?? null]));
+    const fingerprintSource = {
+        schema_version: '1',
+        algorithm: 'mustflow.verify_plan_id.v1',
+        report: {
+            source: report.source,
+            files: report.files,
+            classification_summary: report.classification_summary,
+            requirements: report.requirements,
+            candidates: report.candidates,
+            gaps: report.gaps,
+            schedule: report.schedule,
+            test_selection: report.test_selection,
+        },
+        command_contract: {
+            defaults: contract.defaults,
+            resources: contract.resources,
+            intents: relatedIntents,
+        },
+    };
+    return hashTextSha256(stableJson(fingerprintSource));
+}
+function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks, scopeDiffRisks, repeatedFailureRisks, validationRatchetRisks, reproEvidence, externalChecks) {
+    const runDir = path.join(projectRoot, VERIFY_RUN_DIR);
+    const intentDir = path.join(runDir, 'intents');
+    const receipts = [];
+    const results = [];
+    rmSync(runDir, { recursive: true, force: true });
+    mkdirSync(intentDir, { recursive: true });
+    for (const [index, result] of output.results.entries()) {
+        let receiptPath = null;
+        let receiptSha256 = null;
+        let receipt = result.receipt;
+        if (result.intent && result.receipt) {
+            const fileName = `${String(index + 1).padStart(3, '0')}-${sanitizeIntentFilePart(result.intent)}.json`;
+            const absoluteReceiptPath = path.join(intentDir, fileName);
+            receiptPath = toPosixPath(path.join(VERIFY_RUN_DIR, 'intents', fileName));
+            receipt = {
+                ...result.receipt,
+                verification_plan_id: output.verification_plan_id,
+                receipt_path: receiptPath,
+            };
+            const receiptContent = `${JSON.stringify(receipt, null, 2)}\n`;
+            receiptSha256 = hashTextSha256(receiptContent);
+            writeFileSync(absoluteReceiptPath, receiptContent, 'utf8');
+        }
+        receipts.push({
+            intent: result.intent,
+            status: result.status,
+            skipped: result.skipped,
+            verification_plan_id: result.skipped ? null : output.verification_plan_id,
+            receipt_path: receiptPath,
+            receipt_sha256: receiptSha256,
+        });
+        results.push({
+            ...result,
+            verification_plan_id: result.skipped ? null : output.verification_plan_id,
+            receipt_path: receiptPath,
+            receipt_sha256: receiptSha256,
+            receipt,
+        });
+    }
+    const outputWithReceiptPaths = {
+        ...output,
+        results,
+        evidence_model: createVerifyEvidenceModel({
+            report,
+            results,
+            verificationPlanId: output.verification_plan_id,
+            verdict: output.completion_verdict,
+            sourceAnchorRisks,
+            scopeDiffRisks,
+            repeatedFailureRisks,
+            validationRatchetRisks,
+            reproEvidence,
+            reproEvidenceRisks: createReproEvidenceRisks(reproEvidence),
+            externalChecks,
+            externalEvidenceRisks: createExternalEvidenceRisks(externalChecks),
+        }),
+    };
+    const manifest = {
+        schema_version: '1',
+        command: 'verify',
+        reason: outputWithReceiptPaths.reason,
+        reasons: outputWithReceiptPaths.reasons,
+        plan_source: outputWithReceiptPaths.plan_source,
+        verification_plan_id: outputWithReceiptPaths.verification_plan_id,
+        status: outputWithReceiptPaths.status,
+        completion_verdict: outputWithReceiptPaths.completion_verdict,
+        evidence_model: outputWithReceiptPaths.evidence_model,
+        summary: outputWithReceiptPaths.summary,
+        ...(outputWithReceiptPaths.repro_evidence ? { repro_evidence: outputWithReceiptPaths.repro_evidence } : {}),
+        ...(outputWithReceiptPaths.external_checks ? { external_checks: outputWithReceiptPaths.external_checks } : {}),
+        receipts,
+    };
+    writeFileSync(path.join(runDir, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    const latest = {
+        schema_version: '1',
+        command: 'verify',
+        kind: 'verify_run_summary',
+        reason: outputWithReceiptPaths.reason,
+        reasons: outputWithReceiptPaths.reasons,
+        plan_source: outputWithReceiptPaths.plan_source,
+        verification_plan_id: outputWithReceiptPaths.verification_plan_id,
+        status: outputWithReceiptPaths.status,
+        completion_verdict: outputWithReceiptPaths.completion_verdict,
+        evidence_model: outputWithReceiptPaths.evidence_model,
+        summary: outputWithReceiptPaths.summary,
+        ...(outputWithReceiptPaths.repro_evidence ? { repro_evidence: outputWithReceiptPaths.repro_evidence } : {}),
+        ...(outputWithReceiptPaths.external_checks ? { external_checks: outputWithReceiptPaths.external_checks } : {}),
+        run_dir: toPosixPath(VERIFY_RUN_DIR),
+        manifest_path: toPosixPath(VERIFY_MANIFEST_PATH),
+    };
+    writeFileSync(path.join(projectRoot, LATEST_RUN_RECEIPT_PATH), `${JSON.stringify(latest, null, 2)}\n`, 'utf8');
+    return outputWithReceiptPaths;
+}
+async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvidence = null, externalChecks = []) {
     const contract = readCommandContract(projectRoot);
     const report = createChangeVerificationReport(input.classificationReport, contract, projectRoot);
+    const verificationPlanId = createVerificationPlanId(report, contract);
     const scheduledIntents = new Set(report.schedule.entries.map((entry) => entry.intent));
+    const scheduledTestTargets = testTargetsByScheduledIntent(report);
+    const sourceAnchorRisks = await readLocalSourceAnchorVerdictRisks(projectRoot, report.files);
+    const scopeDiffRisks = createScopeDiffRisks(input.classificationReport);
+    const validationRatchetRisks = createValidationRatchetRisks(input.classificationReport, projectRoot);
+    const reproEvidenceRisks = createReproEvidenceRisks(reproEvidence);
+    const externalEvidenceRisks = createExternalEvidenceRisks(externalChecks);
     const results = [];
     for (const entry of report.schedule.entries) {
-        results.push(await runVerificationIntent(entry.intent, lang));
+        results.push(await runVerificationIntent(entry.intent, lang, verificationPlanId, scheduledTestTargets.get(entry.intent) ?? []));
     }
-    results.push(...createSkippedResults(report.candidates, scheduledIntents));
+    results.push(...createSkippedResults(report.candidates, scheduledIntents, report.gaps));
     const summary = summarizeResults(results);
-    return {
+    const status = getVerificationStatus(summary);
+    const previousVerifyLatest = readPreviousVerifyLatestSummary(projectRoot);
+    const repeatedFailureRisk = createRepeatedFailureRisk({
+        previousVerificationPlanId: previousVerifyLatest?.verification_plan_id ?? null,
+        previousStatus: previousVerifyLatest?.status ?? null,
+        currentVerificationPlanId: verificationPlanId,
+        currentStatus: status,
+    });
+    const repeatedFailureRisks = repeatedFailureRisk ? [repeatedFailureRisk] : [];
+    const completionVerdict = createVerifyCompletionVerdict({
+        verificationPlanId,
+        matchedIntents: summary.matched,
+        ranIntents: summary.ran,
+        passedIntents: summary.passed,
+        failedIntents: summary.failed,
+        skippedIntents: summary.skipped,
+        receiptCount: results.filter((result) => result.receipt !== null).length,
+        sourceAnchorRiskCount: sourceAnchorRisks.length,
+        scopeDiffRiskCount: scopeDiffRisks.length,
+        repeatedFailureCount: repeatedFailureRisks.length,
+        validationRatchetRiskCount: validationRatchetRisks.length,
+        reproEvidenceRiskCount: reproEvidenceRisks.length,
+        externalEvidenceRiskCount: externalEvidenceRisks.length,
+    });
+    const evidenceModel = createVerifyEvidenceModel({
+        report,
+        results,
+        verificationPlanId,
+        verdict: completionVerdict,
+        sourceAnchorRisks,
+        scopeDiffRisks,
+        repeatedFailureRisks,
+        validationRatchetRisks,
+        reproEvidence,
+        reproEvidenceRisks,
+        externalChecks,
+        externalEvidenceRisks,
+    });
+    const output = {
         schema_version: VERIFY_SCHEMA_VERSION,
         command: 'verify',
         mustflow_root: projectRoot,
         reason: input.reasons.join(', '),
         reasons: input.reasons,
         plan_source: planSource,
-        status: getVerificationStatus(summary),
+        verification_plan_id: verificationPlanId,
+        status,
+        completion_verdict: completionVerdict,
+        evidence_model: evidenceModel,
         summary,
+        ...(reproEvidence ? { repro_evidence: reproEvidence } : {}),
+        ...(externalChecks.length > 0 ? { external_checks: externalChecks } : {}),
+        run_dir: toPosixPath(VERIFY_RUN_DIR),
+        manifest_path: toPosixPath(VERIFY_MANIFEST_PATH),
         results,
     };
+    return writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks, scopeDiffRisks, repeatedFailureRisks, validationRatchetRisks, reproEvidence, externalChecks);
 }
 async function createPlanOnlyOutput(input, projectRoot) {
     const contract = readCommandContract(projectRoot);
     const report = createChangeVerificationReport(input.classificationReport, contract, projectRoot);
+    const verificationPlanId = createVerificationPlanId(report, contract);
     const localSurfaceReadModels = await readLocalPathSurfaces(projectRoot, report.files);
     const [firstEntry] = report.schedule.entries;
     const requirements = report.requirements.map((requirement) => {
@@ -453,7 +932,7 @@ async function createPlanOnlyOutput(input, projectRoot) {
         return surfaceReadModels.length > 0 ? { ...requirement, surfaceReadModels } : requirement;
     });
     if (!firstEntry) {
-        return { ...report, requirements };
+        return { ...report, verification_plan_id: verificationPlanId, requirements };
     }
     const firstGraph = await readLocalCommandEffectGraph(projectRoot, firstEntry.intent);
     const graphsByIntent = new Map([[firstEntry.intent, firstGraph]]);
@@ -466,6 +945,7 @@ async function createPlanOnlyOutput(input, projectRoot) {
     }
     return {
         ...report,
+        verification_plan_id: verificationPlanId,
         requirements,
         schedule: {
             ...report.schedule,
@@ -483,6 +963,7 @@ function renderVerifyOutput(output, lang) {
         `${t(lang, 'verify.label.reason')}: ${output.reason}`,
         `${t(lang, 'verify.label.planSource')}: ${output.plan_source ?? t(lang, 'value.none')}`,
         `${t(lang, 'verify.label.status')}: ${output.status}`,
+        `completion verdict: ${output.completion_verdict.status} (${output.completion_verdict.primary_reason})`,
         `matched: ${output.summary.matched}`,
         `ran: ${output.summary.ran}`,
         `passed: ${output.summary.passed}`,
@@ -507,17 +988,28 @@ export async function runVerify(args, reporter, lang = 'en') {
     if (parsed.error) {
         const message = parsed.error === 'missing_reason_value'
             ? t(lang, 'cli.error.missingValue', { option: '--reason' })
-            : parsed.error === 'missing_from_plan_value'
-                ? t(lang, 'cli.error.missingValue', { option: '--from-plan' })
-                : parsed.error === 'missing_write_plan_value'
-                    ? t(lang, 'cli.error.missingValue', { option: '--write-plan' })
-                    : parsed.error.startsWith('unexpected:')
-                        ? t(lang, 'cli.error.unexpectedArgument', { argument: parsed.error.slice('unexpected:'.length) })
-                        : t(lang, 'cli.error.unknownOption', { option: parsed.error });
+            : parsed.error === 'missing_from_classification_value'
+                ? t(lang, 'cli.error.missingValue', { option: '--from-classification' })
+                : parsed.error === 'missing_from_plan_value'
+                    ? t(lang, 'cli.error.missingValue', { option: '--from-plan' })
+                    : parsed.error === 'missing_write_plan_value'
+                        ? t(lang, 'cli.error.missingValue', { option: '--write-plan' })
+                        : parsed.error === 'missing_repro_evidence_value'
+                            ? t(lang, 'cli.error.missingValue', { option: '--repro-evidence' })
+                            : parsed.error === 'missing_external_evidence_value'
+                                ? t(lang, 'cli.error.missingValue', { option: '--external-evidence' })
+                                : parsed.error.startsWith('unexpected:')
+                                    ? t(lang, 'cli.error.unexpectedArgument', { argument: parsed.error.slice('unexpected:'.length) })
+                                    : t(lang, 'cli.error.unknownOption', { option: parsed.error });
         printUsageError(reporter, message, 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
     }
-    const selectedInputCount = [parsed.reason, parsed.fromPlan, parsed.changed ? 'changed' : undefined].filter(Boolean).length;
+    const selectedInputCount = [
+        parsed.reason,
+        parsed.fromClassification,
+        parsed.fromPlan,
+        parsed.changed ? 'changed' : undefined,
+    ].filter(Boolean).length;
     if (selectedInputCount > 1) {
         printUsageError(reporter, t(lang, 'verify.error.conflictingInputs'), 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
@@ -534,17 +1026,27 @@ export async function runVerify(args, reporter, lang = 'en') {
         printUsageError(reporter, t(lang, 'verify.error.planOnlyJson'), 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
     }
+    if (parsed.planOnly && parsed.reproEvidence) {
+        printUsageError(reporter, t(lang, 'verify.error.reproEvidenceRequiresRun'), 'mf verify --help', getVerifyHelp(lang), lang);
+        return 1;
+    }
+    if (parsed.planOnly && parsed.externalEvidence) {
+        printUsageError(reporter, t(lang, 'verify.error.externalEvidenceRequiresRun'), 'mf verify --help', getVerifyHelp(lang), lang);
+        return 1;
+    }
     const projectRoot = resolveMustflowRoot();
     let input;
     let changedPlan = null;
+    let reproEvidence = null;
+    let externalChecks = [];
     try {
         if (parsed.changed) {
             const changedInput = createInputFromChanged(projectRoot);
             input = changedInput.input;
             changedPlan = changedInput.plan;
         }
-        else if (parsed.fromPlan) {
-            input = readInputFromPlan(projectRoot, parsed.fromPlan);
+        else if (parsed.fromClassification || parsed.fromPlan) {
+            input = readInputFromPlan(projectRoot, (parsed.fromClassification ?? parsed.fromPlan));
         }
         else {
             input = {
@@ -555,17 +1057,32 @@ export async function runVerify(args, reporter, lang = 'en') {
         if (parsed.writePlan && changedPlan) {
             writeChangedPlan(projectRoot, parsed.writePlan, changedPlan);
         }
+        if (parsed.reproEvidence) {
+            reproEvidence = readReproEvidenceFile(projectRoot, parsed.reproEvidence);
+        }
+        if (parsed.externalEvidence) {
+            externalChecks = readExternalEvidenceFile(projectRoot, parsed.externalEvidence);
+        }
     }
     catch (error) {
         const code = error instanceof Error ? error.message : 'invalid_plan_file';
-        printUsageError(reporter, t(lang, planErrorMessageKey(code)), 'mf verify --help', getVerifyHelp(lang), lang);
+        const message = code === 'invalid_repro_evidence_file'
+            ? t(lang, 'verify.error.invalid_repro_evidence_file')
+            : code === 'unsupported_repro_evidence_source'
+                ? t(lang, 'verify.error.unsupported_repro_evidence_source')
+                : code === 'invalid_external_evidence_file'
+                    ? t(lang, 'verify.error.invalid_external_evidence_file')
+                    : code === 'unsupported_external_evidence_source'
+                        ? t(lang, 'verify.error.unsupported_external_evidence_source')
+                        : t(lang, planErrorMessageKey(code));
+        printUsageError(reporter, message, 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
     }
     if (parsed.planOnly) {
         reporter.stdout(JSON.stringify(await createPlanOnlyOutput(input, projectRoot), null, 2));
         return 0;
     }
-    const output = await createVerifyOutput(input, parsed.fromPlan ?? (parsed.changed ? 'changed' : null), projectRoot, lang);
+    const output = await createVerifyOutput(input, parsed.fromClassification ?? parsed.fromPlan ?? (parsed.changed ? 'changed' : null), projectRoot, lang, reproEvidence, externalChecks);
     if (parsed.json) {
         reporter.stdout(JSON.stringify(output, null, 2));
     }