loopforge 3.9.2 → 4.0.7

package/dist/verification-gate.js

@@ -21,14 +21,16 @@
 import { afterObservations, gitDeltaState } from "./evidence-provider.js";
 import { deriveFilesReconciliation } from "./files-reconciliation.js";
 import { isPassedAfterObservation } from "./evidence-provider.js";
-import { getPolicy } from "./policy.js";
+import { deriveConfiguredCapability, getPolicy } from "./policy.js";
 import { makeVerificationFlag, makeVerificationResult } from "./protocol.js";
-import { isRecord, entryRound, extractFilePathTokens } from "./token-utils.js";
-import { derivationRounds, machineGitMotionSeries, entryViolations, } from "./committed-round.js";
-import { deriveActiveRoundContract, sameContract, } from "./round-contract.js";
-import { deriveContractItemStatuses, } from "./contract-items.js";
-import { deriveClaimView, resolveRoundFiles } from "./evidence-claims.js";
+import { isRecord, extractFilePathTokens, deriveConstraintId, deriveCriterionId, isCriterionId, normalizeText, } from "./token-utils.js";
+import { derivationRounds, } from "./committed-round.js";
+import { acceptanceItemsDiffer, sameContract, } from "./round-contract.js";
+import { deriveContractRequirement } from "./contract-requirement.js";
+import { deriveRoundFacts } from "./round-facts.js";
+import { machineVerifiedCriterionIds, resolveRoundFiles, } from "./evidence-claims.js";
 import { claimedMetCriteria, claimedRemainingCriteria, effectiveSuccess } from "./self-eval.js";
+import { declaresBlocked } from "./round-outcome.js";
 import { deriveGate, preflightStructuredGate } from "./cognitive-governance.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // v2.12: Check-name constants — single source of truth so the enforcement
@@ -44,11 +46,6 @@ import { deriveGate, preflightStructuredGate } from "./cognitive-governance.js";
 // ═══════════════════════════════════════════════════════════════════════════
 export const CHECK_SUCCESS_WITH_REMAINING_CRITERIA = "success_with_remaining_criteria";
 export const CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE = "success_without_verified_evidence";
-// v3.7: single id for the outcome-vs-success axis — error when a declared
-// success contradicts success=false, warn when success=true but the outcome
-// declares a non-success (the former success_claim_conflict direction).
-export const CHECK_OUTCOME_SUCCESS_CONTRADICTION = "outcome_success_contradiction";
-export const CHECK_BLOCKED_WITHOUT_BLOCKER = "blocked_without_blocker";
 export const CHECK_RETROACTIVE_CLAIM_BAD_ROUND = "retroactive_claim_bad_round";
 export const CHECK_RETROACTIVE_CLAIM_UNVERIFIED = "retroactive_claim_unverified";
 export const CHECK_DUPLICATE_CONSTRAINT_DISCOVERY = "duplicate_constraint_discovery";
@@ -56,7 +53,6 @@ export const CHECK_RECURRING_VIOLATION = "recurring_violation";
 export const CHECK_RETRACT_FRESH_CONSTRAINT = "retract_fresh_constraint";
 export const CHECK_EVIDENCE_INTEGRITY = "evidence_integrity";
 export const CHECK_REQUIRED_COMMAND_FAILED = "required_command_failed";
-export const CHECK_COMMAND_EVIDENCE_MISMATCH = "command_evidence_mismatch";
 /** v3.3: Verification domain integrity — a command entrypoint (run-tests.sh,
  *  package.json, …) changed in the same round the command ran. The runtime
  *  executed a script the agent just rewrote, so the observation has no
@@ -66,7 +62,6 @@ export const CHECK_VERIFICATION_ENTRYPOINT_MODIFIED = "verification_entrypoint_m
 /** v3.3: Test files changed in the same round a verification command passed.
  *  Warn-only — the command result stays usable. */
 export const CHECK_TEST_FILES_MODIFIED = "test_files_modified";
-export const CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED = "backtrack_workspace_not_restored";
 export const CHECK_CRITERIA_CLAIMS_UNVERIFIED = "criteria_claims_unverified";
 // v3.3 — Round Contract checks. v3.4: split by target. The submission's own
 // round_contract is a PROPOSAL for the NEXT round and is checked only
@@ -92,11 +87,19 @@ export const CHECK_CONTRACT_ITEMS_UNVERIFIED = "contract_items_unverified";
  *  contract's declared scope. Warn; v3.8: not waivable by explanation — the
  *  enforcement gate rejects, and repeated drift terminates. */
 export const CHECK_ROUND_SCOPE_DRIFT = "round_scope_drift";
-/** v3.5: The ACTIVE contract is still open (not completed, not blocked)
- *  while a different contract was proposed — the proposal is ignored until
- *  the active one closes. Warn: the walker still ignores it; this only
- *  surfaces the otherwise-silent state. */
+/** v3.5/v4.0.6: The ACTIVE contract is still open (not completed, not
+ *  blocked) while a different contract was proposed WITHOUT `supersedes`.
+ *  Error: a different slice is never silently saved and ignored. To replace
+ *  the active slice, add `round_contract.supersedes` naming it. */
 export const CHECK_CONTRACT_PREMATURE = "contract_premature";
+/** v4.0.6: A continuing round with contract capability and a successor
+ *  available would leave the next round without an active contract. The final
+ *  configured round has no successor consumer and is exempt. */
+export const CHECK_CONTRACT_REQUIRED = "contract_required";
+/** v4.0.6: A successor proposal repeats the closed contract's ACCEPTANCE ITEMS
+ *  verbatim (only work_item/scope changed). Error: a successor must bring
+ *  genuinely new acceptance conditions, or it would re-verify the old slice. */
+export const CHECK_CONTRACT_SUCCESSOR_UNCHANGED = "contract_successor_unchanged";
 /** v3.7.1: A cited gate (evaluation.gate_ids) is not approved. Opt-in:
  *  checked ONLY when policy.gate.enabled — citations are meaningless when
  *  the gate layer is off. Error → enforcement rejects the round. */
