loopforge 3.7.0 → 3.8.1

package/dist/verification-gate.js

@@ -18,15 +18,16 @@
  * changes run order or verdict aggregation. Round Contract checks are further
  * framed as declaration / execution / closure stages in their doc comments.
  */
-import { getPolicy, isConfiguredCommand } from "./policy.js";
+import { isPassedAfterObservation } from "./evidence-provider.js";
+import { getPolicy } from "./policy.js";
 import { makeVerificationFlag, makeVerificationResult } from "./protocol.js";
-import { jaccardSimilarity, tokenize, isRecord, entryRound, extractFilePathTokens } from "./token-utils.js";
-import { deriveSubGoalId } from "./loop-compiler.js";
-import { committedRoundsFromEntries, machineGitMotionSeries, entryViolations } from "./committed-round.js";
-import { contractRoundEvaluations, contractDoneWhenSatisfied, contractItemMatches, deriveActiveRoundContract, } from "./round-contract.js";
-import { stableStringify } from "./canonical-state.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 { effectiveSuccess, parseRoundContract } from "./self-eval.js";
+import { claimedMetCriteria, claimedRemainingCriteria, effectiveSuccess } from "./self-eval.js";
+import { deriveGate, preflightStructuredGate } from "./cognitive-governance.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // v2.12: Check-name constants — single source of truth so the enforcement
 // gate and audit can reference checks without string-literal drift.
@@ -63,8 +64,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_INTENT_DRIFT = "intent_drift";
-export const CHECK_SUBGOAL_DRIFT = "subgoal_drift";
 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
@@ -83,35 +82,23 @@ export const CHECK_CRITERIA_CLAIMS_UNVERIFIED = "criteria_claims_unverified";
 // (completion truth: contract_completion_unverified; premature_boundary's
 // claimed-met-unverified arm). The framing is documentation only — no phase
 // field exists on the contract.
-/** Contract proposed with an empty done_when — nothing is promised, so
- *  nothing can be verified at the boundary. Warn: the contract can be fixed
- *  by re-declaring next round. */
-export const CHECK_ROUND_UNDERSPECIFIED = "round_underspecified";
-/** done_when items exist but verification_plan is empty or names commands
- *  that are not configured AND enabled in policy.evidence.commands — the
- *  completion claims could never be machine-checked. Warn. */
-export const CHECK_ROUND_UNVERIFIABLE = "round_unverifiable";
+/** v3.8: Contract items claimed met but not machine-verified this round.
+ *  The round commits; the debt is surfaced and the enforcement gate's
+ *  verification-debt row handles a persistent pattern. */
+export const CHECK_CONTRACT_ITEMS_UNVERIFIED = "contract_items_unverified";
 /** The round's actual git changes include files outside the ACTIVE
- *  contract's declared scope. Warn + drift_clarification exemption
- *  (R7-style). */
+ *  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";
-/** success claimed under the ACTIVE contract whose done_when items are
- *  either claimed met without machine-verified evidence or silently dropped
- *  (not in success_criteria_met NOR success_criteria_remaining). Error. */
-export const CHECK_PREMATURE_BOUNDARY = "premature_boundary";
-/** v3.5: Closing a Round Contract is a success-class claim and must be
- *  machine-backed. The eval's met claims satisfy every done_when of the
- *  ACTIVE contract but its verification_plan commands did not pass this
- *  round. Error; warn under evidence.machine_backed_success "warn"; never
- *  downgraded by no_change_reason (all done_when met contradicts "no
- *  change"). Fail-open: plan names no longer configured+enabled are not
- *  required (cannot observe). */
-export const CHECK_CONTRACT_COMPLETION_UNVERIFIED = "contract_completion_unverified";
 /** 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. */
 export const CHECK_CONTRACT_PREMATURE = "contract_premature";
