mustflow 2.11.0 → 2.16.0

package/dist/cli/commands/verify.js

@@ -4,13 +4,13 @@ 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 { 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 { createRepeatedFailureRisks, createVerificationFailureFingerprint, updateRepeatedFailureState, } from '../../core/repeated-failure.js';
+import { countReproEvidenceVerdictEffects, 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 { countValidationRatchetVerdictEffects, 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';
@@ -463,25 +463,212 @@ export function readInputFromPlan(projectRoot, inputPath) {
 function isExternalEvidenceStatus(value) {
     return value === 'passed' || value === 'failed' || value === 'cancelled' || value === 'unknown';
 }
-function isReproEvidenceStatus(value) {
+function isLegacyReproEvidenceStatus(value) {
     return value === 'present' || value === 'unavailable' || value === 'missing';
 }
+function isReproBeforeFixStatus(value) {
+    return value === 'reproduced' || value === 'unavailable' || value === 'missing';
+}
+function isReproBeforeFixOutcome(value) {
+    return value === 'failed_as_expected' || value === 'failed_differently' || value === 'passed_unexpectedly' || value === null;
+}
+function isReproAfterFixStatus(value) {
+    return value === 'passed' || value === 'failed' || value === 'unavailable' || value === 'missing';
+}
+function isReproAfterFixOutcome(value) {
+    return value === 'passed_expected_behavior' || value === 'failed_same_route' || value === 'failed_differently' || value === null;
+}
+function isReproRegressionGuardStatus(value) {
+    return value === 'passed' || value === 'failed' || value === 'unavailable' || value === 'missing';
+}
+function isReproRouteKind(value) {
+    return (value === 'test' ||
+        value === 'cli' ||
+        value === 'browser' ||
+        value === 'api' ||
+        value === 'manual' ||
+        value === 'unknown' ||
+        value === null);
+}
 function readOptionalString(value) {
     return typeof value === 'string' && value.length > 0 ? value : null;
 }
-function readReproEvidenceItem(value) {
+function readRouteStep(value, index) {
+    if (!isPlainRecord(value)) {
+        return {
+            ordinal: index + 1,
+            action: null,
+            target: null,
+            input_digest: null,
+            observation_digest: null,
+            summary: null,
+        };
+    }
+    const ordinal = typeof value.ordinal === 'number' && Number.isInteger(value.ordinal) && value.ordinal > 0 ? value.ordinal : index + 1;
+    return {
+        ordinal,
+        action: readOptionalString(value.action),
+        target: readOptionalString(value.target),
+        input_digest: readOptionalString(value.input_digest),
+        observation_digest: readOptionalString(value.observation_digest),
+        summary: readOptionalString(value.summary),
+    };
+}
+function readReproductionRoute(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            route_id: null,
+            route_kind: null,
+            route_digest: null,
+            failure_oracle_hash: null,
+            steps: [],
+        };
+    }
+    const routeKind = value.route_kind ?? null;
+    if (!isReproRouteKind(routeKind)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    const rawSteps = Array.isArray(value.steps) ? value.steps : [];
+    return {
+        route_id: readOptionalString(value.route_id),
+        route_kind: routeKind,
+        route_digest: readOptionalString(value.route_digest),
+        failure_oracle_hash: readOptionalString(value.failure_oracle_hash),
+        steps: rawSteps.map((step, index) => readRouteStep(step, index)),
+    };
+}
+function readLegacyReproEvidenceItem(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            status: 'missing',
+            summary: null,
+            reason: null,
+        };
+    }
+    if (!isLegacyReproEvidenceStatus(value.status)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    return {
+        status: value.status,
+        summary: readOptionalString(value.summary),
+        reason: readOptionalString(value.reason),
+    };
+}
+function legacyBeforeFixEvidence(value) {
+    const item = readLegacyReproEvidenceItem(value);
+    return {
+        status: item.status === 'present' ? 'reproduced' : item.status,
+        outcome: item.status === 'present' ? 'failed_as_expected' : null,
+        receipt_path: null,
+        receipt_sha256: null,
+        verification_plan_id: null,
+        summary: item.summary,
+        reason: item.reason,
+    };
+}
+function legacyAfterFixEvidence(value) {
+    const item = readLegacyReproEvidenceItem(value);
+    return {
+        status: item.status === 'present' ? 'passed' : item.status,
+        outcome: item.status === 'present' ? 'passed_expected_behavior' : null,
+        same_route_as: null,
+        receipt_path: null,
+        receipt_sha256: null,
+        verification_plan_id: null,
+        summary: item.summary,
+        reason: item.reason,
+    };
+}
+function legacyRegressionGuardEvidence(value) {
+    const item = readLegacyReproEvidenceItem(value);
+    return {
+        status: item.status === 'present' ? 'passed' : item.status,
+        intent: null,
+        test_path: null,
+        receipt_path: null,
+        receipt_sha256: null,
+        verification_plan_id: null,
+        summary: item.summary,
+        reason: item.reason,
+    };
+}
+function readBeforeFixEvidence(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            status: 'missing',
+            outcome: null,
+            receipt_path: null,
+            receipt_sha256: null,
+            verification_plan_id: null,
+            summary: null,
+            reason: null,
+        };
+    }
+    const outcome = value.outcome ?? null;
+    if (!isReproBeforeFixStatus(value.status) || !isReproBeforeFixOutcome(outcome)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    return {
+        status: value.status,
+        outcome,
+        receipt_path: readOptionalString(value.receipt_path),
+        receipt_sha256: readOptionalString(value.receipt_sha256),
+        verification_plan_id: readOptionalString(value.verification_plan_id),
+        summary: readOptionalString(value.summary),
+        reason: readOptionalString(value.reason),
+    };
+}
+function readAfterFixEvidence(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            status: 'missing',
+            outcome: null,
+            same_route_as: null,
+            receipt_path: null,
+            receipt_sha256: null,
+            verification_plan_id: null,
+            summary: null,
+            reason: null,
+        };
+    }
+    const outcome = value.outcome ?? null;
+    if (!isReproAfterFixStatus(value.status) || !isReproAfterFixOutcome(outcome)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    return {
+        status: value.status,
+        outcome,
+        same_route_as: readOptionalString(value.same_route_as),
+        receipt_path: readOptionalString(value.receipt_path),
+        receipt_sha256: readOptionalString(value.receipt_sha256),
+        verification_plan_id: readOptionalString(value.verification_plan_id),
+        summary: readOptionalString(value.summary),
+        reason: readOptionalString(value.reason),
+    };
+}
+function readRegressionGuardEvidence(value) {
     if (!isPlainRecord(value)) {
         return {
             status: 'missing',
+            intent: null,
+            test_path: null,
+            receipt_path: null,
+            receipt_sha256: null,
+            verification_plan_id: null,
             summary: null,
             reason: null,
         };
     }
-    if (!isReproEvidenceStatus(value.status)) {
+    if (!isReproRegressionGuardStatus(value.status)) {
         throw new Error('invalid_repro_evidence_file');
     }
     return {
         status: value.status,
+        intent: readOptionalString(value.intent),
+        test_path: readOptionalString(value.test_path),
+        receipt_path: readOptionalString(value.receipt_path),
+        receipt_sha256: readOptionalString(value.receipt_sha256),
+        verification_plan_id: readOptionalString(value.verification_plan_id),
         summary: readOptionalString(value.summary),
         reason: readOptionalString(value.reason),
     };
@@ -498,16 +685,23 @@ function readReproEvidenceFile(projectRoot, inputPath) {
     if (!isPlainRecord(parsed) || parsed.schema_version !== '1' || parsed.command !== 'repro-evidence') {
         throw new Error('unsupported_repro_evidence_source');
     }
+    const regressionGuard = isPlainRecord(parsed.regression_guard) && isReproRegressionGuardStatus(parsed.regression_guard.status)
+        ? readRegressionGuardEvidence(parsed.regression_guard)
+        : legacyRegressionGuardEvidence(parsed.regression_guard);
     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),
+        reproduction_route: readReproductionRoute(parsed.reproduction_route),
+        before_fix: isPlainRecord(parsed.before_fix)
+            ? readBeforeFixEvidence(parsed.before_fix)
+            : legacyBeforeFixEvidence(parsed.evidence_before_fix),
+        after_fix: isPlainRecord(parsed.after_fix)
+            ? readAfterFixEvidence(parsed.after_fix)
+            : legacyAfterFixEvidence(parsed.evidence_after_fix),
+        regression_guard: regressionGuard,
     };
 }
 function readExternalEvidenceFile(projectRoot, inputPath) {
@@ -674,6 +868,210 @@ function summarizeResults(results) {
         skipped,
     };
 }
+function countUndeclaredWriteDrift(results) {
+    return results.filter((result) => {
+        const writeDrift = result.receipt?.write_drift;
+        if (typeof writeDrift !== 'object' || writeDrift === null) {
+            return false;
+        }
+        return writeDrift.has_undeclared_changes === true;
+    }).length;
+}
+function stringField(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function objectField(value) {
+    return typeof value === 'object' && value !== null ? value : null;
+}
+function performanceForResult(result) {
+    return objectField(result.receipt?.performance);
+}
+function resultSummaryForResult(result) {
+    return objectField(performanceForResult(result)?.result_summary);
+}
+function commandFingerprintForResult(result) {
+    return stringField(performanceForResult(result)?.command_fingerprint);
+}
+function exitCodeClassForResult(result) {
+    const resultSummary = resultSummaryForResult(result);
+    const explicitClass = stringField(resultSummary?.exit_code_class);
+    if (explicitClass) {
+        return explicitClass;
+    }
+    if (result.exit_code === null) {
+        return 'no_exit_code';
+    }
+    return result.exit_code === 0 ? 'success' : 'failure';
+}
+function timedOutForResult(result) {
+    const resultSummary = resultSummaryForResult(result);
+    return result.status === 'timed_out' || resultSummary?.timed_out === true;
+}
+function errorKindForResult(result) {
+    return stringField(resultSummaryForResult(result)?.error_kind) ?? (result.status === 'start_failed' ? 'start_failed' : null);
+}
+function failedResults(results) {
+    return results.filter((result) => !result.skipped &&
+        (result.status === 'failed' || result.status === 'timed_out' || result.status === 'start_failed'));
+}
+function createFailureFingerprintForVerify(input) {
+    const failures = failedResults(input.results);
+    return createVerificationFailureFingerprint({
+        verificationPlanId: input.verificationPlanId,
+        failedIntents: failures.map((result) => result.intent).filter((intent) => intent !== null),
+        exitCodeClasses: failures.map(exitCodeClassForResult).filter((value) => value !== null),
+        timeoutFlags: failures.map(timedOutForResult),
+        errorKinds: failures.map(errorKindForResult).filter((value) => value !== null),
+        riskCodes: input.riskCodes,
+        affectedSurfaces: input.report.requirements.flatMap((requirement) => requirement.surfaces),
+        commandFingerprints: failures.map(commandFingerprintForResult).filter((value) => value !== null),
+    });
+}
+function riskCodesForFailureFingerprint(input) {
+    const writeDriftRiskCodes = countUndeclaredWriteDrift(input.results) > 0 ? ['undeclared_write_drift'] : [];
+    return [
+        ...input.sourceAnchorRisks.map(() => 'source_anchor_invariant_review_required'),
+        ...input.scopeDiffRisks.map((risk) => risk.code),
+        ...input.validationRatchetRisks.map((risk) => risk.code),
+        ...input.reproEvidenceRisks.map((risk) => risk.code),
+        ...input.externalEvidenceRisks.map((risk) => risk.code),
+        ...writeDriftRiskCodes,
+    ];
+}
+function createReceiptBindingEvidence(results, verificationPlanId) {
+    let planBoundCount = 0;
+    let planUnboundCount = 0;
+    let fingerprintBoundCount = 0;
+    let fingerprintUnboundCount = 0;
+    let currentStateBoundCount = 0;
+    let currentStateUnavailableCount = 0;
+    let staleCount = 0;
+    let planMismatchCount = 0;
+    for (const result of results) {
+        if (!result.receipt) {
+            continue;
+        }
+        const receiptPlanId = stringField(result.receipt.verification_plan_id);
+        const resultPlanId = result.verification_plan_id;
+        const resultPlanMatches = resultPlanId === verificationPlanId;
+        const receiptPlanMatches = receiptPlanId === verificationPlanId;
+        if (resultPlanMatches && receiptPlanMatches) {
+            planBoundCount += 1;
+        }
+        else if ((typeof resultPlanId === 'string' && resultPlanId !== verificationPlanId) ||
+            (receiptPlanId !== null && receiptPlanId !== verificationPlanId)) {
+            planMismatchCount += 1;
+        }
+        else {
+            planUnboundCount += 1;
+        }
+        const performance = objectField(result.receipt.performance);
+        const hasFingerprints = performance !== null &&
+            stringField(performance.command_fingerprint) !== null &&
+            stringField(performance.intent_fingerprint) !== null &&
+            stringField(performance.contract_fingerprint) !== null;
+        if (hasFingerprints) {
+            fingerprintBoundCount += 1;
+        }
+        else {
+            fingerprintUnboundCount += 1;
+        }
+        const currentStateBinding = stringField(result.receipt.head_tree_hash) ??
+            stringField(result.receipt.changed_files_hash) ??
+            stringField(result.receipt.current_state_hash);
+        if (currentStateBinding !== null) {
+            currentStateBoundCount += 1;
+        }
+        else {
+            currentStateUnavailableCount += 1;
+        }
+        if (!result.receipt_path || !result.receipt_sha256) {
+            staleCount += 1;
+        }
+    }
+    return {
+        plan_bound_count: planBoundCount,
+        plan_unbound_count: planUnboundCount,
+        fingerprint_bound_count: fingerprintBoundCount,
+        fingerprint_unbound_count: fingerprintUnboundCount,
+        current_state_bound_count: currentStateBoundCount,
+        current_state_unavailable_count: currentStateUnavailableCount,
+        stale_count: staleCount,
+        plan_mismatch_count: planMismatchCount,
+    };
+}
+function resultForSelectedIntent(results, intent) {
+    return results.find((result) => result.intent === intent && result.status !== 'skipped') ?? null;
+}
+function createCriteriaEvidence(report, results) {
+    const evidence = {
+        total: report.requirements.length,
+        covered: 0,
+        partially_covered: 0,
+        uncovered: 0,
+        blocked: 0,
+        contradicted: 0,
+    };
+    return report.requirements.reduce((current, requirement) => {
+        const candidates = report.candidates.filter((candidate) => candidate.reason === requirement.reason);
+        const selectedIntents = candidates
+            .filter((candidate) => candidate.selectionState === 'selected')
+            .map((candidate) => candidate.intent)
+            .filter((intent) => intent !== null);
+        const skippedIntents = candidates
+            .filter((candidate) => candidate.status !== 'runnable')
+            .map((candidate) => candidate.intent)
+            .filter((intent) => intent !== null);
+        const gapCount = report.gaps.filter((gap) => gap.reason === requirement.reason).length;
+        const selectedResults = selectedIntents.map((intent) => resultForSelectedIntent(results, intent));
+        if (selectedResults.some((result) => result?.status === 'failed' || result?.status === 'timed_out' || result?.status === 'start_failed')) {
+            return { ...current, contradicted: current.contradicted + 1 };
+        }
+        if (gapCount > 0 || (selectedIntents.length === 0 && skippedIntents.length > 0)) {
+            return { ...current, blocked: current.blocked + 1 };
+        }
+        if (selectedIntents.length === 0) {
+            return { ...current, uncovered: current.uncovered + 1 };
+        }
+        if (skippedIntents.length > 0) {
+            return { ...current, partially_covered: current.partially_covered + 1 };
+        }
+        if (selectedResults.every((result) => result?.status === 'passed')) {
+            return { ...current, covered: current.covered + 1 };
+        }
+        return { ...current, uncovered: current.uncovered + 1 };
+    }, evidence);
+}
+function createCompletionVerdictForResults(input) {
+    const receiptBinding = createReceiptBindingEvidence(input.results, input.verificationPlanId);
+    const receiptBindingRiskCount = receiptBinding.plan_unbound_count + receiptBinding.fingerprint_unbound_count;
+    const repeatedFailureBlockerCount = input.repeatedFailureRisks.filter((risk) => risk.verdict_effect === 'blocker').length;
+    return createVerifyCompletionVerdict({
+        verificationPlanId: input.verificationPlanId,
+        matchedIntents: input.summary.matched,
+        ranIntents: input.summary.ran,
+        passedIntents: input.summary.passed,
+        failedIntents: input.summary.failed,
+        skippedIntents: input.summary.skipped,
+        receiptCount: input.results.filter((result) => result.receipt !== null).length,
+        sourceAnchorRiskCount: input.sourceAnchorRiskCount,
+        scopeDiffRiskCount: input.scopeDiffRiskCount,
+        repeatedFailureCount: input.repeatedFailureRisks.length,
+        repeatedFailureBlockerCount,
+        validationRatchetRiskCount: input.validationRatchetRiskCount,
+        validationRatchetContradictionCount: input.validationRatchetContradictionCount,
+        reproEvidenceRiskCount: input.reproEvidenceRiskCount,
+        reproEvidenceContradictionCount: input.reproEvidenceContradictionCount,
+        reproEvidenceUnverifiedCount: input.reproEvidenceUnverifiedCount,
+        externalEvidenceRiskCount: input.externalEvidenceRiskCount,
+        writeDriftRiskCount: countUndeclaredWriteDrift(input.results),
+        receiptBindingRiskCount,
+        staleReceiptCount: receiptBinding.stale_count,
+        planMismatchCount: receiptBinding.plan_mismatch_count,
+        criteria: createCriteriaEvidence(input.report, input.results),
+        receiptBinding,
+    });
+}
 function getVerificationStatus(summary) {
     if (summary.failed > 0) {
         return 'failed';
@@ -689,6 +1087,35 @@ function getVerificationStatus(summary) {
 function isVerificationStatus(value) {
     return value === 'passed' || value === 'partial' || value === 'failed' || value === 'blocked';
 }
+function readVerificationFailureFingerprint(value) {
+    const record = objectField(value);
+    if (record?.schema_version !== '1' ||
+        typeof record.fingerprint !== 'string' ||
+        typeof record.verification_plan_id !== 'string' ||
+        typeof record.failed_intents_hash !== 'string' ||
+        typeof record.exit_code_classes_hash !== 'string' ||
+        typeof record.timeout_flags_hash !== 'string' ||
+        typeof record.error_kinds_hash !== 'string' ||
+        typeof record.diagnostic_hash !== 'string' ||
+        typeof record.risk_codes_hash !== 'string' ||
+        typeof record.affected_surfaces_hash !== 'string' ||
+        typeof record.command_fingerprints_hash !== 'string') {
+        return null;
+    }
+    return {
+        schema_version: '1',
+        fingerprint: record.fingerprint,
+        verification_plan_id: record.verification_plan_id,
+        failed_intents_hash: record.failed_intents_hash,
+        exit_code_classes_hash: record.exit_code_classes_hash,
+        timeout_flags_hash: record.timeout_flags_hash,
+        error_kinds_hash: record.error_kinds_hash,
+        diagnostic_hash: record.diagnostic_hash,
+        risk_codes_hash: record.risk_codes_hash,
+        affected_surfaces_hash: record.affected_surfaces_hash,
+        command_fingerprints_hash: record.command_fingerprints_hash,
+    };
+}
 function readPreviousVerifyLatestSummary(projectRoot) {
     try {
         const parsed = JSON.parse(readFileSync(path.join(projectRoot, LATEST_RUN_RECEIPT_PATH), 'utf8'));
@@ -701,6 +1128,7 @@ function readPreviousVerifyLatestSummary(projectRoot) {
         return {
             verification_plan_id: parsed.verification_plan_id,
             status: parsed.status,
+            failure_fingerprint: readVerificationFailureFingerprint(parsed.failure_fingerprint),
         };
     }
     catch {
@@ -750,7 +1178,7 @@ function createVerificationPlanId(report, contract) {
     };
     return hashTextSha256(stableJson(fingerprintSource));
 }
-function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks, scopeDiffRisks, repeatedFailureRisks, validationRatchetRisks, reproEvidence, externalChecks) {
+function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks, scopeDiffRisks, validationRatchetRisks, reproEvidence, externalChecks) {
     const runDir = path.join(projectRoot, VERIFY_RUN_DIR);
     const intentDir = path.join(runDir, 'intents');
     const receipts = [];
@@ -790,22 +1218,72 @@ function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks,
             receipt,
         });
     }
+    const reproEvidenceRisks = createReproEvidenceRisks(reproEvidence, {
+        verificationPlanId: output.verification_plan_id,
+    });
+    const reproEvidenceVerdictEffects = countReproEvidenceVerdictEffects(reproEvidenceRisks);
+    const validationRatchetVerdictEffects = countValidationRatchetVerdictEffects(validationRatchetRisks);
+    const externalEvidenceRisks = createExternalEvidenceRisks(externalChecks);
+    const failureFingerprint = createFailureFingerprintForVerify({
+        verificationPlanId: output.verification_plan_id,
+        report,
+        results,
+        riskCodes: riskCodesForFailureFingerprint({
+            sourceAnchorRisks,
+            scopeDiffRisks,
+            validationRatchetRisks,
+            reproEvidenceRisks,
+            externalEvidenceRisks,
+            results,
+        }),
+    });
+    const repeatedFailureSummary = updateRepeatedFailureState({
+        projectRoot,
+        failureFingerprint,
+        status: output.status,
+    });
+    const previousVerifyLatest = readPreviousVerifyLatestSummary(projectRoot);
+    const finalRepeatedFailureRisks = createRepeatedFailureRisks({
+        previousFailureFingerprint: previousVerifyLatest?.failure_fingerprint ?? null,
+        previousStatus: previousVerifyLatest?.status ?? null,
+        currentFailureFingerprint: failureFingerprint,
+        currentStatus: output.status,
+        currentSummary: repeatedFailureSummary,
+    });
+    const completionVerdict = createCompletionVerdictForResults({
+        report,
+        verificationPlanId: output.verification_plan_id,
+        summary: output.summary,
+        results,
+        sourceAnchorRiskCount: sourceAnchorRisks.length,
+        scopeDiffRiskCount: scopeDiffRisks.length,
+        repeatedFailureRisks: finalRepeatedFailureRisks,
+        validationRatchetRiskCount: validationRatchetRisks.length,
+        validationRatchetContradictionCount: validationRatchetVerdictEffects.contradicted,
+        reproEvidenceRiskCount: reproEvidenceRisks.length,
+        reproEvidenceContradictionCount: reproEvidenceVerdictEffects.contradicted,
+        reproEvidenceUnverifiedCount: reproEvidenceVerdictEffects.unverified,
+        externalEvidenceRiskCount: externalEvidenceRisks.length,
+    });
     const outputWithReceiptPaths = {
         ...output,
+        completion_verdict: completionVerdict,
+        failure_fingerprint: failureFingerprint,
+        repeated_failure_summary: repeatedFailureSummary,
         results,
         evidence_model: createVerifyEvidenceModel({
             report,
             results,
             verificationPlanId: output.verification_plan_id,
-            verdict: output.completion_verdict,
+            verdict: completionVerdict,
             sourceAnchorRisks,
             scopeDiffRisks,
-            repeatedFailureRisks,
+            repeatedFailureRisks: finalRepeatedFailureRisks,
             validationRatchetRisks,
             reproEvidence,
-            reproEvidenceRisks: createReproEvidenceRisks(reproEvidence),
+            reproEvidenceRisks,
             externalChecks,
-            externalEvidenceRisks: createExternalEvidenceRisks(externalChecks),
+            externalEvidenceRisks,
         }),
     };
     const manifest = {
@@ -818,6 +1296,8 @@ function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks,
         status: outputWithReceiptPaths.status,
         completion_verdict: outputWithReceiptPaths.completion_verdict,
         evidence_model: outputWithReceiptPaths.evidence_model,
+        failure_fingerprint: outputWithReceiptPaths.failure_fingerprint,
+        repeated_failure_summary: outputWithReceiptPaths.repeated_failure_summary,
         summary: outputWithReceiptPaths.summary,
         ...(outputWithReceiptPaths.repro_evidence ? { repro_evidence: outputWithReceiptPaths.repro_evidence } : {}),
         ...(outputWithReceiptPaths.external_checks ? { external_checks: outputWithReceiptPaths.external_checks } : {}),
@@ -835,6 +1315,8 @@ function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks,
         status: outputWithReceiptPaths.status,
         completion_verdict: outputWithReceiptPaths.completion_verdict,
         evidence_model: outputWithReceiptPaths.evidence_model,
+        failure_fingerprint: outputWithReceiptPaths.failure_fingerprint,
+        repeated_failure_summary: outputWithReceiptPaths.repeated_failure_summary,
         summary: outputWithReceiptPaths.summary,
         ...(outputWithReceiptPaths.repro_evidence ? { repro_evidence: outputWithReceiptPaths.repro_evidence } : {}),
         ...(outputWithReceiptPaths.external_checks ? { external_checks: outputWithReceiptPaths.external_checks } : {}),
@@ -853,7 +1335,9 @@ async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvi
     const sourceAnchorRisks = await readLocalSourceAnchorVerdictRisks(projectRoot, report.files);
     const scopeDiffRisks = createScopeDiffRisks(input.classificationReport);
     const validationRatchetRisks = createValidationRatchetRisks(input.classificationReport, projectRoot);
-    const reproEvidenceRisks = createReproEvidenceRisks(reproEvidence);
+    const validationRatchetVerdictEffects = countValidationRatchetVerdictEffects(validationRatchetRisks);
+    const reproEvidenceRisks = createReproEvidenceRisks(reproEvidence, { verificationPlanId });
+    const reproEvidenceVerdictEffects = countReproEvidenceVerdictEffects(reproEvidenceRisks);
     const externalEvidenceRisks = createExternalEvidenceRisks(externalChecks);
     const results = [];
     for (const entry of report.schedule.entries) {
@@ -863,26 +1347,38 @@ async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvi
     const summary = summarizeResults(results);
     const status = getVerificationStatus(summary);
     const previousVerifyLatest = readPreviousVerifyLatestSummary(projectRoot);
-    const repeatedFailureRisk = createRepeatedFailureRisk({
-        previousVerificationPlanId: previousVerifyLatest?.verification_plan_id ?? null,
+    const failureFingerprint = createFailureFingerprintForVerify({
+        verificationPlanId,
+        report,
+        results,
+        riskCodes: riskCodesForFailureFingerprint({
+            sourceAnchorRisks,
+            scopeDiffRisks,
+            validationRatchetRisks,
+            reproEvidenceRisks,
+            externalEvidenceRisks,
+            results,
+        }),
+    });
+    const repeatedFailureRisks = createRepeatedFailureRisks({
+        previousFailureFingerprint: previousVerifyLatest?.failure_fingerprint ?? null,
         previousStatus: previousVerifyLatest?.status ?? null,
-        currentVerificationPlanId: verificationPlanId,
+        currentFailureFingerprint: failureFingerprint,
         currentStatus: status,
     });
-    const repeatedFailureRisks = repeatedFailureRisk ? [repeatedFailureRisk] : [];
-    const completionVerdict = createVerifyCompletionVerdict({
+    const completionVerdict = createCompletionVerdictForResults({
+        report,
         verificationPlanId,
-        matchedIntents: summary.matched,
-        ranIntents: summary.ran,
-        passedIntents: summary.passed,
-        failedIntents: summary.failed,
-        skippedIntents: summary.skipped,
-        receiptCount: results.filter((result) => result.receipt !== null).length,
+        summary,
+        results,
         sourceAnchorRiskCount: sourceAnchorRisks.length,
         scopeDiffRiskCount: scopeDiffRisks.length,
-        repeatedFailureCount: repeatedFailureRisks.length,
+        repeatedFailureRisks,
         validationRatchetRiskCount: validationRatchetRisks.length,
+        validationRatchetContradictionCount: validationRatchetVerdictEffects.contradicted,
         reproEvidenceRiskCount: reproEvidenceRisks.length,
+        reproEvidenceContradictionCount: reproEvidenceVerdictEffects.contradicted,
+        reproEvidenceUnverifiedCount: reproEvidenceVerdictEffects.unverified,
         externalEvidenceRiskCount: externalEvidenceRisks.length,
     });
     const evidenceModel = createVerifyEvidenceModel({
@@ -910,6 +1406,8 @@ async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvi
         status,
         completion_verdict: completionVerdict,
         evidence_model: evidenceModel,
+        failure_fingerprint: failureFingerprint,
+        repeated_failure_summary: null,
         summary,
         ...(reproEvidence ? { repro_evidence: reproEvidence } : {}),
         ...(externalChecks.length > 0 ? { external_checks: externalChecks } : {}),
@@ -917,7 +1415,7 @@ async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvi
         manifest_path: toPosixPath(VERIFY_MANIFEST_PATH),
         results,
     };
-    return writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks, scopeDiffRisks, repeatedFailureRisks, validationRatchetRisks, reproEvidence, externalChecks);
+    return writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks, scopeDiffRisks, validationRatchetRisks, reproEvidence, externalChecks);
 }
 async function createPlanOnlyOutput(input, projectRoot) {
     const contract = readCommandContract(projectRoot);