@@ -104,8 +107,6 @@ export const CHECK_USER_GATE_UNRESOLVED = "user_gate_unresolved";
 export const CHECK_DOMAIN = {
     // ── evaluation_consistency ────────────────────────────────────────────────
     [CHECK_SUCCESS_WITH_REMAINING_CRITERIA]: "evaluation_consistency",
-    [CHECK_OUTCOME_SUCCESS_CONTRADICTION]: "evaluation_consistency",
-    [CHECK_BLOCKED_WITHOUT_BLOCKER]: "evaluation_consistency",
     [CHECK_RETROACTIVE_CLAIM_BAD_ROUND]: "evaluation_consistency",
     [CHECK_RETROACTIVE_CLAIM_UNVERIFIED]: "evaluation_consistency",
     [CHECK_DUPLICATE_CONSTRAINT_DISCOVERY]: "evaluation_consistency",
@@ -116,17 +117,17 @@ export const CHECK_DOMAIN = {
     [CHECK_CRITERIA_CLAIMS_UNVERIFIED]: "evidence_integrity",
     [CHECK_EVIDENCE_INTEGRITY]: "evidence_integrity",
     [CHECK_REQUIRED_COMMAND_FAILED]: "evidence_integrity",
-    [CHECK_COMMAND_EVIDENCE_MISMATCH]: "evidence_integrity",
     [CHECK_VERIFICATION_ENTRYPOINT_MODIFIED]: "evidence_integrity",
     [CHECK_TEST_FILES_MODIFIED]: "evidence_integrity",
     // ── plan_contract ─────────────────────────────────────────────────────────
     [CHECK_CONTRACT_ITEMS_UNVERIFIED]: "plan_contract",
     [CHECK_ROUND_SCOPE_DRIFT]: "plan_contract",
     [CHECK_CONTRACT_PREMATURE]: "plan_contract",
+    [CHECK_CONTRACT_REQUIRED]: "plan_contract",
+    [CHECK_CONTRACT_SUCCESSOR_UNCHANGED]: "plan_contract",
     // v3.7.1: cited-gate authorization conformance (opt-in blocking layer).
     [CHECK_USER_GATE_UNRESOLVED]: "plan_contract",
     // ── progress_recovery ─────────────────────────────────────────────────────
-    [CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED]: "progress_recovery",
 };
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
@@ -206,21 +207,8 @@ function passedAfterCommand(deltas) {
  *  missing — the fix for the "weakest when it matters most" gap. */
 export function deriveEvidenceStatus(selfEval, evidenceDeltas) {
     const git = gitDeltaState(evidenceDeltas);
-    const gitObserved = git.state === "observed";
     const command = passedAfterCommand(evidenceDeltas);
     const commandVerified = command !== null;
-    // testsMachineBacked: agent-reported tests_reported agree with a passed
-    // command's parsed stdout (the same comparison checkCommandEvidenceIntegrity
-    // performs — parseTestOutput lives in this module).
-    let testsMachineBacked = false;
-    const reported = selfEval.execution_report?.tests_reported;
-    if (command && command.kind === "command" && reported) {
-        const parsed = parseTestOutput(command.data.stdoutExcerpt ?? "");
-        testsMachineBacked = parsed !== null &&
-            parsed.passed === reported.passed &&
-            parsed.failed === reported.failed &&
-            parsed.skipped === reported.skipped;
-    }
     // v3.3: git observation alone is no longer "verified" — the machine seeing
     // file changes is not the machine verifying success. Only a passed
     // after-phase command (observed by the runtime itself) upgrades a round.
@@ -234,15 +222,15 @@ export function deriveEvidenceStatus(selfEval, evidenceDeltas) {
             : "unavailable";
     return {
         providerStatus,
-        gitObserved,
         gitChangeState: git.state,
         commandVerified,
-        testsMachineBacked,
     };
 }
-/** Per-round machine progress over decoded committed history. */
-export function machineProgressSeries(vaultEntries, currentRound, lookback) {
-    return machineGitMotionSeries(derivationRounds(vaultEntries, currentRound), currentRound, lookback);
+/** Whether a changed path looks like a test file. */
+function isTestFile(path) {
+    return /\.(test|spec)\.[a-z0-9]+$/i.test(path) ||
+        /(^|[\/])tests?[\/]/i.test(path) ||
+        /_test\.[a-z0-9]+$/i.test(path);
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // Individual checks — each returns a VerificationFlag or null
@@ -255,9 +243,9 @@ function checkSuccessWithRemainingCriteria(selfEval) {
         return null;
     return makeVerificationFlag({
         severity: "error",
-        field: "success",
+        field: "outcome",
         check: CHECK_SUCCESS_WITH_REMAINING_CRITERIA,
-        detail: `Agent claims success but ${remaining.length} criteria remain unmet: ` +
+        detail: `outcome=success but ${remaining.length} criteria remain unmet: ` +
             remaining.slice(0, 3).join("; "),
     });
 }
@@ -266,55 +254,27 @@ function checkSuccessWithRemainingCriteria(selfEval) {
  *  command snapshot backs them. Warn — completion still counts, but the
  *  next prompt tells the agent its claims are unverified. This is the
  *  mild form of the 3.x criterion-specific completion rule. */
-function checkUnverifiedCriteriaClaims(selfEval, claimView) {
+function checkUnverifiedCriteriaClaims(selfEval, machineVerifiedIds) {
     const met = claimedMetCriteria(selfEval.execution_report);
     if (met.length === 0)
         return null;
-    if (claimView.verifiedCount > 0 || claimView.hasMachineEvidence)
+    // v4.0.3: EVERY met claim is checked. A verified claim elsewhere in the
+    // same round does not excuse an unbacked one.
+    const unverified = met.filter((target) => {
+        const id = isCriterionId(target) ? target : deriveCriterionId(target);
+        return !machineVerifiedIds.has(id);
+    });
+    if (unverified.length === 0)
         return null;
     return makeVerificationFlag({
         severity: "warn",
         field: "execution_report",
         check: CHECK_CRITERIA_CLAIMS_UNVERIFIED,
-        detail: `${met.length} criteria reported met but none machine-verified ` +
-            "(no passing test evidence or command snapshot)",
+        detail: `${unverified.length} of ${met.length} criteria reported met are not ` +
+            "machine-verified: " + unverified.slice(0, 3).join("; ") +
+            (unverified.length > 3 ? " …" : ""),
     });
 }
-/** Declared outcome vs the core success flag — one check id for the whole
- *  axis (v3.7: the former success_claim_conflict warn direction merged here).
- *  A declared success with success=false is a self-contradiction (error);
- *  success=true with a non-success outcome is an inconsistent claim (warn).
- *  Also: outcome==="blocked" without a blocker description gets a warn so the
- *  next prompt asks for it. */
-function checkOutcomeConsistency(selfEval) {
-    const outcome = selfEval.outcome;
-    if (outcome === "success" && selfEval.success === false) {
-        return makeVerificationFlag({
-            severity: "error",
-            field: "outcome",
-            check: CHECK_OUTCOME_SUCCESS_CONTRADICTION,
-            detail: "outcome=success but success=false — self-contradictory",
-        });
-    }
-    if (outcome !== undefined && outcome !== "success" && selfEval.success === true) {
-        return makeVerificationFlag({
-            severity: "warn",
-            field: "success",
-            check: CHECK_OUTCOME_SUCCESS_CONTRADICTION,
-            detail: `outcome=${outcome} but success=true — the declared outcome wins`,
-        });
-    }
-    if (outcome === "blocked" &&
-        (typeof selfEval.blocker !== "string" || selfEval.blocker.trim().length === 0)) {
-        return makeVerificationFlag({
-            severity: "warn",
-            field: "blocker",
-            check: CHECK_BLOCKED_WITHOUT_BLOCKER,
-            detail: "outcome=blocked but no blocker description was provided",
-        });
-    }
-    return null;
-}
 /** v2.12: Retroactive claims reference PRIOR rounds. Each claim's file
  *  paths are checked against the referenced round's committed git evidence
  *  (P0 provenance layer). Unverifiable claims warn — they never upgrade
@@ -366,11 +326,10 @@ function checkRetroactiveClaims(selfEval, vaultEntries, currentRound) {
 }
 /** v2.12/v3.6/v3.7/v3.9.1: success without machine backing — the single
  *  "success evidence" semantic. Two arms, evaluated in order:
- *  1. Empty/missing-report arm: success=true with NO execution_report at all,
- *     or with files_changed empty AND tests_reported null, is a WARN. It is a
- *     reporting gap, not an acceptance gate: 3.9.1 does not reject a round
- *     because an optional report field was not filled. The warn still keeps
- *     success out of the success trajectory.
+ *  1. Missing-report arm: outcome=success with NO execution_report at all is
+ *     a WARN. It is a reporting gap, not an acceptance gate: the runtime does
+ *     not reject a round because an optional report field was not filled. An
+ *     empty files_changed is a legitimate no-change report, not a gap.
  *  2. Claims arm (v3.6): success=true but the runtime observed no machine
  *     evidence for it. The trigger is the runtime-derived providerStatus
  *     (verified / unavailable / absent) — "verified" requires an UNTAMPERED
@@ -394,17 +353,14 @@ function checkSuccessWithoutVerifiedEvidence(selfEval, status) {
     // remains the verification fact, and the warn still keeps success out of
     // the success trajectory (shouldPushSuccess keys on this check).
     const ev = selfEval.execution_report;
-    if (!ev || ((ev.files_changed ?? []).length === 0 && ev.tests_reported === null)) {
+    if (!ev) {
         return makeVerificationFlag({
             severity: "warn",
-            field: "success",
+            field: "outcome",
             check: CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE,
-            detail: ev
-                ? "Agent claims success but execution_report shows no files changed " +
-                    "and no tests were run. This is a reporting gap, not machine evidence."
-                : "Agent claims success but provided no execution_report. The report is " +
-                    "expected but missing; this is a reporting gap, not by itself a " +
-                    "rejection. No machine evidence backs the claim.",
+            detail: "outcome=success but no execution_report was provided. The report " +
+                "is expected but missing; this is a reporting gap, not by itself a " +
+                "rejection. No machine evidence backs the claim.",
         });
     }
     // Claims arm (v3.6).
@@ -427,12 +383,12 @@ function checkSuccessWithoutVerifiedEvidence(selfEval, status) {
     // this warn). The bounded verification-debt row is what eventually acts on
     // a persistent pattern. `no_change_reason` stays info, and only works when
     // machine verification was structurally impossible (no enabled command).
-    // A success claim with NO execution_report at all is the other arm and
-    // remains an unconditional error.
+    // A success claim with NO execution_report at all is the other arm and is
+    // also a warn: report coverage never decides acceptance.
     const severity = noChange ? "info" : "warn";
     return makeVerificationFlag({
         severity,
-        field: "success",
+        field: "outcome",
         check: CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE,
         detail: noChange
             ? "success with zero verified claims (no_change_reason declared)"
@@ -446,18 +402,18 @@ function checkDuplicateConstraintDiscovery(selfEval, prevSelfEval, olderViolatio
     // Collect all previously-known constraints
     const known = new Set();
     for (const v of olderViolations)
-        known.add(v.toLowerCase().trim());
+        known.add(normalizeText(v));
     if (prevSelfEval) {
         for (const d of prevSelfEval.discovered_constraints ?? []) {
-            known.add(d.toLowerCase().trim());
+            known.add(normalizeText(d));
         }
         // Also treat previous violations as implicitly discovered
         for (const v of prevSelfEval.constraint_violations) {
-            known.add(v.toLowerCase().trim());
+            known.add(normalizeText(v));
         }
     }
     for (const d of discovered) {
-        if (known.has(d.toLowerCase().trim())) {
+        if (known.has(normalizeText(d))) {
             return makeVerificationFlag({
                 severity: "warn",
                 field: "discovered_constraints",
@@ -468,29 +424,27 @@ function checkDuplicateConstraintDiscovery(selfEval, prevSelfEval, olderViolatio
     }
     return null;
 }
-function checkRecurringViolation(selfEval, prevSelfEval, vaultEntries, currentRound) {
+function checkRecurringViolation(selfEval, prevSelfEval, committedRounds, currentRound) {
     const currViols = selfEval.constraint_violations;
     if (!currViols || currViols.length === 0)
         return null;
     // Build the violation history: [round N-2, round N-1, round N]
     const violationsByRound = [];
-    // Round N-2 violations come from the vault entry for round N-1
-    // (persistLoopLineage stores the PREVIOUS round's violations on each entry)
+    // Round N-2 violations come from the committed round's own evaluation.
     if (currentRound >= 3) {
-        const entryNMinus1 = vaultEntries.find((e) => entryRound(e) === currentRound - 1);
-        if (entryNMinus1) {
-            const viols = entryViolations(entryNMinus1);
-            if (viols.length)
-                violationsByRound.push(viols.map((v) => v.toLowerCase().trim()));
+        const nMinus2 = committedRounds.find((view) => view.round === currentRound - 2);
+        const viols = nMinus2?.constraintViolations ?? [];
+        if (viols.length) {
+            violationsByRound.push(viols.map((v) => normalizeText(v)));
         }
     }
     // Round N-1 violations from prevSelfEval
     if (prevSelfEval) {
         const prevViols = prevSelfEval.constraint_violations;
-        violationsByRound.push(prevViols.map((v) => v.toLowerCase().trim()));
+        violationsByRound.push(prevViols.map((v) => normalizeText(v)));
     }
     // Round N violations from current selfEval
-    violationsByRound.push(currViols.map((v) => v.toLowerCase().trim()));
+    violationsByRound.push(currViols.map((v) => normalizeText(v)));
     // Need at least 3 rounds of data
     if (violationsByRound.length < 3)
         return null;
@@ -515,12 +469,11 @@ function checkRetractFreshConstraint(selfEval, prevSelfEval, currentRound) {
         return null;
     if (!prevSelfEval)
         return null;
-    const lastRoundDiscoveries = new Set();
-    for (const d of prevSelfEval.discovered_constraints ?? []) {
-        lastRoundDiscoveries.add(d.toLowerCase().trim());
-    }
+    const discoveries = prevSelfEval.discovered_constraints ?? [];
+    const lastRoundDiscoveries = new Set(discoveries.map((discovery) => normalizeText(discovery)));
+    const discoveryIds = new Set(discoveries.map((discovery) => deriveConstraintId(discovery)));
     for (const r of retracted) {
-        if (lastRoundDiscoveries.has(r.toLowerCase().trim())) {
+        if (lastRoundDiscoveries.has(normalizeText(r)) || discoveryIds.has(r)) {
             return makeVerificationFlag({
                 severity: "warn",
                 field: "retracted_constraints",
@@ -534,10 +487,12 @@ function checkRetractFreshConstraint(selfEval, prevSelfEval, currentRound) {
 }
 /** v1.18: Cross-validate agent-reported files_changed against git evidence
  *  from the configured evidence providers (MachineObservation array). */
-function checkEvidenceIntegrity(selfEval, evidenceDeltas) {
-    if (!selfEval.execution_report)
-        return null;
-    const reconciliation = deriveFilesReconciliation(selfEval.execution_report, evidenceDeltas);
+function checkEvidenceIntegrity(selfEval, evidenceDeltas,
+/** v3.9.4: whether the raw submission named
+ *  `execution_report.files_changed`. The receipt uses the SAME manifest, so
+ *  the two projections can never disagree about an omitted report. */
+filesReported) {
+    const reconciliation = deriveFilesReconciliation(selfEval.execution_report ?? null, evidenceDeltas, { attempted: filesReported });
     if (reconciliation.status !== "mismatch")
         return null;
     const parts = [];
@@ -576,124 +531,7 @@ function checkRequiredCommandEvidence(selfEval, evidenceDeltas) {
             field: "execution_report",
             check: CHECK_REQUIRED_COMMAND_FAILED,
             detail: `Agent claims success but required command "${name}" ${String(status)}${exitCode}`,
-        });
-    }
-    return null;
-}
-// ── Test output parsing ────────────────────────────────────────────────────
-/** Whether a changed path looks like a test file. */
-function isTestFile(path) {
-    return /\.(test|spec)\.[a-z0-9]+$/i.test(path) ||
-        /(^|[\\/])tests?[\\/]/i.test(path) ||
-        /_test\.[a-z0-9]+$/i.test(path);
-}
-/** Best-effort parse of test counts from common test-runner output formats.
- *
- *  Scans the last 2000 characters of stdout (where summary lines typically
- *  appear) and tries patterns in descending specificity order. Returns null
- *  when the output format is unrecognized, stdout is empty, or a confident
- *  parse cannot be made.
- *
- *  Recognized formats: Jest verbose/compact, Mocha, pytest/unittest, Go test,
- *  and PHPUnit OK summaries. */
-export function parseTestOutput(stdout) {
-    if (!stdout)
-        return null;
-    const tail = stdout.length > 2000 ? stdout.slice(-2000) : stdout;
-    let match;
-    // 1. Jest verbose: "Tests: 1 failed, 8 passed, 9 total"
-    match = tail.match(/Tests:\s*(\d+)\s+failed,\s*(\d+)\s+passed,\s*(\d+)\s+total/i);
-    if (match) {
-        return { failed: Number(match[1]), passed: Number(match[2]), total: Number(match[3]), skipped: 0 };
-    }
-    // 2. Jest compact: "Tests: 8 passed, 9 total"
-    match = tail.match(/Tests:\s*(\d+)\s+passed,\s*(\d+)\s+total/i);
-    if (match) {
-        const passed = Number(match[1]);
-        const total = Number(match[2]);
-        return { passed, failed: total - passed, total, skipped: 0 };
-    }
-    // 3. Mocha: "8 passing" + optional "2 failing"
-    const mochaPass = tail.match(/(\d+)\s+passing/i);
-    if (mochaPass) {
-        const mochaFail = tail.match(/(\d+)\s+failing/i);
-        const passed = Number(mochaPass[1]);
-        const failed = mochaFail ? Number(mochaFail[1]) : 0;
-        return { passed, failed, total: passed + failed, skipped: 0 };
-    }
-    // 4. Go test: count "--- PASS:" and "--- FAIL:" lines
-    const goPassCount = (tail.match(/---\s+PASS:/g) || []).length;
-    const goFailCount = (tail.match(/---\s+FAIL:/g) || []).length;
-    if (goPassCount > 0 || goFailCount > 0) {
-        return { passed: goPassCount, failed: goFailCount, total: goPassCount + goFailCount, skipped: 0 };
-    }
-    // 5. pytest / unittest: "8 passed, 1 failed" or "8 passed"
-    match = tail.match(/(\d+)\s+passed[,;\s]+(\d+)\s+failed/i);
-    if (match) {
-        return { passed: Number(match[1]), failed: Number(match[2]), total: Number(match[1]) + Number(match[2]), skipped: 0 };
-    }
-    // pytest compact: "8 passed" (with a reasonable context hint)
-    match = tail.match(/(?:=\s+test session|\b(?:passed|failed)\b)/i);
-    if (match) {
-        const pCount = tail.match(/(\d+)\s+passed/i);
-        const fCount = tail.match(/(\d+)\s+failed/i);
-        if (pCount || fCount) {
-            const passed = pCount ? Number(pCount[1]) : 0;
-            const failed = fCount ? Number(fCount[1]) : 0;
-            return { passed, failed, total: passed + failed, skipped: 0 };
-        }
-    }
-    // 6. PHPUnit: "OK (8 tests, 16 assertions)"
-    match = tail.match(/OK\s*\((\d+)\s+tests?/i);
-    if (match) {
-        const total = Number(match[1]);
-        return { passed: total, failed: 0, total, skipped: 0 };
-    }
-    return null;
-}
-/** Cross-validate agent-reported tests_reported against command evidence output.
- *
- *  For each command provider whose status is "passed" and output is not
- *  truncated, attempts to parse test counts from stdout. Mismatched counts
- *  produce a warn-level flag; failures hidden by the agent (reported 0 failed
- *  when the command shows >0) produce an error-level flag.
- *
- *  Non-command evidence providers are skipped (no structural cross-check is
- *  defined for them yet). */
-function checkCommandEvidenceIntegrity(selfEval, evidenceDeltas) {
-    const reported = selfEval.execution_report?.tests_reported;
-    if (!reported)
-        return null;
-    for (const snapshot of afterObservations(evidenceDeltas)) {
-        if (snapshot.kind !== "command")
-            continue;
-        if (snapshot.status !== "passed")
-            continue;
-        if (snapshot.data.truncated === true)
-            continue;
-        const stdout = typeof snapshot.data.stdoutExcerpt === "string" ? snapshot.data.stdoutExcerpt : "";
-        const parsed = parseTestOutput(stdout);
-        if (!parsed)
-            continue;
-        const mismatches = [];
-        if (parsed.passed !== reported.passed) {
-            mismatches.push(`passed: reported ${reported.passed}, command shows ${parsed.passed}`);
-        }
-        if (parsed.failed !== reported.failed) {
-            mismatches.push(`failed: reported ${reported.failed}, command shows ${parsed.failed}`);
-        }
-        if (mismatches.length === 0) {
-            // Counts match exactly — evidence supports the agent's claim.
-            continue;
-        }
-        const name = snapshot.data.commandId;
-        // Agent hides failures → error. Other mismatch → warn.
-        const severity = parsed.failed > 0 && reported.failed === 0 ? "error" : "warn";
-        return makeVerificationFlag({
-            severity,
-            field: "tests_reported",
-            check: CHECK_COMMAND_EVIDENCE_MISMATCH,
-            detail: `Agent tests_reported don't match "${name}" output: ${mismatches.join("; ")}`,
+            ref: name,
         });
     }
     return null;
@@ -741,10 +579,9 @@ function checkVerificationDomainIntegrity(evidenceDeltas, drift) {
                 (changed.length > 0
                     ? "At round start: " + changed.map((entry) => entry.roundStart === "absent"
                         ? `"${entry.file}" did not exist`
-                        : `"${entry.file}" was present`).join("; ") + ". "
-                    : "") +
-                "Keep the verification command stable or resubmit the same round with the " +
-                "entrypoint unchanged.",
+                        : `"${entry.file}" was present`).join("; ") + "."
+                    : ""),
+            ref: snapshot.data.commandId,
         });
     }
     // Only when NO entrypoint was tampered does the test-file warn stand in.
@@ -761,136 +598,11 @@ function checkVerificationDomainIntegrity(evidenceDeltas, drift) {
             check: CHECK_TEST_FILES_MODIFIED,
             detail: `Test files changed in the same round command "${snapshot.data.commandId}" passed — ` +
                 "confirm the tests still verify the task claims.",
+            ref: snapshot.data.commandId,
         });
     }
     return null;
 }
-/** v2.13: After a backtrack, check that the agent restored the workspace
- *  before working. Two arms:
- *
- *  1. Machine arm (M3, error): a skipped file whose CURRENT git fingerprint
- *     still equals the fingerprint recorded at its failed round was never
- *     touched since the rollback — the workspace was provably not restored.
- *     Restored or re-modified files change fingerprint and can never be
- *     misjudged by this arm.
- *
- *  2. Claims arm (warn only): the agent's files_changed overlaps the skipped
- *     list. A self-report alone cannot distinguish a restored-then-redone
- *     file from a never-restored one — a legitimate multi-file redo would
- *     otherwise be falsely terminated — so overlap is guidance, not a
- *     verdict. (The old error tier for >= 3 overlapping files was removed
- *     for exactly this reason: it fired on honest redos.) */
-function checkBacktrackWorkspaceRestore(selfEval, backtrackSkippedFiles, backtrackSkippedFingerprints = {}, evidenceDeltas = []) {
-    // Machine arm — untouched-since-rollback proof, independent of claims.
-    const failedEntries = Object.entries(backtrackSkippedFingerprints);
-    if (failedEntries.length > 0) {
-        const afterGit = evidenceDeltas.find((delta) => delta.kind === "git")?.after;
-        const currentFingerprints = afterGit && afterGit.kind === "git" &&
-            isRecord(afterGit.data.fingerprints)
-            ? afterGit.data.fingerprints
-            : null;
-        if (currentFingerprints) {
-            const untouched = failedEntries
-                .filter(([file, failedFp]) => currentFingerprints[file] === failedFp)
-                .map(([file]) => file)
-                .sort();
-            if (untouched.length > 0) {
-                return makeVerificationFlag({
-                    severity: "error",
-                    field: "workspace",
-                    check: CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED,
-                    detail: `File(s) from the failed rounds are byte-identical to their ` +
-                        `state at the rollback: ${untouched.slice(0, 5).join(", ")}. The ` +
-                        `workspace was never restored — restore it to the restore point ` +
-                        `(git checkout/reset) before redoing the work.`,
-                });
-            }
-        }
-    }
-    const ev = selfEval.execution_report;
-    if (!ev || (ev.files_changed ?? []).length === 0)
-        return null;
-    // Claims arm — overlap as guidance only.
-    const overlap = (ev.files_changed ?? []).filter((f) => backtrackSkippedFiles.some((sf) => sf === f || f.endsWith(sf) || sf.endsWith(f)));
-    if (overlap.length === 0)
-        return null;
-    return makeVerificationFlag({
-        severity: "warn",
-        field: "files_changed",
-        check: CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED,
-        detail: `Agent modified files that overlap with skipped rounds: ` +
-            `${overlap.join(", ")}. Verify the workspace was restored.`,
-    });
-}
-/** v2.12: After a backtrack, the workspace must return to the restore point:
- *  the same git HEAD that round committed, carrying no dirty file the restore
- *  point did not already have. Compares HEAD's first 12 characters (short
- *  hash), matching how git itself disambiguates.
- *
- *  The dirty-set comparison is against the restore point's OWN baseline, not
- *  an empty tree: unrelated work in progress in the same workspace is no
- *  evidence of a failed restore, while a file the failed rounds left behind
- *  is — it is dirty now and was not dirty then. An absent baseline means the
- *  restore point's dirt was never observed, so only HEAD can be judged.
- *
- *  A redo prepared before the agent restores the workspace has a stale before
- *  snapshot, so its first submission is a recovery checkpoint; once the
- *  restore is proven, later work may move HEAD freely. */
-function checkBacktrackGitHeadRestore(evidenceDeltas, backtrackTargetGitHead, beforeEvidence = [],
-/** The restore point's own dirty files — undefined when never observed. */
-backtrackTargetDirty) {
-    if (!backtrackTargetGitHead)
-        return null;
-    const short = (hash) => hash.slice(0, 12);
-    const readGit = (observations) => {
-        const snapshot = observations.find((item) => item.providerId === "git" && item.status === "observed" && isRecord(item.data) &&
-            typeof item.data.head === "string");
-        if (!snapshot || !isRecord(snapshot.data))
-            return null;
-        const data = snapshot.data;
-        // v3.9.1: the workspace's dirty set is one explicit list. "Tracked /
-        // staged / untracked" were dirty-since-HEAD categories, not the complete
-        // boundary, and are gone.
-        const dirty = Array.isArray(data.dirty)
-            ? data.dirty.filter((file) => typeof file === "string")
-            : [];
-        return { head: data.head, dirty };
-    };
-    const foreignDirty = (dirty) => Array.isArray(backtrackTargetDirty)
-        ? dirty.filter((file) => !backtrackTargetDirty.includes(file))
-        : [];
-    const restored = (git) => git !== null && git.head.length > 0 &&
-        short(git.head) === short(backtrackTargetGitHead) &&
-        foreignDirty(git.dirty).length === 0;
-    // When restoration happened before the redo was prepared, the before
-    // snapshot already proves it. The redo may then commit new work.
-    if (restored(readGit(beforeEvidence)))
-        return null;
-    const afterGit = readGit(afterObservations(evidenceDeltas));
-    if (!afterGit)
-        return null; // git unavailable → cannot verify → skip (fail-open)
-    if (restored(afterGit))
-        return null;
-    // Normal lifecycle: prepare captured the pre-restore workspace. The first
-    // submission must prove restoration before a later submission can commit.
-    const headBack = afterGit.head.length > 0 &&
-        short(afterGit.head) === short(backtrackTargetGitHead);
-    const left = foreignDirty(afterGit.dirty);
-    return makeVerificationFlag({
-        severity: "error",
-        field: "workspace",
-        check: CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED,
-        detail: headBack
-            ? `Workspace HEAD is back at the backtrack restore commit ` +
-                `(${short(backtrackTargetGitHead)}) but these files were not there at ` +
-                `the restore point and are still changed: ${left.slice(0, 5).join(", ")}` +
-                `${left.length > 5 ? ` (+${left.length - 5} more)` : ""}. Revert them ` +
-                `before redoing the work.`
-            : `Workspace HEAD (${short(afterGit.head)}) does not match the backtrack ` +
-                `restore commit (${short(backtrackTargetGitHead)}). Submit one recovery ` +
-                `evaluation at the restore point before redoing work.`,
-    });
-}
 // ═══════════════════════════════════════════════════════════════════════════
 // v3.8 — Round Contract checks (all silent when no contract is declared)
 //
@@ -930,58 +642,132 @@ function checkRoundScopeDrift(activeContract, evidenceDeltas) {
     if (outOfScope === null || outOfScope.length === 0)
         return null;
     return makeVerificationFlag({
-        severity: "warn",
+        // v3.9.9: report only. `scope` is the Agent's declared intent, not a
+        // permission, so drift is an INFO fact — it never rejects, terminates,
+        // backtracks, stalls, or counts toward a rejection streak.
+        severity: "info",
         field: "round_contract",
         check: CHECK_ROUND_SCOPE_DRIFT,
-        detail: `Files changed outside the active contract's declared scope` +
+        detail: `Files changed outside the active contract's declared scope (report ` +
+            `only; this does not block the round)` +
             (outOfScope.length > 5
                 ? ` (${outOfScope.length} total, showing 5): ${outOfScope.slice(0, 5).join(", ")}`
-                : `: ${outOfScope.join(", ")}`) +
-            `. Revert them, or close the active contract and declare the extended scope in a new proposal.`,
+                : `: ${outOfScope.join(", ")}`),
     });
 }
 /** v3.8: Claimed-but-unverified contract items. The round COMMITS — the debt
  *  is surfaced (prompt, state file, handoff) and the enforcement gate's
  *  verification-debt row handles a persistent pattern. */