+/** 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. */
+export const CHECK_USER_GATE_UNRESOLVED = "user_gate_unresolved";
 export const CHECK_DOMAIN = {
     // ── evaluation_consistency ────────────────────────────────────────────────
     [CHECK_SUCCESS_WITH_REMAINING_CRITERIA]: "evaluation_consistency",
@@ -131,14 +118,11 @@ export const CHECK_DOMAIN = {
     [CHECK_VERIFICATION_ENTRYPOINT_MODIFIED]: "evidence_integrity",
     [CHECK_TEST_FILES_MODIFIED]: "evidence_integrity",
     // ── plan_contract ─────────────────────────────────────────────────────────
-    [CHECK_INTENT_DRIFT]: "plan_contract",
-    [CHECK_SUBGOAL_DRIFT]: "plan_contract",
-    [CHECK_ROUND_UNDERSPECIFIED]: "plan_contract",
-    [CHECK_ROUND_UNVERIFIABLE]: "plan_contract",
+    [CHECK_CONTRACT_ITEMS_UNVERIFIED]: "plan_contract",
     [CHECK_ROUND_SCOPE_DRIFT]: "plan_contract",
-    [CHECK_PREMATURE_BOUNDARY]: "plan_contract",
-    [CHECK_CONTRACT_COMPLETION_UNVERIFIED]: "plan_contract",
     [CHECK_CONTRACT_PREMATURE]: "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",
 };
@@ -178,72 +162,46 @@ export function isFileInScope(file, scope) {
 export function collectOutOfScopeFiles(files, scope) {
     return files.filter((file) => !isFileInScope(file, scope));
 }
-/** v3.3: Detect verification-domain tampering for a command snapshot.
- *  entrypointModified — a workspace file the command depends on
- *  (snapshot.data.entrypointFiles) changed this round: the runtime executed
- *  a script the agent just rewrote, so the "machine observation" has no
- *  stable baseline. testFilesModified — the round changed test files
- *  (isTestFile): normal in TDD, so warn-only; the command result stays
- *  usable. Pure snapshot derivation — no fs access (this module is pure). */
-function commandTampered(snapshot, gitSnapshot) {
-    if (!gitSnapshot)
+/** v3.3: Detect verification-domain tampering for a command observation.
+ *  entrypointModified — a workspace file the command depends on changed this
+ *  round: the runtime executed a script the agent just rewrote, so the
+ *  "machine observation" has no stable baseline. testFilesModified — the
+ *  round changed test files (isTestFile): normal in TDD, so warn-only; the
+ *  command result stays usable. Pure derivation — no fs access. */
+function commandTampered(observation, gitObservation) {
+    if (!gitObservation)
         return { entrypointModified: false, testFilesModified: false };
-    const gitFiles = new Set(gitSnapshot.files);
-    const entrypoints = isRecord(snapshot.data) &&
-        Array.isArray(snapshot.data.entrypointFiles)
-        ? snapshot.data.entrypointFiles.filter((f) => typeof f === "string")
+    const gitFiles = new Set(gitObservation.files);
+    const entrypoints = observation.kind === "command"
+        ? observation.data.entrypointFiles ?? []
         : [];
     const entrypointModified = entrypoints.some((file) => gitFiles.has(file));
     const testFilesModified = [...gitFiles].some((file) => isTestFile(file));
     return { entrypointModified, testFilesModified };
 }
-function passedAfterCommand(snapshots) {
-    const git = snapshots.find((snapshot) => snapshot.provider === "git") ?? null;
-    return snapshots.find((snapshot) => isRecord(snapshot.data) &&
-        snapshot.data.kind === "command" &&
-        snapshot.data.phase === "after" &&
-        snapshot.data.status === "passed" &&
-        // v3.3: a command whose entrypoint changed this round is not machine
-        // evidence — exclude it so providerStatus degrades to unavailable.
-        !commandTampered(snapshot, git).entrypointModified) ?? null;
-}
-/** v3.5: Names of commands observed passing in the after-phase this round.
- *  Tampered commands (entrypoint changed this round) are not machine
- *  evidence and are excluded — the same rule passedAfterCommand applies. */
-function passedPlanCommandNames(snapshots) {
-    const git = snapshots.find((snapshot) => snapshot.provider === "git") ?? null;
-    const names = new Set();
-    for (const snapshot of snapshots) {
-        if (!isRecord(snapshot.data))
-            continue;
-        if (snapshot.data.kind !== "command")
-            continue;
-        if (snapshot.data.phase !== "after" || snapshot.data.status !== "passed")
-            continue;
-        if (commandTampered(snapshot, git).entrypointModified)
-            continue;
-        const name = snapshot.data.commandName;
-        if (typeof name === "string" && name.length > 0)
-            names.add(name);
-    }
-    return names;
+/** v3.8: The single machine-backed predicate lives in evidence-provider.ts.
+ *  This wrapper resolves the round's git observation once for a collection. */
+function passedAfterCommand(observations) {
+    const git = observations.find((item) => item.providerId === "git") ?? null;
+    const changed = git ? new Set(git.files) : null;
+    return observations.find((item) => isPassedAfterObservation(item, changed)) ?? null;
 }
 /** v3.2: Derive the machine-verification status of a round. The verification
  *  capability is modeled explicitly (verified / unavailable / absent) instead
  *  of letting evidence-dependent checks silently disappear when snapshots are
  *  missing — the fix for the "weakest when it matters most" gap. */
 export function deriveEvidenceStatus(selfEval, evidenceSnapshots) {
-    const gitSnap = evidenceSnapshots.find((snapshot) => snapshot.provider === "git") ?? null;
+    const gitSnap = evidenceSnapshots.find((item) => item.providerId === "git") ?? null;
     const gitObserved = gitSnap !== null && gitSnap.files.length > 0;
     const command = passedAfterCommand(evidenceSnapshots);
     const commandVerified = command !== null;
-    // testsMachineBacked: agent-reported test_results agree with a passed
+    // 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_evidence?.test_results;
-    if (command && reported) {
-        const parsed = parseTestOutput(String(command.data.stdout ?? ""));
+    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 &&
@@ -251,8 +209,8 @@ export function deriveEvidenceStatus(selfEval, evidenceSnapshots) {
     }
     // reportedFilesMatch: agent-reported files_changed equals the git diff set.
     let reportedFilesMatch = false;
-    if (gitSnap && selfEval.execution_evidence) {
-        const reportedSet = [...selfEval.execution_evidence.files_changed].sort();
+    if (gitSnap && selfEval.execution_report) {
+        const reportedSet = [...(selfEval.execution_report.files_changed ?? [])].sort();
         const actualSet = [...gitSnap.files].sort();
         reportedFilesMatch = reportedSet.length === actualSet.length &&
             reportedSet.every((file, index) => file === actualSet[index]);
@@ -278,7 +236,7 @@ export function deriveEvidenceStatus(selfEval, evidenceSnapshots) {
 }
 /** Per-round machine progress over decoded committed history. */
 export function machineProgressSeries(vaultEntries, currentRound, lookback) {
-    return machineGitMotionSeries(committedRoundsFromEntries(vaultEntries, currentRound), currentRound, lookback);
+    return machineGitMotionSeries(derivationRounds(vaultEntries, currentRound), currentRound, lookback);
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // Individual checks — each returns a VerificationFlag or null
@@ -286,8 +244,8 @@ export function machineProgressSeries(vaultEntries, currentRound, lookback) {
 function checkSuccessWithRemainingCriteria(selfEval) {
     if (!effectiveSuccess(selfEval))
         return null;
-    const remaining = selfEval.execution_evidence?.success_criteria_remaining;
-    if (!remaining || remaining.length === 0)
+    const remaining = claimedRemainingCriteria(selfEval.execution_report);
+    if (remaining.length === 0)
         return null;
     return makeVerificationFlag({
         severity: "error",
@@ -303,14 +261,14 @@ function checkSuccessWithRemainingCriteria(selfEval) {
  *  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) {
-    const met = selfEval.execution_evidence?.success_criteria_met;
-    if (!met || met.length === 0)
+    const met = claimedMetCriteria(selfEval.execution_report);
+    if (met.length === 0)
         return null;
     if (claimView.verifiedCount > 0 || claimView.hasMachineEvidence)
         return null;
     return makeVerificationFlag({
         severity: "warn",
-        field: "execution_evidence",
+        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)",
@@ -403,13 +361,12 @@ function checkRetroactiveClaims(selfEval, vaultEntries, currentRound) {
 /** v2.12/v3.6/v3.7: success without machine backing — the single
  *  "success evidence" semantic. Two arms, evaluated in order:
  *  1. Empty/missing-evidence arm (v3.7: absorbed the enforcement-only
- *     empty_success rule): success=true with NO execution_evidence at all, or
- *     with files_changed empty AND test_results null, is an error
+ *     empty_success rule): success=true with NO execution_report at all, or
+ *     with files_changed empty AND tests_reported null, is an error
  *     unconditionally — BEFORE the providerStatus early-exit, so a passed
- *     command never rescues it (execution_evidence stays mandatory), and
- *     neither evidence.machine_backed_success "warn" nor a declared
- *     no_change_reason downgrades it ("no change" with literally no evidence
- *     recorded is still an unbacked claim).
+ *     command never rescues it (execution_report stays mandatory), and
+ *     no declared no_change_reason downgrades it ("no change" with literally
+ *     no evidence recorded is still an unbacked claim).
  *  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
@@ -418,38 +375,51 @@ function checkRetroactiveClaims(selfEval, vaultEntries, currentRound) {
  *     success — "required" rejects (error), "warn" tolerates with a warn
  *     (round commits, success excluded from the trajectory, trust drops). A
  *     declared no_change_reason is the honest escape hatch: it downgrades to
- *     info. no_change_reason is honored HERE ONLY — contract checks refuse it. */
+ *     info — honored only while NO enabled verification command is
+ *     configured (machine verification was structurally impossible); a
+ *     configured command closes the escape. no_change_reason is honored HERE
+ *     ONLY — contract checks refuse it. */
 function checkSuccessWithoutVerifiedEvidence(selfEval, status) {
     if (!effectiveSuccess(selfEval))
         return null;
     // v3.7: empty/missing-evidence arm (ex-R3 empty_success posture).
-    const ev = selfEval.execution_evidence;
-    if (!ev || (ev.files_changed.length === 0 && ev.test_results === null)) {
+    const ev = selfEval.execution_report;
+    if (!ev || ((ev.files_changed ?? []).length === 0 && ev.tests_reported === null)) {
         return makeVerificationFlag({
             severity: "error",
             field: "success",
             check: CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE,
             detail: ev
-                ? "Agent claims success but execution_evidence shows no files changed " +
+                ? "Agent claims success but execution_report shows no files changed " +
                     "and no tests were run. There is no verifiable evidence of work."
-                : "Agent claims success but provided no execution_evidence. " +
-                    "Every successful round MUST include execution_evidence with " +
-                    "files_changed, test_results, and progress_estimate.",
+                : "Agent claims success but provided no execution_report. " +
+                    "Every successful round MUST include execution_report with " +
+                    "files_changed, tests_reported, and progress_estimate.",
         });
     }
     // Claims arm (v3.6).
     if (status.providerStatus === "verified")
         return null;
-    const noChange = typeof selfEval.no_change_reason === "string" &&
+    // M2 (v3.7.x): the no_change_reason escape is only honest when machine
+    // verification was STRUCTURALLY impossible. With an enabled verification
+    // command configured, the runtime had a machine-verifiable path for this
+    // round — a declared reason cannot waive it (that would let an agent
+    // dodge the configured verification by writing a sentence, even while git
+    // observed real file changes). Verification-less policies (the default:
+    // commands: []) keep the escape: there is genuinely nothing to run.
+    const verificationConfigured = getPolicy().evidence.commands.some((command) => command.enabled);
+    const noChange = !verificationConfigured &&
+        typeof selfEval.no_change_reason === "string" &&
         selfEval.no_change_reason.trim().length > 0;
-    // v3.3: severity follows evidence.machine_backed_success — "required"
-    // rejects (error), "warn" tolerates with a warn (round commits, success
-    // excluded from the trajectory, trust drops). no_change_reason stays info.
-    const severity = noChange
-        ? "info"
-        : getPolicy().evidence.machine_backed_success === "warn"
-            ? "warn"
-            : "error";
+    // v3.8: an unbacked success claim is "机器观察不足", not a contradiction —
+    // the round COMMITS with the claim recorded as insufficient, and the
+    // success stays out of the success trajectory (shouldPushSuccess keys on
+    // 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.
+    const severity = noChange ? "info" : "warn";
     return makeVerificationFlag({
         severity,
         field: "success",
@@ -553,16 +523,16 @@ function checkRetractFreshConstraint(selfEval, prevSelfEval, currentRound) {
     return null;
 }
 /** v1.18: Cross-validate agent-reported files_changed against git evidence
- *  from the configured evidence providers (ProviderSnapshot array). */
+ *  from the configured evidence providers (MachineObservation array). */
 function checkEvidenceIntegrity(selfEval, evidenceSnapshots) {
-    if (!selfEval.execution_evidence)
+    if (!selfEval.execution_report)
         return null;
     if (evidenceSnapshots.length === 0)
         return null;
-    const gitSnap = evidenceSnapshots.find((s) => s.provider === "git");
+    const gitSnap = evidenceSnapshots.find((s) => s.providerId === "git");
     if (!gitSnap)
         return null;
-    const reported = [...selfEval.execution_evidence.files_changed].sort();
+    const reported = [...(selfEval.execution_report.files_changed ?? [])].sort();
     const actual = [...gitSnap.files].sort();
     if (reported.length === 0 && actual.length === 0)
         return null;
@@ -597,22 +567,20 @@ function checkRequiredCommandEvidence(selfEval, evidenceSnapshots) {
     if (!effectiveSuccess(selfEval))
         return null;
     for (const snapshot of evidenceSnapshots) {
-        if (snapshot.data.kind !== "command")
+        if (snapshot.kind !== "command")
             continue;
-        if (snapshot.data.phase !== "after" || snapshot.data.required !== true)
+        if (snapshot.phase !== "after" || snapshot.data.required !== true)
             continue;
-        const status = snapshot.data.status;
+        const status = snapshot.status;
         if (status === "passed")
             continue;
-        const name = typeof snapshot.data.commandName === "string"
-            ? snapshot.data.commandName
-            : snapshot.provider;
+        const name = snapshot.data.commandId;
         const exitCode = typeof snapshot.data.exitCode === "number"
             ? ` (exit ${snapshot.data.exitCode})`
             : "";
         return makeVerificationFlag({
             severity: "error",
-            field: "execution_evidence",
+            field: "execution_report",
             check: CHECK_REQUIRED_COMMAND_FAILED,
             detail: `Agent claims success but required command "${name}" ${String(status)}${exitCode}`,
         });
@@ -620,122 +588,12 @@ function checkRequiredCommandEvidence(selfEval, evidenceSnapshots) {
     return null;
 }
 // ── Test output parsing ────────────────────────────────────────────────────
-// jaccardSimilarity() imported from token-utils.ts (v2.1 — intent-action drift detection)
-/** Extract stable sub-goal IDs (sg-XXXXXXXX) mentioned in text.
- *  Matches the ID format rendered in prompts (loop-compiler deriveSubGoalId). */
-function extractSubGoalIds(text) {
-    return [...new Set(text.toLowerCase().match(/sg-[a-f0-9]{8}/g) ?? [])];
-}
 /** 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);
 }
-/** Map each referenced sub-goal ID to its known description(s), reconstructed
- *  from emerged_subtasks in the vault lineage and the previous self-eval. */
-function referencedSubGoalDescriptions(ids, vaultEntries, prevSelfEval) {
-    const map = new Map();
-    for (const id of ids)
-        map.set(id, []);
-    const descriptions = [];
-    for (const entry of vaultEntries) {
-        const emerged = Array.isArray(entry.emerged_subtasks)
-            ? entry.emerged_subtasks.filter((v) => typeof v === "string")
-            : [];
-        descriptions.push(...emerged);
-    }
-    descriptions.push(...(prevSelfEval?.emerged_subtasks ?? []));
-    for (const desc of descriptions) {
-        const trimmed = desc.trim();
-        if (!trimmed)
-            continue;
-        const id = deriveSubGoalId(trimmed);
-        if (map.has(id))
-            map.get(id).push(trimmed);
-    }
-    return map;
-}
-/** v2.1 (check 11): Compare the previous round's declared next_action with
- *  the current round's actual output_summary. Detect when the agent says it
- *  will do X but then does Y — silent drift without explanation.
- *
- *  Only fires when both next_action and output_summary are non-empty.
- *
- *  v2.14: Structured-ID-first detection. Alignment is decided by a waterfall
- *  of concrete signals before falling back to string similarity:
- *    1. Sub-goal IDs (sg-XXXXXXXX) in next_action matched against this
- *       round's completed_subtasks (exact ID, ID derived from the
- *       description text, or Jaccard against the referenced sub-goal's
- *       known description).
- *    2. File paths named in next_action appearing in files_changed.
- *    3. Test evidence — next_action mentions tests and test files were
- *       changed with tests actually run.
- *    4. Jaccard token similarity against the policy threshold (weak signal).
- *  Any signal aligning is sufficient — text similarity is never the sole
- *  authority when structured evidence exists. */
-function checkIntentDrift(selfEval, prevSelfEval, vaultEntries) {
-    if (!prevSelfEval?.next_action?.trim())
-        return null;
-    if (!selfEval.output_summary.trim())
-        return null;
-    const intent = prevSelfEval.next_action.trim();
-    const actual = selfEval.output_summary.trim();
-    const policy = getPolicy();
-    const filesChanged = selfEval.execution_evidence?.files_changed ?? [];
-    // ── Signal 1: sub-goal IDs referenced by next_action → completed this round
-    const intentIds = extractSubGoalIds(intent);
-    if (intentIds.length > 0) {
-        const completed = selfEval.completed_subtasks ?? [];
-        const referenced = referencedSubGoalDescriptions(intentIds, vaultEntries, prevSelfEval);
-        const idMatched = intentIds.some((id) => completed.some((entry) => {
-            const text = entry.trim();
-            if (!text)
-                return false;
-            if (text.toLowerCase() === id)
-                return true;
-            if (deriveSubGoalId(text) === id)
-                return true;
-            const descriptions = referenced.get(id) ?? [];
-            return descriptions.some((desc) => jaccardSimilarity(text, desc) >= policy.evolution.subgoal_match_threshold);
-        }));
-        if (idMatched)
-            return null;
-    }
-    // ── Signal 2: file paths named in next_action appear in files_changed
-    const intentPaths = extractFilePathTokens(intent);
-    if (intentPaths.length > 0 && filesChanged.length > 0) {
-        const pathMatched = intentPaths.some((p) => filesChanged.some((f) => f === p || f.endsWith(p) || p.endsWith(f)));
-        if (pathMatched)
-            return null;
-    }
-    // ── Signal 3: test evidence — intent mentions tests, test files changed,
-    //    and tests actually ran this round
-    const intentTokens = tokenize(intent);
-    const mentionsTests = intentTokens.has("test") || intentTokens.has("tests");
-    const testResults = selfEval.execution_evidence?.test_results;
-    const testsRan = !!testResults && testResults.passed + testResults.failed > 0;
-    const testFilesChanged = filesChanged.some((f) => isTestFile(f));
-    if (mentionsTests && testsRan && testFilesChanged)
-        return null;
-    // ── Signal 4 (weak): Jaccard token similarity
-    const score = jaccardSimilarity(intent, actual);
-    const threshold = policy.evolution.intent_drift_threshold;
-    if (score >= threshold)
-        return null;
-    const idNote = intentIds.length > 0
-        ? `; ${intentIds.length} referenced sub-goal ID(s) did not match completed_subtasks`
-        : "";
-    return makeVerificationFlag({
-        severity: "warn",
-        field: "output_summary",
-        check: CHECK_INTENT_DRIFT,
-        detail: `Declared intent was "${intent.slice(0, 120)}" ` +
-            `but actual output "${actual.slice(0, 120)}" — ` +
-            `similarity ${(score * 100).toFixed(0)}% below threshold ${(threshold * 100).toFixed(0)}%` +
-            idNote,
-    });
-}
 /** Best-effort parse of test counts from common test-runner output formats.
  *
  *  Scans the last 2000 characters of stdout (where summary lines typically
@@ -800,7 +658,7 @@ export function parseTestOutput(stdout) {
     }
     return null;
 }
-/** Cross-validate agent-reported test_results against command evidence output.
+/** 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
@@ -810,17 +668,17 @@ export function parseTestOutput(stdout) {
  *  Non-command evidence providers are skipped (no structural cross-check is
  *  defined for them yet). */
 function checkCommandEvidenceIntegrity(selfEval, evidenceSnapshots) {
-    const reported = selfEval.execution_evidence?.test_results;
+    const reported = selfEval.execution_report?.tests_reported;
     if (!reported)
         return null;
     for (const snapshot of evidenceSnapshots) {
-        if (snapshot.data.kind !== "command")
+        if (snapshot.kind !== "command")
             continue;
-        if (snapshot.data.status !== "passed")
+        if (snapshot.status !== "passed")
             continue;
         if (snapshot.data.truncated === true)
             continue;
-        const stdout = typeof snapshot.data.stdout === "string" ? snapshot.data.stdout : "";
+        const stdout = typeof snapshot.data.stdoutExcerpt === "string" ? snapshot.data.stdoutExcerpt : "";
         const parsed = parseTestOutput(stdout);
         if (!parsed)
             continue;
@@ -835,16 +693,14 @@ function checkCommandEvidenceIntegrity(selfEval, evidenceSnapshots) {
             // Counts match exactly — evidence supports the agent's claim.
             continue;
         }
-        const name = typeof snapshot.data.commandName === "string"
-            ? snapshot.data.commandName
-            : snapshot.provider;
+        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: "test_results",
+            field: "tests_reported",
             check: CHECK_COMMAND_EVIDENCE_MISMATCH,
-            detail: `Agent test_results don't match "${name}" output: ${mismatches.join("; ")}`,
+            detail: `Agent tests_reported don't match "${name}" output: ${mismatches.join("; ")}`,
         });
     }
     return null;
@@ -856,149 +712,99 @@ function checkCommandEvidenceIntegrity(selfEval, evidenceSnapshots) {
  *  confirm the tests still verify the task claims). Fail-open when the git
  *  snapshot is missing or the command has no resolvable entrypoint. */
 function checkVerificationDomainIntegrity(evidenceSnapshots) {
-    const git = evidenceSnapshots.find((snapshot) => snapshot.provider === "git") ?? null;
+    const git = evidenceSnapshots.find((snapshot) => snapshot.providerId === "git") ?? null;
     if (!git)
         return null;
+    // v3.8.1: EVERY after-phase command is scanned for a tampered entrypoint
+    // before the test-file warn may answer for one of them. `testFilesModified`
+    // is derived from the git file set alone, so it is true for every command as
+    // soon as the round touched a test file; answering with that warn on the
+    // first command in array order meant a rewritten verification entrypoint
+    // produced no error flag at all, and the enforcement row that reacts to it
+    // never fired. The verdict depended on observation order.
     for (const snapshot of evidenceSnapshots) {
-        if (!isRecord(snapshot.data) || snapshot.data.kind !== "command")
+        if (!isRecord(snapshot.data) || snapshot.kind !== "command")
             continue;
-        if (snapshot.data.phase !== "after")
+        if (snapshot.phase !== "after")
             continue;
-        const { entrypointModified, testFilesModified } = commandTampered(snapshot, git);
-        if (!entrypointModified && !testFilesModified)
+        if (!commandTampered(snapshot, git).entrypointModified)
+            continue;
+        return makeVerificationFlag({
+            severity: "error",
+            field: "execution_report",
+            check: CHECK_VERIFICATION_ENTRYPOINT_MODIFIED,
+            detail: `Verification command "${snapshot.data.commandId}" entrypoint changed this round — ` +
+                "its result cannot be trusted as machine evidence. Keep the " +
+                "verification command stable or resubmit the same round with the " +
+                "entrypoint unchanged.",
+        });
+    }
+    // Only when NO entrypoint was tampered does the test-file warn stand in.
+    for (const snapshot of evidenceSnapshots) {
+        if (!isRecord(snapshot.data) || snapshot.kind !== "command")
+            continue;
+        if (snapshot.phase !== "after")
+            continue;
+        if (!commandTampered(snapshot, git).testFilesModified)
             continue;
-        const name = typeof snapshot.data.commandName === "string"
-            ? snapshot.data.commandName
-            : snapshot.provider;
-        if (entrypointModified) {
-            return makeVerificationFlag({
-                severity: "error",
-                field: "execution_evidence",
-                check: CHECK_VERIFICATION_ENTRYPOINT_MODIFIED,
-                detail: `Verification command "${name}" entrypoint changed this round — ` +
-                    "its result cannot be trusted as machine evidence. Keep the " +
-                    "verification command stable or resubmit the same round with the " +
-                    "entrypoint unchanged.",
-            });
-        }
         return makeVerificationFlag({
             severity: "warn",
-            field: "execution_evidence",
+            field: "execution_report",
             check: CHECK_TEST_FILES_MODIFIED,
-            detail: `Test files changed in the same round command "${name}" passed — ` +
+            detail: `Test files changed in the same round command "${snapshot.data.commandId}" passed — ` +
                 "confirm the tests still verify the task claims.",
         });
     }
     return null;
 }
-/** v2.2: Check if the agent's declared next_action aligns with any pending
- *  or in_progress sub-goal. When 3+ pending sub-goals exist but the agent
- *  plans work unrelated to any of them, it may indicate task drift.
- *  This is a warn-level advisory — the agent always owns prioritization.
+/** v2.13: After a backtrack, check that the agent restored the workspace
+ *  before working. Two arms:
  *
- *  v2.14: Exact sub-goal ID alignment first — next_action naming a pending
- *  sub-goal by its stable ID (sg-XXXXXXXX) is aligned by definition.
- *  Jaccard description similarity remains as the fallback. */
-function checkSubGoalDrift(selfEval, prevSelfEval, vaultEntries, currentRound) {
-    const nextAction = selfEval.next_action?.trim();
-    if (!nextAction)
-        return null;
-    // Reconstruct pending sub-goal descriptions from vault entries
-    const pendingSubGoals = new Set();
-    const completedOrCanceled = new Set();
-    for (const entry of vaultEntries) {
-        const emerged = Array.isArray(entry.emerged_subtasks)
-            ? entry.emerged_subtasks.filter((v) => typeof v === "string")
-            : [];
-        for (const desc of emerged) {
-            pendingSubGoals.add(desc.trim());
-        }
-        const done = Array.isArray(entry.completed_subtasks)
-            ? entry.completed_subtasks.filter((v) => typeof v === "string")
-            : [];
-        for (const desc of done) {
-            completedOrCanceled.add(desc.trim());
-        }
-        const canceled = Array.isArray(entry.canceled_subtasks)
-            ? entry.canceled_subtasks.filter((v) => typeof v === "string")
-            : [];
-        for (const desc of canceled) {
-            completedOrCanceled.add(desc.trim());
+ *  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 = {}, evidenceSnapshots = []) {
+    // Machine arm — untouched-since-rollback proof, independent of claims.
+    const failedEntries = Object.entries(backtrackSkippedFingerprints);
+    if (failedEntries.length > 0) {
+        const git = evidenceSnapshots.find((snapshot) => snapshot.kind === "git" && isRecord(snapshot.data.fingerprints));
+        const currentFingerprints = git && git.kind === "git"
+            ? git.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.`,
+                });
+            }
         }
     }
-    // Also process current selfEval
-    for (const desc of selfEval.emerged_subtasks ?? []) {
-        pendingSubGoals.add(desc.trim());
-    }
-    for (const desc of selfEval.completed_subtasks ?? []) {
-        completedOrCanceled.add(desc.trim());
-    }
-    for (const desc of selfEval.canceled_subtasks ?? []) {
-        completedOrCanceled.add(desc.trim());
-    }
-    // Remove completed/canceled from pending
-    for (const desc of completedOrCanceled) {
-        pendingSubGoals.delete(desc);
-    }
-    // Need at least 3 pending sub-goals for the check to be meaningful
-    if (pendingSubGoals.size < 3)
+    const ev = selfEval.execution_report;
+    if (!ev || (ev.files_changed ?? []).length === 0)
         return null;
-    // v2.14: Stable ID match first — next_action naming a pending sub-goal
-    // by ID is aligned by definition, regardless of description wording.
-    const nextActionIds = extractSubGoalIds(nextAction);
-    if (nextActionIds.length > 0) {
-        const pendingIds = new Set([...pendingSubGoals].map((d) => deriveSubGoalId(d)));
-        if (nextActionIds.some((id) => pendingIds.has(id)))
-            return null;
-    }
-    // Check if next_action aligns with any pending sub-goal
-    let aligns = false;
-    for (const sg of pendingSubGoals) {
-        const score = jaccardSimilarity(nextAction, sg);
-        if (score >= getPolicy().evolution.subgoal_drift_alignment_threshold) {
-            aligns = true;
-            break;
-        }
-    }
-    if (!aligns) {
-        const sample = [...pendingSubGoals].slice(0, 3).join(", ");
-        return makeVerificationFlag({
-            severity: "warn",
-            field: "next_action",
-            check: CHECK_SUBGOAL_DRIFT,
-            detail: `Agent's next_action doesn't align with any of ${pendingSubGoals.size} pending sub-goals. ` +
-                `Pending: ${sample}… Consider completing existing sub-goals before starting new work, ` +
-                `or cancel outdated sub-goals via canceled_subtasks.`,
-        });
-    }
-    return null;
-}
-/** v2.13: After a backtrack, check that the agent restored the workspace
- *  before working. If the agent's files_changed overlaps with files from
- *  skipped (failed) rounds, the workspace was likely not clean. */
-function checkBacktrackWorkspaceRestore(selfEval, backtrackSkippedFiles) {
-    if (backtrackSkippedFiles.length === 0)
-        return null;
-    const ev = selfEval.execution_evidence;
-    if (!ev || ev.files_changed.length === 0)
-        return null;
-    // Check overlap: files the agent changed vs. files from skipped rounds
-    const overlap = ev.files_changed.filter((f) => backtrackSkippedFiles.some((sf) => sf === f || f.endsWith(sf) || sf.endsWith(f)));
+    // 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;
-    // Agent is modifying files that were part of failed rounds without
-    // having properly restored the workspace first.
-    if (overlap.length >= 3 || overlap.length === ev.files_changed.length) {
-        return makeVerificationFlag({
-            severity: "error",
-            field: "files_changed",
-            check: CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED,
-            detail: `Agent modified ${overlap.length} file(s) that were part of ` +
-                `the skipped (failed) rounds: ${overlap.slice(0, 5).join(", ")}. ` +
-                `The workspace was likely not restored before working.`,
-        });
-    }
-    // Minor overlap — warn only
     return makeVerificationFlag({
         severity: "warn",
         field: "files_changed",
@@ -1013,7 +819,7 @@ function checkBacktrackWorkspaceRestore(selfEval, backtrackSkippedFiles) {
 function checkBacktrackGitHeadRestore(evidenceSnapshots, backtrackTargetGitHead) {
     if (!backtrackTargetGitHead)
         return null;
-    const git = evidenceSnapshots.find((snapshot) => snapshot.provider === "git" && isRecord(snapshot.data) &&
+    const git = evidenceSnapshots.find((snapshot) => snapshot.providerId === "git" && isRecord(snapshot.data) &&
         typeof snapshot.data.head === "string");
     if (!git)
         return null; // git unavailable → cannot verify → skip (fail-open)
@@ -1032,67 +838,23 @@ function checkBacktrackGitHeadRestore(evidenceSnapshots, backtrackTargetGitHead)
     });
 }
 // ═══════════════════════════════════════════════════════════════════════════
-// v3.3 — Round Contract checks (all silent when no contract is declared)
+// v3.8 — Round Contract checks (all silent when no contract is declared)
+//
+// The item model moved closure to the runtime: an item is verified only when
+// its bound commands were observed passing (untampered, same config) in the
+// claiming round. A claimed-but-unbacked item is therefore `insufficient`
+// (recorded, never a rejection), and a premature closure is structurally
+// impossible. The checks below only surface state the agent must see.
 // ═══════════════════════════════════════════════════════════════════════════
-/** A PROPOSAL that promises nothing is a wasted round's worth of trust:
- *  done_when empty means the boundary can never be machine-checked.
- *  v3.4: declaration-quality check on the submission's own proposal — never
- *  on the (derived) active contract. */
-function checkRoundUnderspecified(selfEval) {
-    const contract = selfEval.round_contract;
-    if (!contract)
-        return null;
-    if (contract.done_when.length > 0)
-        return null;
-    return makeVerificationFlag({
-        severity: "warn",
-        field: "round_contract",
-        check: CHECK_ROUND_UNDERSPECIFIED,
-        detail: "Round Contract declared with an empty done_when — nothing is " +
-            "promised, so completion cannot be verified. Declare what must be " +
-            "true when the round is done.",
-    });
-}
-/** done_when items whose verification_plan cannot run (empty plan, or names
- *  outside the configured, enabled evidence.commands) can never be
- *  machine-checked at the boundary. v3.4: declaration-quality check on the
- *  submission's own proposal. */
-function checkRoundUnverifiable(selfEval) {
-    const contract = selfEval.round_contract;
-    if (!contract)
-        return null;
-    if (contract.done_when.length === 0)
-        return null;
-    if (contract.verification_plan.length > 0 &&
-        contract.verification_plan.every((name) => isConfiguredCommand(name))) {
-        return null;
-    }
-    const unknown = contract.verification_plan.filter((name) => !isConfiguredCommand(name));
-    const detail = contract.verification_plan.length === 0
-        ? "done_when items declared but verification_plan is empty — no command " +
-            "can back the completion claims"
-        : `verification_plan names commands that are not configured and enabled ` +
-            `in evidence.commands: ${unknown.slice(0, 3).join(", ")}`;
-    return makeVerificationFlag({
-        severity: "warn",
-        field: "round_contract",
-        check: CHECK_ROUND_UNVERIFIABLE,
-        detail: detail + ". Name only configured, enabled evidence.commands, or drop " +
-            "done_when items that cannot be machine-verified.",
-    });
-}
 /** The round changed files outside the ACTIVE contract's declared scope.
  *  Git diff files are the machine-authoritative "what actually changed" set.
- *  v3.4: targets the contract the round actually executed under — derived
- *  from committed evals, never the submission's own proposal. Silent when
- *  no active contract exists (round 1 and whole-task rounds: the agent
- *  executed the original task, not a contract boundary). */
+ *  Silent when no active contract exists or it declares no scope. */
 function checkRoundScopeDrift(activeContract, evidenceSnapshots) {
     if (!activeContract)
         return null;
     if (activeContract.scope.length === 0)
         return null;
-    const git = evidenceSnapshots.find((snapshot) => snapshot.provider === "git");
+    const git = evidenceSnapshots.find((snapshot) => snapshot.providerId === "git");
     if (!git)
         return null; // git unavailable → cannot observe → fail open
     const outOfScope = collectOutOfScopeFiles(git.files, activeContract.scope);
@@ -1106,142 +868,53 @@ function checkRoundScopeDrift(activeContract, evidenceSnapshots) {
             (outOfScope.length > 5
                 ? ` (${outOfScope.length} total, showing 5): ${outOfScope.slice(0, 5).join(", ")}`
                 : `: ${outOfScope.join(", ")}`) +
-            `. Revert them or extend the contract scope and explain in drift_clarification.`,
-    });
-}
-/** success claimed under the ACTIVE contract whose done_when items were not
- *  honestly and verifiably completed: claimed met with no machine-verified
- *  evidence this round, or silently dropped (present in neither
- *  success_criteria_met nor success_criteria_remaining).
- *  v3.4: targets the derived ACTIVE contract (the round's real boundary) —
- *  a proposal declared on a round without an active contract is never
- *  checked for conformance against work the round did not do under it.
- *  v3.5.1: a fully-met posture (every done_when claimed satisfied) is owned
- *  by contract_completion_unverified — this check stays for mixed and
- *  silently-dropped success claims only.
- *  v3.6: no_change_reason never downgrades this check — the escape hatch
- *  belongs to the R8 success-claim family alone; a declared "no change"
- *  contradicts silently dropping contract done_when items. */
-function checkPrematureBoundary(activeContract, selfEval, claimView) {
-    if (!activeContract || activeContract.done_when.length === 0)
-        return null;
-    if (!effectiveSuccess(selfEval))
-        return null;
-    const ev = selfEval.execution_evidence;
-    const met = ev?.success_criteria_met ?? [];
-    // v3.5.1: full-met → the completion check owns the posture (it also fires
-    // on success=false, so nothing is lost — and under machine_backed_success
-    // "warn" the same tolerance applies on both sides).
-    if (contractDoneWhenSatisfied(activeContract, met))
-        return null;
-    const remaining = ev?.success_criteria_remaining ?? [];
-    const problems = [];
-    for (const item of activeContract.done_when) {
-        // Shared matcher with the lifecycle walker (round-contract.ts) — the
-        // compile-side closure decision and this conformance check can never
-        // disagree on what counts as a satisfied item.
-        const isMet = met.some((m) => contractItemMatches(item, m));
-        const isRemaining = remaining.some((r) => contractItemMatches(item, r));
-        if (isMet) {
-            // Claimed met — needs round-level machine verification. The v3.3
-            // claim model is round-uniform: any verified claim backs the round,
-            // so zero verified claims = none of them are backed.
-            if (claimView.verifiedCount === 0) {
-                problems.push(`"${item.slice(0, 80)}" claimed met without machine-verified evidence`);
-            }
-        }
-        else if (!isRemaining) {
-            // Neither met nor remaining — silently dropped while success is
-            // claimed. Honest reporting would list it in remaining (R1's domain).
-            problems.push(`"${item.slice(0, 80)}" neither met nor listed as remaining`);
-        }
-    }
-    if (problems.length === 0)
-        return null;
-    return makeVerificationFlag({
-        severity: "error",
-        field: "round_contract",
-        check: CHECK_PREMATURE_BOUNDARY,
-        detail: `Round Contract boundary claimed prematurely: ${problems.slice(0, 3).join("; ")}. ` +
-            `Run the contract's verification_plan commands and report real output, ` +
-            `or set success=false and list the items in success_criteria_remaining.`,
+            `. Revert them, or close the active contract and declare the extended scope in a new proposal.`,
     });
 }
-/** v3.5: Closing a Round Contract is a success-class claim and must be
- *  machine-backed. When the eval's met claims satisfy EVERY done_when of
- *  the ACTIVE contract (the walker's close condition), each verification_plan
- *  command must have been observed passing (after-phase command snapshot,
- *  untampered) in the same round. Fires regardless of the success flag —
- *  a claim-based closure that the machine cannot back must not advance the
- *  contract state machine. Severity follows evidence.machine_backed_success
- *  (the R8 tolerance switch). Deliberately no no_change_reason downgrade:
- *  all done_when met contradicts "no change". Fail-open: a plan name that
- *  is no longer a configured, enabled command cannot be observed and is
- *  not required. The check observes that the commands ran, not what they
- *  verified — R-C1's claim model remains the content bound. */
-function checkContractCompletionUnverified(activeContract, selfEval, evidenceSnapshots) {
-    if (!activeContract || activeContract.verification_plan.length === 0)
-        return null;
-    const met = selfEval.execution_evidence?.success_criteria_met ?? [];
-    if (!contractDoneWhenSatisfied(activeContract, met))
-        return null; // walker does not close
-    const required = activeContract.verification_plan
-        .filter((name) => isConfiguredCommand(name));
-    if (required.length === 0)
-        return null; // fail open — cannot observe
-    const passed = passedPlanCommandNames(evidenceSnapshots);
-    const missing = required.filter((name) => !passed.has(name));
-    if (missing.length === 0)
+/** 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) {
+    if (statuses.insufficientCount === 0)
         return null;
-    const severity = getPolicy().evidence.machine_backed_success === "warn"
-        ? "warn"
-        : "error";
+    const unverified = statuses.items
+        .filter((item) => item.status === "insufficient")
+        .slice(0, 3)
+        .map((item) => item.itemId);
     return makeVerificationFlag({
-        severity,
+        severity: "warn",
         field: "round_contract",
-        check: CHECK_CONTRACT_COMPLETION_UNVERIFIED,
-        detail: `Round Contract completion claimed (every done_when met), but verification_plan ` +
-            `command${missing.length > 1 ? "s" : ""} did not pass this round: ` +
-            `${missing.slice(0, 3).join(", ")}. Closing a contract is a success-class claim — ` +
-            `fix the underlying failure so the command${missing.length > 1 ? "s" : ""} pass and ` +
-            `resubmit; no_change_reason does not apply to completion claims.`,
+        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.`,
     });
 }
-/** v3.5: 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 to the agent. Silent when the eval closes the
- *  active contract (all done_when met, or outcome=blocked — checked FIRST,
- *  mirroring the walker), when no proposal is submitted, or when the
- *  proposal equals the active contract (a restate). Equality is
- *  key-order-insensitive and normalized through parseRoundContract on both
- *  sides so committed-raw vs parsed-submission key-set drift cannot cause
- *  spurious warns. */
-function checkContractPremature(activeContract, selfEval) {
+/** 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). */
+function checkContractPremature(activeContract, statuses, selfEval) {
     if (!activeContract)
         return null;
-    const met = selfEval.execution_evidence?.success_criteria_met ?? [];
-    if (contractDoneWhenSatisfied(activeContract, met))
+    if (statuses.closure !== "open")
         return null; // closed
     if (selfEval.outcome === "blocked")
         return null; // closed
     const proposal = selfEval.round_contract;
     if (!proposal)
         return null;
-    const same = stableStringify(parseRoundContract(activeContract)) ===
-        stableStringify(parseRoundContract(proposal));
-    if (same)
+    if (sameContract(proposal, activeContract))
         return null; // restate → continue
     return makeVerificationFlag({
         severity: "warn",
         field: "round_contract",
         check: CHECK_CONTRACT_PREMATURE,
-        detail: "The ACTIVE Round Contract is still open (not all done_when met, not blocked) " +
+        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 is completed or blocked. Restate the active contract unchanged to " +
-            "continue it.",
+            "contract closes. Restate the active contract unchanged to continue it.",
     });
 }
-// ═══════════════════════════════════════════════════════════════════════════
 // Main entry point
 // ═══════════════════════════════════════════════════════════════════════════
 /** Verify a SelfEvaluation against the loop's cross-round lineage.
@@ -1256,15 +929,80 @@ function checkContractPremature(activeContract, selfEval) {
  * @param evidenceSnapshots    v1.18: Evidence snapshots from configured providers.
  *                             Used by checkEvidenceIntegrity for multi-provider
  *                             cross-validation. Defaults to empty array. */
-export function verifySelfEvaluation(selfEval, currentRound, vaultEntries, prevSelfEval = null, evidenceSnapshots = [], 
+/** v3.7.1: Opt-in round blocking for the gate layer. For every gate id the
+ *  round cites (gate_ids), the gate_opened record must exist, must be a
+ *  USER gate, and must have an approved gate_decision. Error flags list
+ *  every failing id with a reason. Entirely skipped when the feature is
+ *  disabled — there is nothing to cite against. */
+function checkUserGateUnresolved(selfEval, gateEntries) {
+    if (!getPolicy().gate.enabled)
+        return null;
+    const cited = (selfEval.gate_ids ?? []).filter((id) => typeof id === "string");
+    if (cited.length === 0)
+        return null;
+    const opened = new Set();
+    const userKind = new Set();
+    const approved = new Set();
+    for (const entry of gateEntries) {
+        if (entry.task_type === "gate_opened" && typeof entry.gate_id === "string") {
+            opened.add(entry.gate_id);
+            // v3.7.1: structured records declare gate_kind; legacy flat records
+            // (blocked-round auto-records) classify their stored action text.
+            if (entry.gate_kind === "user") {
+                userKind.add(entry.gate_id);
+            }
+            else if (typeof entry.gate_action === "string") {
+                let kind = null;
+                try {
+                    kind = preflightStructuredGate(JSON.parse(entry.gate_action)).kind;
+                }
+                catch {
+                    kind = deriveGate(entry.gate_action).gate.kind;
+                }
+                if (kind === "user")
+                    userKind.add(entry.gate_id);
+            }
+        }
+        if (entry.task_type === "gate_decision" && entry.approved === true &&
+            typeof entry.gate_id === "string") {
+            approved.add(entry.gate_id);
+        }
+    }
+    const failures = [];
+    for (const gateId of cited) {
+        if (!opened.has(gateId))
+            failures.push(`${gateId} (not_found)`);
+        else if (!userKind.has(gateId))
+            failures.push(`${gateId} (not_user_gate)`);
+        else if (!approved.has(gateId))
+            failures.push(`${gateId} (not_approved)`);
+    }
+    if (failures.length === 0)
+        return null;
+    return makeVerificationFlag({
+        severity: "error",
+        field: "evaluation",
+        check: CHECK_USER_GATE_UNRESOLVED,
+        detail: `The round cites gates without an approved human decision: ` +
+            `${failures.join("; ")}. Obtain approval via loopforge_gate_check / ` +
+            `loopforge_gate_resolve before claiming the action is done.`,
+    });
+}
+export function verifySelfEvaluation(selfEval, currentRound, vaultEntries, prevSelfEval = null, evidenceSnapshots = [],
 /** 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 = [], 
+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) {
+backtrackTargetGitHead,
+/** v3.7.1: gate records (task_type gate_opened / gate_decision) live
+ *  outside the round prefix — the caller passes them in explicitly. */
+gateEntries = []) {
     const flags = [];
     // Collect violations from all previous vault entries for duplicate-discovery
     // and other checks that need deeper history.
@@ -1278,7 +1016,18 @@ backtrackTargetGitHead) {
     // 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 activeContract = deriveActiveRoundContract(contractRoundEvaluations(committedRoundsFromEntries(vaultEntries, currentRound)));
+    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,
+        rounds: committedRounds,
+        currentRound,
+        currentReport: selfEval.execution_report ?? null,
+        currentObservations: evidenceSnapshots,
+        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, evidenceSnapshots);
@@ -1308,30 +1057,24 @@ backtrackTargetGitHead) {
         // v1.18: Cross-validate agent-reported files_changed against git evidence
         () => checkEvidenceIntegrity(selfEval, evidenceSnapshots),
         () => checkRequiredCommandEvidence(selfEval, evidenceSnapshots),
-        // v2.0: Cross-validate agent-reported test_results against command output
+        // v2.0: Cross-validate agent-reported tests_reported against command output
         () => checkCommandEvidenceIntegrity(selfEval, evidenceSnapshots),
         // v3.3: Verification domain integrity — command entrypoint / test files
         // changed in the same round the command ran
         () => checkVerificationDomainIntegrity(evidenceSnapshots),
-        // v2.1: Detect intent-action drift — agent said X but did Y
-        () => checkIntentDrift(selfEval, prevSelfEval, vaultEntries),
-        // v2.2: Detect sub-goal drift — next_action doesn't align with pending sub-goals
-        () => checkSubGoalDrift(selfEval, prevSelfEval, vaultEntries, currentRound),
         // v2.13: Post-backtrack workspace restore check
-        () => checkBacktrackWorkspaceRestore(selfEval, backtrackSkippedFiles),
+        () => checkBacktrackWorkspaceRestore(selfEval, backtrackSkippedFiles, backtrackSkippedFingerprints, evidenceSnapshots),
         // v2.12: Post-backtrack git HEAD restore check
         () => checkBacktrackGitHeadRestore(evidenceSnapshots, backtrackTargetGitHead),
-        // v3.3: Round Contract checks. v3.4: split by target — structural
-        // (warn) at proposal declaration, conformance against the derived
-        // ACTIVE contract (scope_drift warn / premature_boundary error).
-        // v3.5: + completion machine-backing (error) and premature-replacement
-        // visibility (warn).
-        () => checkRoundUnderspecified(selfEval),
-        () => checkRoundUnverifiable(selfEval),
+        // 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, evidenceSnapshots),
-        () => checkPrematureBoundary(activeContract, selfEval, claimView),
-        () => checkContractCompletionUnverified(activeContract, selfEval, evidenceSnapshots),
-        () => checkContractPremature(activeContract, selfEval),
+        () => checkContractItemsUnverified(contractStatuses),
+        () => checkContractPremature(activeContract, contractStatuses, selfEval),
+        // v3.7.1: opt-in gate-layer blocking (skipped when disabled)
+        () => checkUserGateUnresolved(selfEval, gateEntries),
     ];
     for (const run of checks) {
         const result = run();
@@ -1353,6 +1096,14 @@ backtrackTargetGitHead) {
     else {
         verdict = "trusted";
     }
-    return makeVerificationResult({ verdict, flags });
+    // v3.8.1: the machine-backed-success fact rides along with the result —
+    // ONE derivation (`deriveEvidenceStatus`), so the progress evaluator reads
+    // the same fact instead of inventing a second one. A round the machine
+    // verified is the loop FINISHING; a motion window says nothing about it,
+    // and the old self-reported `>= 0.95` guard said it with the agent's own
+    // number.
+    const machineBackedSuccess = effectiveSuccess(selfEval) &&
+        deriveEvidenceStatus(selfEval, evidenceSnapshots).providerStatus === "verified";
+    return makeVerificationResult({ verdict, flags, machineBackedSuccess });
 }
 //# sourceMappingURL=verification-gate.js.map