-function checkContractItemsUnverified(statuses) {
+function checkContractItemsUnverified(statuses, currentReport) {
     if (statuses.insufficientCount === 0)
         return null;
+    // v3.9.9: an honest abandonment retires the old debt finding. A superseded
+    // contract whose round does NOT claim any of its items `met` is the Agent
+    // saying "this slice was wrong" — not a completion claim to police. If the
+    // round still claims an old item `met`, the debt finding stands: a redirect
+    // cannot wash away an unverified completion claim.
+    if (statuses.closure === "superseded") {
+        const itemIds = new Set(statuses.items.map((item) => item.itemId));
+        const claimsMet = (currentReport?.claims ?? []).some((claim) => claim.id.startsWith("rci-") &&
+            claim.outcome === "met" && itemIds.has(claim.id));
+        if (!claimsMet)
+            return null;
+    }
+    // v3.9.4: EVERY insufficient item is named. The previous 3-item cap hid the
+    // rest of the debt from the one repair surface the agent reads.
     const unverified = statuses.items
         .filter((item) => item.status === "insufficient")
-        .slice(0, 3)
         .map((item) => item.itemId);
     return makeVerificationFlag({
         severity: "warn",
         field: "round_contract",
         check: CHECK_CONTRACT_ITEMS_UNVERIFIED,
         detail: `${statuses.insufficientCount} contract item(s) claimed met but not machine-verified: ` +
-            `${unverified.join(", ")}. Run the bound command(s) or report the item as remaining.`,
+            `${unverified.join(", ")}.`,
     });
 }
-/** A different contract proposed while the ACTIVE contract is still open. The
- *  walker ignores the premature proposal — this warn only makes the ignored
- *  state visible. Silent when the active contract is closed (all items
- *  verified, or outcome=blocked), when no proposal is submitted, or when the
- *  proposal is a restate (content equality, never id equality). */
+/** v4.0.6: A different contract proposed while the ACTIVE contract is still
+ *  open and the proposal does not explicitly `supersedes` it. This is an
+ *  ERROR: a different slice is never silently saved and ignored. Silent when
+ *  the active contract is closed (all items verified, or outcome=blocked),
+ *  when no proposal is submitted, or when the proposal is a restate (content
+ *  equality, never id equality). A legal redirect makes the closure
+ *  `superseded`, so it never reaches this check. */
 function checkContractPremature(activeContract, statuses, selfEval) {
     if (!activeContract)
         return null;
     if (statuses.closure !== "open")
         return null; // closed
-    if (selfEval.outcome === "blocked")
+    if (declaresBlocked(selfEval))
         return null; // closed
     const proposal = selfEval.round_contract;
     if (!proposal)
         return null;
+    if (proposal.supersedes?.contract_id === activeContract.id)
+        return null; // explicit redirect
     if (sameContract(proposal, activeContract))
         return null; // restate → continue
     return makeVerificationFlag({
-        severity: "warn",
+        severity: "error",
         field: "round_contract",
         check: CHECK_CONTRACT_PREMATURE,
         detail: "The ACTIVE Round Contract is still open (not every item verified, not blocked) " +
-            "while a different contract was proposed — it is ignored until the active " +
-            "contract closes. Restate the active contract unchanged to continue it.",
+            "while a different contract was proposed without supersedes — to replace it, " +
+            "add round_contract.supersedes with the active contract id and different " +
+            "acceptance items; otherwise omit round_contract to continue.",
+    });
+}
+/** v4.0.6: contract coverage. With an after-capable command configured, a
+ *  continuing round must leave the next round with an active contract.
+ *  `blocked` rounds are exempt (they close the contract and stop). The rule is
+ *  the shared `deriveContractRequirement`, so the submission boundary and the
+ *  gate cannot disagree. */
+function checkContractRequired(activeContract, statuses, selfEval, contractCapability, successorRoundAvailable) {
+    const requirement = deriveContractRequirement({
+        shouldContinue: selfEval.should_continue === true,
+        blocked: declaresBlocked(selfEval),
+        proposalPresent: selfEval.round_contract !== undefined,
+        activeContract,
+        closure: statuses.closure,
+        contractCapability,
+        successorRoundAvailable,
+    });
+    if (!requirement.required)
+        return null;
+    return makeVerificationFlag({
+        severity: "error",
+        field: "round_contract",
+        check: CHECK_CONTRACT_REQUIRED,
+        detail: requirement.reason === "no_active_contract"
+            ? "A verification command is configured and this round continues, but no " +
+                "Round Contract is active for the next round and none was proposed. " +
+                "Submit round_contract with a work_item and at least one item bound to a " +
+                "configured after-capable command."
+            : "The active Round Contract closed this round and this round continues, " +
+                "but no successor round_contract was proposed. Submit the next slice's " +
+                "contract (a new work_item with acceptance items).",
+    });
+}
+/** v4.0.6: a successor for a closed contract must bring genuinely new
+ *  acceptance conditions. Re-stating the same items would re-activate the old
+ *  slice and re-verify it. Changing only work_item/scope is not a new slice. */
+function checkContractSuccessorUnchanged(activeContract, statuses, selfEval) {
+    if (!activeContract)
+        return null;
+    if (statuses.closure === "open")
+        return null;
+    const proposal = selfEval.round_contract;
+    if (!proposal)
+        return null;
+    if (acceptanceItemsDiffer(proposal, activeContract))
+        return null;
+    return makeVerificationFlag({
+        severity: "error",
+        field: "round_contract",
+        check: CHECK_CONTRACT_SUCCESSOR_UNCHANGED,
+        detail: "The proposed successor repeats the closed contract's acceptance items " +
+            "verbatim. A successor must bring new acceptance conditions; changing only " +
+            "work_item or scope is not a new slice.",
     });
 }
 // Main entry point
@@ -1058,54 +844,63 @@ function checkUserGateUnresolved(selfEval, gateEntries) {
     });
 }
 export function verifySelfEvaluation(selfEval, currentRound, vaultEntries, prevSelfEval = null, evidenceDeltas = [],
-/** v2.13: Files from skipped backtrack rounds. If the agent's
- *  files_changed overlaps significantly with these, the workspace
- *  was not properly restored before working. */
-backtrackSkippedFiles = [],
-/** M3 (v3.7.x): skipped-file git fingerprints at their failed rounds —
- *  machine proof of "untouched since the rollback" for the restore check. */
-backtrackSkippedFingerprints = {},
-/** v2.12: Git HEAD commit of the backtrack restore point. When set, the
- *  current git snapshot must sit at this commit — otherwise the workspace
- *  was not restored and the round cannot be accepted. */
-backtrackTargetGitHead,
+/** v3.7.1: gate records (task_type gate_opened / gate_decision) live
+ *  outside the round prefix — the caller passes them in explicitly. */
 /** v3.7.1: gate records (task_type gate_opened / gate_decision) live
  *  outside the round prefix — the caller passes them in explicitly. */
 gateEntries = [],
 /** v3.8.3: entrypoint files that no longer match the trusted round-start
  *  baseline. Derived by the caller (it needs the in-flight trust map and
  *  filesystem access); this function stays a pure function of its inputs. */
-entrypointDrift = [], beforeEvidence = [],
-/** v3.9: the restore point's own dirty files (undefined = never observed). */
-backtrackTargetDirty) {
+entrypointDrift = [],
+/** v3.9.4: whether the raw submission attempted
+ *  `execution_report.files_changed` (from the persisted submittedFields
+ *  manifest). Undefined falls back to "an execution report exists". */
+filesReported,
+/** v4.0.3: the ONE `RoundFacts` bundle the coordinator derived before
+ *  verification. When supplied, the gate consumes it instead of deriving
+ *  the active contract / item statuses a second time. The fallback exists
+ *  for direct library callers and unit tests; it calls the same derivation
+ *  function, so there is still exactly one rule. */
+facts, maxRounds = Number.POSITIVE_INFINITY) {
     const flags = [];
-    // Collect violations from all previous vault entries for duplicate-discovery
-    // and other checks that need deeper history.
-    const olderViolations = [];
-    for (const entry of vaultEntries) {
-        for (const v of entryViolations(entry))
-            olderViolations.push(v);
-    }
+    const filesReportedForGate = filesReported ?? (selfEval.execution_report != null);
     // v3.4: The ACTIVE contract this round executed under — derived from the
     // committed :feedback evals of earlier rounds. The submission's own
     // round_contract is a PROPOSAL for the next round and never participates
     // (the eval under verification is not yet committed, so it structurally
     // cannot influence the derivation).
     const committedRounds = derivationRounds(vaultEntries, currentRound);
-    const activeContract = deriveActiveRoundContract(committedRounds);
-    // v3.8: The item-level status of the ACTIVE contract for THIS round — the
-    // same reducer the compile path, audit, and explain consume.
-    const contractStatuses = deriveContractItemStatuses({
-        contract: activeContract,
+    const olderViolations = [];
+    for (const view of committedRounds) {
+        for (const v of view.constraintViolations ?? [])
+            olderViolations.push(v);
+    }
+    // v4.0.3: the coordinator computes this bundle once and passes it in. A
+    // direct caller gets the SAME derivation — never a second rule.
+    const roundFacts = facts ?? deriveRoundFacts({
         rounds: committedRounds,
         currentRound,
-        currentReport: selfEval.execution_report ?? null,
-        currentDeltas: evidenceDeltas,
+        inFlight: {
+            currentReport: selfEval.execution_report ?? null,
+            currentDeltas: evidenceDeltas,
+            currentBlocked: declaresBlocked(selfEval),
+            // v3.9.9/v4.0.6: without this, debt/premature checks cannot see a
+            // superseded closure and would report the old contract as merely open.
+            currentRedirect: selfEval.round_contract?.supersedes ?? null,
+        },
         commands: getPolicy().evidence.commands ?? [],
     });
-    // v2.12: Derived claim provenance — which reported criteria completions
-    // are backed by machine evidence (pure derivation, not persisted).
-    const claimView = deriveClaimView(selfEval, evidenceDeltas);
+    const activeContract = roundFacts.activeContract;
+    const contractStatuses = roundFacts.itemStatuses;
+    // v4.0.3: the ONLY machine-verified criterion ids are contract-bound
+    // criterion facts and verified active-contract items. Agent claims and
+    // self-reported tests never enter this set.
+    const machineVerified = machineVerifiedCriterionIds({
+        criterionFacts: roundFacts.criterionFacts,
+        activeContract,
+        itemStatuses: contractStatuses,
+    });
     // v3.2: Runtime machine-verification status (git observed / command passed /
     // absent). v3.6: feeds the merged R8 check (providerStatus lens) that
     // never self-skips.
@@ -1120,34 +915,30 @@ backtrackTargetDirty) {
         // v2.12/v3.6/v3.7: the single success-evidence semantic — empty/missing-
         // evidence arm (ex-R3) + claims arm (providerStatus lens, tamper-aware)
         () => checkSuccessWithoutVerifiedEvidence(selfEval, evidenceStatus),
-        // v2.12: criteria met but none machine-verified (mild criterion-specific rule)
-        () => checkUnverifiedCriteriaClaims(selfEval, claimView),
-        // Declared outcome vs the required core success flag.
-        () => checkOutcomeConsistency(selfEval),
+        // v2.12/v4.0.3: per-claim machine verification
+        () => checkUnverifiedCriteriaClaims(selfEval, machineVerified),
         // v2.12: retroactive claims against prior rounds
         () => checkRetroactiveClaims(selfEval, vaultEntries, currentRound),
         () => checkDuplicateConstraintDiscovery(selfEval, prevSelfEval, olderViolations),
-        () => checkRecurringViolation(selfEval, prevSelfEval, vaultEntries, currentRound),
+        () => checkRecurringViolation(selfEval, prevSelfEval, committedRounds, currentRound),
         () => checkRetractFreshConstraint(selfEval, prevSelfEval, currentRound),
         // v1.18: Cross-validate agent-reported files_changed against git evidence
-        () => checkEvidenceIntegrity(selfEval, evidenceDeltas),
+        () => checkEvidenceIntegrity(selfEval, evidenceDeltas, filesReportedForGate),
         () => checkRequiredCommandEvidence(selfEval, evidenceDeltas),
-        // v2.0: Cross-validate agent-reported tests_reported against command output
-        () => checkCommandEvidenceIntegrity(selfEval, evidenceDeltas),
         // v3.3: Verification domain integrity — command entrypoint / test files
         // changed in the same round the command ran
         () => checkVerificationDomainIntegrity(evidenceDeltas, entrypointDrift),
-        // v2.13: Post-backtrack workspace restore check
-        () => checkBacktrackWorkspaceRestore(selfEval, backtrackSkippedFiles, backtrackSkippedFingerprints, evidenceDeltas),
-        // v2.12: Post-backtrack git HEAD restore check
-        () => checkBacktrackGitHeadRestore(evidenceDeltas, backtrackTargetGitHead, beforeEvidence, backtrackTargetDirty),
+        // v3.9.7: restore verification happens before the redo prompt, not on
+        // the redo submission.
         // v3.8: Round Contract checks over the derived item model. Declaration
         // quality is enforced structurally (contract_invalid) before the round
         // advances, so the gate only reports execution state: scope drift,
         // claimed-but-unverified items, and an ignored replacement proposal.
         () => checkRoundScopeDrift(activeContract, evidenceDeltas),
-        () => checkContractItemsUnverified(contractStatuses),
+        () => checkContractItemsUnverified(contractStatuses, selfEval.execution_report ?? null),
         () => checkContractPremature(activeContract, contractStatuses, selfEval),
+        () => checkContractRequired(activeContract, contractStatuses, selfEval, deriveConfiguredCapability(getPolicy()).contractVerificationAvailable, currentRound < maxRounds),
+        () => checkContractSuccessorUnchanged(activeContract, contractStatuses, selfEval),
         // v3.7.1: opt-in gate-layer blocking (skipped when disabled)
         () => checkUserGateUnresolved(selfEval, gateEntries),
     ];