loopforge 3.2.1 → 3.7.0

package/dist/enforcement-gate.js

@@ -17,35 +17,22 @@
  *              with stopReason "enforcement_terminated".
  */
 import { makeEnforcementResult } from "./protocol.js";
-import { entryRound, machineProgressSeries, CHECK_SUCCESS_WITH_REMAINING_CRITERIA, CHECK_RECURRING_VIOLATION, CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE, CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED, CHECK_REQUIRED_COMMAND_FAILED, CHECK_COMMAND_EVIDENCE_MISMATCH, CHECK_OUTCOME_SUCCESS_CONTRADICTION } from "./verification-gate.js";
-import { effectiveSuccess } from "./self-eval.js";
+import { machineProgressSeries, CHECK_SUCCESS_WITH_REMAINING_CRITERIA, CHECK_RECURRING_VIOLATION, CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE, CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED, CHECK_REQUIRED_COMMAND_FAILED, CHECK_COMMAND_EVIDENCE_MISMATCH, CHECK_OUTCOME_SUCCESS_CONTRADICTION, CHECK_VERIFICATION_ENTRYPOINT_MODIFIED, CHECK_PREMATURE_BOUNDARY, CHECK_ROUND_SCOPE_DRIFT, CHECK_CONTRACT_COMPLETION_UNVERIFIED } from "./verification-gate.js";
 import { deriveConstraintId, deriveCriterionId, deriveSubGoalId } from "./loop-compiler.js";
 import { getPolicy } from "./policy.js";
-import { STABLE_ID_RE, isRecord } from "./token-utils.js";
-import { isProcessResult } from "./round-transaction.js";
+import { STABLE_ID_RE, isRecord, entryRound, extractFilePathTokens } from "./token-utils.js";
+import { committedRoundsFromEntries, decodeCommittedRound, machineEvidenceForRound, } from "./committed-round.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
-/** Extract progress_estimate from a vault entry's execution_evidence.
- *  Returns null if no execution evidence is available. */
-function entryProgress(entry) {
-    const evidence = entry.execution_evidence;
-    if (!evidence)
-        return null;
-    const pe = evidence.progress_estimate;
-    return typeof pe === "number" ? pe : null;
-}
 /** Collect progress estimates from vault entries into a round→estimate map.
- *  Shared by R4 (progress_stall) and R5 (progress_stall_terminal). */
+ *  Shared by the progress evaluator's stall and flatline tiers. */
 function collectProgressByRound(vaultEntries, currentRound) {
     const progressByRound = new Map();
-    for (const entry of vaultEntries) {
-        const rnd = entryRound(entry);
-        if (rnd < 1 || rnd >= currentRound)
-            continue;
-        const pe = entryProgress(entry);
-        if (pe !== null)
-            progressByRound.set(rnd, pe);
+    for (const round of committedRoundsFromEntries(vaultEntries, currentRound)) {
+        const progress = round.executionEvidence?.progress_estimate;
+        if (typeof progress === "number")
+            progressByRound.set(round.round, progress);
     }
     return progressByRound;
 }
@@ -73,13 +60,7 @@ function progressWindow(vaultEntries, currentRound, selfEval) {
  *  decision under loop_lineage.round_transaction; lineage entries carry
  *  nothing at the top level. */
 function committedRoundResult(entry) {
-    const lineage = isRecord(entry.loop_lineage) ? entry.loop_lineage : null;
-    const rt = lineage && isRecord(lineage.round_transaction)
-        ? lineage.round_transaction
-        : null;
-    if (!rt)
-        return null;
-    return isProcessResult(rt.result) ? rt.result : null;
+    return decodeCommittedRound(entry)?.result ?? null;
 }
 /** True when a backtrack already committed at or after the current round —
  *  i.e. the loop is re-walking territory the system already rolled back
@@ -91,7 +72,7 @@ function hasCommittedBacktrack(vaultEntries, currentRound) {
         return committedRoundResult(entry)?.action === "backtrack";
     });
 }
-/** Check whether a vault entry represents a "clean" round that can serve
+/** Check whether a committed round represents a clean restore point.
  *  as a safe restore point. A clean round was accepted (not rejected)
  *  and had no error-level verification flags.
  *
@@ -101,61 +82,30 @@ function hasCommittedBacktrack(vaultEntries, currentRound) {
  *  valid backtrack target (the most common backtrack trigger is exactly a
  *  run of such rounds). Rejected/terminated rounds never commit, and
  *  rolled-back rounds are excluded below. */
-function isCleanRound(entry) {
-    const committed = committedRoundResult(entry);
-    // A rolled-back round (already backtracked) is not a valid restore point.
-    if (committed?.action === "backtrack")
-        return false;
-    // Rejected/terminated rounds are not clean. (They never commit in the
-    // real vault — this guards legacy or mixed-shape data.)
-    if (committed && (committed.action === "reject" || committed.action === "terminate")) {
-        return false;
-    }
-    // Rounds with error-level verification flags are not clean
-    const flags = Array.isArray(entry.verification_flags)
-        ? entry.verification_flags
-        : committed?.verificationFlags ?? [];
-    for (const f of flags) {
-        if (f !== null && typeof f === "object" &&
-            f.severity === "error")
-            return false;
-    }
-    return true;
+function isCleanRound(round) {
+    return !round.verificationFlags.some((flag) => flag.severity === "error");
 }
 /** Scan backwards from currentRound to find the most recent clean round.
  *  Collects discovered_constraints from skipped rounds along the way.
  *  Returns null when no clean round is found within maxDepth. */
 export function findSafeRestorePoint(currentRound, vaultEntries, maxDepth) {
-    // v3.2.1: exclude compile-time lineage entries — every committed round
-    // writes one (engine.ts hardcodes `success: true` on it, and it carries no
-    // round_transaction), and it precedes the feedback entry in the flat view.
-    // Treating it as a decision made every round look clean, so the restore
-    // point was always currentRound-1: dirty/rejected rounds were never
-    // skipped, depth > 1 never collected skippedDiscoveries, and the restore
-    // prompt's file list (round-coordinator) was always empty.
-    const completed = vaultEntries
-        .filter((e) => {
-        const rnd = entryRound(e);
-        return rnd >= 1 && rnd < currentRound && e.task_type !== "loop_lineage";
-    })
-        .sort((a, b) => entryRound(b) - entryRound(a)); // newest first
+    const completed = committedRoundsFromEntries(vaultEntries, currentRound)
+        .sort((a, b) => b.round - a.round);
     const skippedDiscoveries = [];
     for (let depth = 1; depth <= maxDepth; depth++) {
         const targetRound = currentRound - depth;
         if (targetRound < 1)
             break;
-        const entry = completed.find((e) => entryRound(e) === targetRound);
-        if (!entry)
+        const round = completed.find((item) => item.round === targetRound);
+        if (!round)
             continue;
         // Collect discoveries from rounds we're about to skip (depth > 1)
         if (depth > 1) {
             for (let d = 1; d < depth; d++) {
                 const skippedRound = currentRound - d;
-                const skippedEntry = completed.find((e) => entryRound(e) === skippedRound);
-                if (skippedEntry) {
-                    const discovered = Array.isArray(skippedEntry.discovered_constraints)
-                        ? skippedEntry.discovered_constraints.filter((v) => typeof v === "string")
-                        : [];
+                const skippedEntry = completed.find((item) => item.round === skippedRound);
+                if (skippedEntry?.evaluation) {
+                    const discovered = skippedEntry.evaluation.discovered_constraints ?? [];
                     for (const item of discovered) {
                         if (!skippedDiscoveries.includes(item))
                             skippedDiscoveries.push(item);
@@ -163,7 +113,7 @@ export function findSafeRestorePoint(currentRound, vaultEntries, maxDepth) {
                 }
             }
         }
-        if (isCleanRound(entry)) {
+        if (isCleanRound(round)) {
             return { round: targetRound, skippedDiscoveries };
         }
     }
@@ -174,23 +124,11 @@ export function findSafeRestorePoint(currentRound, vaultEntries, maxDepth) {
  *  evidence as fallback). Returns null when the round has no git snapshot
  *  or no committed feedback entry. */
 export function findBacktrackTargetGitHead(restoreRound, vaultEntries) {
-    const feedback = vaultEntries.find((entry) => String(entry.task_id ?? "") === `loop:${entry.loop_id}:r${restoreRound}:feedback`);
-    const lineage = feedback && isRecord(feedback.loop_lineage)
-        ? feedback.loop_lineage
-        : null;
-    const transaction = lineage && isRecord(lineage.round_transaction)
-        ? lineage.round_transaction
-        : null;
-    const snapshot = transaction && isRecord(transaction.snapshot)
-        ? transaction.snapshot
-        : null;
-    if (!snapshot)
+    const committed = committedRoundsFromEntries(vaultEntries)
+        .find((view) => view.round === restoreRound);
+    if (!committed)
         return null;
-    const evidence = Array.isArray(snapshot.afterEvidence) && snapshot.afterEvidence.length > 0
-        ? snapshot.afterEvidence
-        : Array.isArray(snapshot.beforeEvidence)
-            ? snapshot.beforeEvidence
-            : [];
+    const evidence = machineEvidenceForRound(committed);
     for (const item of evidence) {
         if (!isRecord(item) || item.provider !== "git" || !isRecord(item.data))
             continue;
@@ -217,14 +155,15 @@ gitHead) {
         "",
     ];
     // ── Why This Happened ────────────────────────────────────────────────
+    // v3.7: stall and flatline are one evaluator emitting progress_stall; the
+    // former flatline-specific wording ("zero forward motion → radically
+    // different strategy") is folded into the single section — the disposition
+    // tier still distinguishes the enforcement reason itself.
     if (triggerRule === "progress_stall") {
-        lines.push("### Why This Happened", "", `Progress stalled over rounds ${toRound + 1}–${fromRound}. ` +
-            `The work done in those rounds produced no verifiable progress — ` +
-            `no new files changed, no criteria met.`, "", "The approach used in those rounds **did not work**. It should not be repeated.", "");
-    }
-    else if (triggerRule === "progress_stall_terminal") {
-        lines.push("### Why This Happened", "", `Progress was completely flat for multiple rounds leading up to Round ${fromRound}. ` +
-            `The agent made **zero forward motion** — the task is not advancing.`, "", "A **radically different** strategy is needed. The previous approach produced nothing.", "");
+        lines.push("### Why This Happened", "", `Progress stalled over rounds ${toRound + 1}–${fromRound}: the work ` +
+            `produced no verifiable forward motion — no new files changed, no ` +
+            `criteria met, no progress estimates moving.`, "", "The approach used in those rounds **did not work**. It should not be " +
+            "repeated — a **radically different** strategy is needed.", "");
     }
     // ── v2.13: Workspace Restore ──────────────────────────────────────────
     lines.push("### ⚠️ Workspace Restore Required", "", `Your working directory still contains changes from the **failed** ` +
@@ -241,7 +180,10 @@ gitHead) {
         }
         lines.push("");
     }
-    lines.push("**To restore a clean workspace, run:**", "", "```bash", "# Option A: Discard all uncommitted changes (recommended)", "git checkout -- .", "git clean -fd", "", "# Option B: If you have unrelated work to keep", `git stash push -m "backtrack-safety-net-round-${fromRound}"`, "git checkout -- .", "git clean -fd", "```", "");
+    lines.push("**To restore a clean workspace, run:**", "", "```bash", "# Option A: Keep everything as a safety net (recommended) — reversible", `git stash push -u -m "backtrack-safety-net-round-${fromRound}"`, "", "# Option B: Discard ALL uncommitted AND untracked changes (permanent)", "git checkout -- .", "git clean -fd", "```", "", "> Option A is a safety net — do NOT `git stash pop` before submitting " +
+        "the next round: the skipped work would look unrestored and be rejected. " +
+        "Restore only files you own after the next round commits, via " +
+        "`git checkout stash@{0} -- <path>`.", "");
     // v2.12: Restore to the exact commit observed at the clean round.
     if (gitHead) {
         lines.push(`**Restore to commit \`${gitHead.slice(0, 12)}\`** — the verification ` +
@@ -255,7 +197,16 @@ gitHead) {
         "> with unrestored files will be **rejected**.", "");
     // ── What Must Change ──────────────────────────────────────────────────
     lines.push("### What Must Change", "", "- Do **NOT** repeat the approach used in the skipped rounds.", "- Try a **different** task decomposition or technique.", "- If the current sub-goal is stuck, consider canceling it " +
-        "(`canceled_subtasks`) and working on a different one.", "- Use the `prompt_requests.confusion_points` field in your self-evaluation " +
+        "(`canceled_subtasks`) and working on a different one.", 
+    // v3.5: the restored Current Task may be the very Round Contract that
+    // stalled — the agent must be told the sanctioned way to revise it
+    // (outcome=blocked closes the active contract; the revised proposal in
+    // the same submission becomes active next round). Without this the
+    // agent's revision would be silently ignored as premature.
+    "- If the restored Current Task is a Round Contract that caused the stall: " +
+        "close it in this submission with `outcome=\"blocked\"` (+ a blocker " +
+        "explaining why it stalled) and declare the REVISED contract in the " +
+        "same submission. Do **NOT** silently restate the stalled contract.", "- Use the `prompt_requests.confusion_points` field in your self-evaluation " +
         "to flag anything you don't understand about the task or the blockage.", "");
     // ── Preserved Discoveries ─────────────────────────────────────────────
     if (skippedDiscoveries.length > 0) {
@@ -333,53 +284,34 @@ function enforceEvidenceContradiction(flags) {
         check: contradiction.check,
     });
 }
-/** R3: Agent claims success but did nothing verifiable.
- *  v1.17: execution_evidence is now MANDATORY for structured self-evaluations.
- *  Missing evidence when success=true → reject (agent must provide evidence).
- *  Empty evidence (no files + no tests) when success=true → reject. */
-function enforceEmptySuccess(selfEval, _flags, skipEvidenceRules = false) {
-    if (skipEvidenceRules)
-        return null; // Requires execution_evidence
-    if (!effectiveSuccess(selfEval))
-        return null;
-    const ev = selfEval.execution_evidence;
-    // v1.17: Missing evidence when claiming success → reject.
-    // The agent MUST provide execution_evidence to back up a success claim.
-    if (!ev) {
-        return makeEnforcementResult({
-            action: "reject",
-            reason: "Agent claims success but provided no execution_evidence. " +
-                "Every successful round MUST include execution_evidence with " +
-                "files_changed, test_results, and progress_estimate.",
-            fix_instructions: "You must provide execution_evidence in your self-evaluation: " +
-                "(a) list the files you changed in execution_evidence.files_changed, " +
-                "(b) run tests and report results in execution_evidence.test_results, " +
-                "(c) estimate your progress in execution_evidence.progress_estimate. " +
-                "If you genuinely completed the task without file changes or tests, " +
-                "explain why in detail in your output_summary.",
-            check: "empty_success",
-        });
-    }
-    const filesEmpty = ev.files_changed.length === 0;
-    const testsNotRun = ev.test_results === null;
-    if (!filesEmpty || !testsNotRun)
+/** v3.3: R-EVID-VERIFY — the verification command's entrypoint changed in
+ *  the same round the command ran. The runtime executed a script the agent
+ *  just rewrote, so the "machine observation" has no stable baseline and
+ *  cannot back the success claim. Reject so the agent resubmits the SAME
+ *  round with the entrypoint unchanged (a freshly created entrypoint passes
+ *  on the redo — the diff no longer contains it). */
+function enforceVerificationEntrypointTampered(flags) {
+    const flag = flags.find((f) => f.check === CHECK_VERIFICATION_ENTRYPOINT_MODIFIED && f.severity === "error");
+    if (!flag)
         return null;
     return makeEnforcementResult({
         action: "reject",
-        reason: "Agent claims success but execution_evidence shows no files changed " +
-            "and no tests were run. There is no verifiable evidence of work.",
-        fix_instructions: "You must provide verifiable evidence: " +
-            "(a) list the files you changed in execution_evidence.files_changed, " +
-            "and (b) run tests and report results in execution_evidence.test_results. " +
-            "If you genuinely completed the task without file changes or tests, " +
-            "explain why in detail in your output_summary.",
-        check: "empty_success",
+        reason: flag.detail,
+        fix_instructions: "The verification command entrypoint changed in this round, so its " +
+            "result cannot be trusted as machine evidence. You must: (a) keep the " +
+            "verification command (and its entrypoint files) stable, (b) resubmit " +
+            "your SelfEvaluation for the SAME round with the entrypoint unchanged " +
+            "so the runtime can re-run it against a stable baseline, and (c) do " +
+            "NOT rewrite the verification script to make it pass.",
+        check: "verification_entrypoint_modified",
     });
 }
-/** R8 (v2.12): Success claimed without any machine-verifiable evidence.
- *  The verification gate produced success_without_verified_evidence (error):
- *  zero verified claims, no test results. First occurrence → reject with
- *  concrete evidence requirements; second consecutive → terminate. */
+/** R8 (v2.12/v3.7): The single success-evidence row. The verification gate
+ *  produced success_without_verified_evidence (error) — either the empty/
+ *  missing-evidence arm (v3.7: the ex-R3 empty_success posture moved into
+ *  checkSuccessWithoutVerifiedEvidence) or the claims arm (zero verified
+ *  claims). First occurrence → reject with concrete evidence requirements;
+ *  second consecutive → terminate. */
 function enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections) {
     const flag = flags.find((f) => f.check === CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE && f.severity === "error");
     if (!flag)
@@ -407,6 +339,131 @@ function enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections) {
         check: "success_without_verified_evidence",
     });
 }
+/** R-C1 (v3.3): Round Contract boundary claimed prematurely. The gate
+ *  produced premature_boundary (error): success claimed while done_when
+ *  items were claimed met without machine-verified evidence or silently
+ *  dropped. First occurrence → reject with contract-specific fix
+ *  instructions; second consecutive → terminate (R8 ladder). */
+function enforcePrematureBoundary(flags, consecutiveRejections) {
+    const flag = flags.find((f) => f.check === CHECK_PREMATURE_BOUNDARY && f.severity === "error");
+    if (!flag)
+        return null;
+    if (consecutiveRejections >= 2) {
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: "Repeated premature Round Contract boundary claims — done_when items " +
+                "claimed without machine evidence or dropped while success is claimed.",
+            check: "premature_boundary",
+        });
+    }
+    const escalation = getPolicy().engine.enforcement_escalation_enabled &&
+        consecutiveRejections >= 1
+        ? buildEscalationNotice()
+        : "";
+    return makeEnforcementResult({
+        action: "reject",
+        reason: flag.detail,
+        fix_instructions: "You claimed success under a Round Contract but done_when items are " +
+            "unfinished or unverified. You must: (a) run the contract's " +
+            "verification_plan commands (configured in loop_policy.json " +
+            "evidence.commands) and report their actual output, listing satisfied " +
+            "done_when items in success_criteria_met; or (b) set success=false and " +
+            "list what remains in success_criteria_remaining. " +
+            "Do NOT claim contract completion without machine evidence " +
+            "(no_change_reason does not apply to contract claims)." + escalation,
+        check: "premature_boundary",
+    });
+}
+/** v3.5: Round Contract completion claimed without its verification_plan
+ *  commands passing this round. The gate produced
+ *  contract_completion_unverified (error): the eval's met claims satisfy
+ *  every done_when of the ACTIVE contract, but the machine never observed
+ *  the plan's commands pass. Closing a contract is a success-class claim —
+ *  first occurrence → reject with fix instructions; second consecutive →
+ *  terminate (R-C1's ladder). Registered BEFORE R-C1: the completion-truth
+ *  question outranks boundary nuance. */
+function enforceContractCompletionUnverified(flags, consecutiveRejections) {
+    const flag = flags.find((f) => f.check === CHECK_CONTRACT_COMPLETION_UNVERIFIED && f.severity === "error");
+    if (!flag)
+        return null;
+    if (consecutiveRejections >= 2) {
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: "Repeated unverified Round Contract completion claims — done_when items " +
+                "claimed complete while the verification_plan commands never passed.",
+            check: "contract_completion_unverified",
+        });
+    }
+    const escalation = getPolicy().engine.enforcement_escalation_enabled &&
+        consecutiveRejections >= 1
+        ? buildEscalationNotice()
+        : "";
+    return makeEnforcementResult({
+        action: "reject",
+        reason: flag.detail,
+        fix_instructions: "You claimed completion under the ACTIVE Round Contract, but its " +
+            "verification_plan commands did not pass this round. You must: (a) fix " +
+            "the underlying failure, re-run the contract's verification_plan " +
+            "commands (configured in loop_policy.json evidence.commands), and list " +
+            "satisfied done_when items in success_criteria_met; or (b) set " +
+            "success=false and list what remains in success_criteria_remaining. " +
+            "Completion claims are never accepted without machine verification — " +
+            "do NOT use no_change_reason for completion claims." + escalation,
+        check: "contract_completion_unverified",
+    });
+}
+/** R-C2 (v3.3): Round Contract scope drift. The gate produced
+ *  round_scope_drift (warn): files changed outside the contract's declared
+ *  scope. A substantive drift_clarification (≥ 20 chars with real anchors —
+ *  the out-of-scope file paths count) accepts the legitimately expanded
+ *  scope; no/weak clarification rejects; repeated unclarified drift
+ *  terminates. Mirrors R8's ladder, not R7's streak counter — no new
+ *  session state. */
+function enforceScopeDrift(flags, selfEval, consecutiveRejections, vaultEntries = []) {
+    const flag = flags.find((f) => f.check === CHECK_ROUND_SCOPE_DRIFT);
+    if (!flag)
+        return null;
+    const clarification = selfEval.drift_clarification?.trim();
+    const hasAnchor = clarification
+        ? clarificationIsSubstantive(clarification, selfEval, vaultEntries)
+        : false;
+    const isSubstantive = clarification !== undefined
+        && clarification.length >= 20
+        && hasAnchor;
+    if (isSubstantive) {
+        // Genuine scope expansion with concrete file references → accept.
+        return makeEnforcementResult({
+            action: "accept",
+            reason: "",
+            fix_instructions: "",
+            check: "round_scope_drift",
+            clarification_accepted: true,
+        });
+    }
+    if (consecutiveRejections >= 2) {
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: `Repeated scope drift without substantive drift_clarification — ` +
+                `the agent keeps changing files outside its declared contract scope.`,
+            check: "round_scope_drift",
+        });
+    }
+    const escalation = getPolicy().engine.enforcement_escalation_enabled &&
+        consecutiveRejections >= 1
+        ? buildEscalationNotice()
+        : "";
+    return makeEnforcementResult({
+        action: "reject",
+        reason: flag.detail,
+        fix_instructions: "Files changed outside the contract's declared scope. You must either: " +
+            "(a) revert the out-of-scope changes, or (b) extend the scope in your " +
+            "re-declared round_contract AND explain the pivot in drift_clarification " +
+            "with concrete file paths (≥ 20 characters, real anchors). Weak or " +
+            "missing clarifications are rejected; repeated scope drift terminates " +
+            "the loop." + escalation,
+        check: "round_scope_drift",
+    });
+}
 /** R9 (v2.12): Post-backtrack workspace not restored. The verification gate
  *  produced backtrack_workspace_not_restored (error): either skipped-round
  *  files are still dirty, or the working tree is not at the restore point's
@@ -439,237 +496,132 @@ function enforceBacktrackNotRestored(flags, vaultEntries = [], currentRound = 0)
         check: "backtrack_workspace_not_restored",
     });
 }
-/** R4: Progress has stalled for 3+ consecutive rounds.
- *  Detected by checking progress_estimate deltas across vault entries.
- *  First occurrence → REJECT (agent must change approach).
- *  Second consecutive occurrence → TERMINATE (agent cannot recover). */
-function enforceProgressStall(selfEval, _flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules = false) {
-    // Need at least 3 rounds of history
-    if (currentRound < 3)
+/** Shared observation pipeline for the progress evaluator (stall window,
+ *  flatline tier). Machine git motion is exculpatory only: it may veto a
+ *  self-reported stall but can never create one. */
+function evaluateStallWindow(tier, selfEval, currentRound, vaultEntries) {
+    const window = tier === "progress_stall"
+        ? 3
+        : Math.max(1, getPolicy().engine.stall_lookback_rounds);
+    if (currentRound < window)
         return null;
-    let isStalling = false;
-    let stallDetail = "";
-    let stallThreshold = 0;
-    if (skipEvidenceRules) {
-        // v3.2: heuristic path has no execution_evidence — fall back to machine
-        // observations: three consecutive rounds with no git change = stall.
-        // No git signal → keep the legacy skip (the machine cannot observe).
-        const machine = machineProgressSeries(vaultEntries, currentRound, 3);
-        if (machine === null)
+    const progressByRound = progressWindow(vaultEntries, currentRound, selfEval);
+    let stalled = false;
+    let detail = "";
+    const threshold = getPolicy().evolution.progress_stall_threshold;
+    if (progressByRound.size >= window) {
+        const recent = [...progressByRound.keys()].sort((a, b) => a - b).slice(-window);
+        if (recent[0] < currentRound - window)
+            return null;
+        const values = recent.map((round) => progressByRound.get(round));
+        if (values[values.length - 1] >= 0.95)
             return null;
-        isStalling = machine.every((value) => !value);
-        stallDetail = "no machine-observed changes in the last 3 rounds";
+        if (tier === "progress_stall") {
+            stalled = values.slice(1).every((value, index) => value - values[index] < threshold);
+            detail = values.map((value) => `${(value * 100).toFixed(0)}%`).join(" → ");
+        }
+        else {
+            const first = values[0];
+            stalled = values.every((value) => Math.abs(value - first) < 1e-10);
+            detail = `completely flat at ${(first * 100).toFixed(0)}%`;
+        }
     }
     else {
-        const progressByRound = progressWindow(vaultEntries, currentRound, selfEval);
-        if (progressByRound.size < 3)
-            return null;
-        const sortedRounds = [...progressByRound.keys()].sort((a, b) => a - b);
-        const last3 = sortedRounds.slice(-3);
-        // Require all three data points to be within [currentRound-3, currentRound-1].
-        // (collectProgressByRound already filters rnd < currentRound, so the upper
-        // bound is always satisfied — the lower bound is the real continuity guard.)
-        const expectedMin = currentRound - 3;
-        if (last3[0] < expectedMin)
+        const machine = machineProgressSeries(vaultEntries, currentRound, window);
+        if (machine === null)
             return null;
-        const p1 = progressByRound.get(last3[0]);
-        const p2 = progressByRound.get(last3[1]);
-        const p3 = progressByRound.get(last3[2]);
-        stallThreshold = getPolicy().evolution.progress_stall_threshold;
-        const delta12 = p2 - p1;
-        const delta23 = p3 - p2;
-        // Both deltas must be below threshold AND not near completion
-        isStalling = delta12 < stallThreshold && delta23 < stallThreshold && p3 < 0.95;
-        stallDetail = `${(p1 * 100).toFixed(0)}% → ${(p2 * 100).toFixed(0)}% → ${(p3 * 100).toFixed(0)}%`;
+        stalled = machine.every((value) => !value);
+        detail = tier === "progress_stall"
+            ? `no machine-observed changes in the last ${window} rounds`
+            : `no machine-observed changes for ${window} consecutive rounds`;
     }
-    if (!isStalling)
+    if (!stalled)
         return null;
+    const machine = machineProgressSeries(vaultEntries, currentRound, window);
+    if (machine?.some(Boolean))
+        return null;
+    if (machine !== null) {
+        detail += ` — no machine-observed git motion in rounds ${currentRound - window}–${currentRound - 1}`;
+    }
+    return { tier, detail, window, threshold };
+}
+/** Shared progress escalation and backtrack deadlock guard (v3.7: one
+ * evaluator). The flatline tier keeps its steeper threshold-0 ladder while
+ * using the same mechanics — the tier is an internal diagnostic only. */
+function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections) {
+    const { tier, detail, window, threshold } = verdict;
+    const flatline = tier === "progress_flatline";
     const escalation = getPolicy().engine.enforcement_escalation_enabled;
-    // v2.7: When escalation is enabled, give one extra rejection round with a
-    // "Seek Human Guidance" notice before terminating. This lets the agent
-    // course-correct with human input rather than being killed immediately.
-    if (consecutiveRejections >= 2) {
+    const stalledReason = flatline
+        ? `Progress has been ${detail} for ${window} consecutive rounds.`
+        : `Progress has stalled: ${detail} over the last ${window} rounds` +
+            `${threshold > 0 ? ` (delta < ${(threshold * 100).toFixed(0)}% each round)` : ""}.`;
+    // v3.7: both tiers emit the single progress_stall check id — the tier
+    // survives only in the reason/fix wording (former progress_flatline id).
+    const check = "progress_stall";
+    if ((flatline && consecutiveRejections >= 1) || consecutiveRejections >= 2) {
         return makeEnforcementResult({
             action: "terminate",
-            reason: `Progress stalled for 3+ rounds ` +
-                `(${stallDetail}) ` +
-                `and agent did not resolve after escalation. Terminating loop.`,
-            check: "progress_stall",
+            reason: `${stalledReason} The stall persisted after escalation. Terminating loop.`,
+            check,
         });
     }
-    if (consecutiveRejections >= 1 && escalation) {
-        // v2.10: When backtrack is enabled, escalate to backtrack instead of
-        // reject. The agent is rolled back to the last clean round with lessons
-        // injected, rather than redoing the same round with an escalation notice.
-        if (getPolicy().engine.backtrack_enabled) {
-            // v2.14: A backtrack that already committed for this round (the loop
-            // is re-walking rolled-back territory with the same stall) must not
-            // loop forever — terminate instead. Without this, consecutive
-            // rejections reset on every backtrack and the R4 cycle has no exit.
-            if (hasCommittedBacktrack(vaultEntries, currentRound)) {
-                return makeEnforcementResult({
-                    action: "terminate",
-                    reason: `Progress has stalled over the last 3 rounds ` +
-                        `(${stallDetail}) and a backtrack already fired for ` +
-                        `this round. The stall persists after rollback — terminating.`,
-                    check: "progress_stall",
-                });
-            }
+    if (consecutiveRejections >= 1 && !escalation) {
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: `${stalledReason} The stall persisted after the previous rejection. Terminating loop.`,
+            check,
+        });
+    }
+    const escalated = flatline ? escalation : consecutiveRejections >= 1 && escalation;
+    if (escalated && getPolicy().engine.backtrack_enabled) {
+        if (hasCommittedBacktrack(vaultEntries, currentRound)) {
             return makeEnforcementResult({
-                action: "backtrack",
-                reason: `Progress has stalled: ${stallDetail} over the last 3 rounds` +
-                    `${stallThreshold > 0 ? ` (delta < ${(stallThreshold * 100).toFixed(0)}% each round)` : ""}.`,
-                fix_instructions: "Your progress has been flat for 3 rounds. You are being rolled back " +
-                    "to the last clean round. Do NOT repeat the approach that led to the stall. " +
-                    "Choose a different technique or task decomposition.",
-                check: "progress_stall",
+                action: "terminate",
+                reason: `${stalledReason} A backtrack already fired for this round; the stall persists after rollback.`,
+                check,
             });
         }
         return makeEnforcementResult({
-            action: "reject",
-            reason: `Progress has stalled: ${stallDetail} over the last 3 rounds` +
-                `${stallThreshold > 0 ? ` (delta < ${(stallThreshold * 100).toFixed(0)}% each round)` : ""}.`,
-            fix_instructions: "Your progress has been flat for 3 rounds. You must: " +
-                "(a) explain what is blocking progress, " +
-                "(b) propose a DIFFERENT technique or task decomposition, and " +
-                "(c) set a concrete, verifiable goal for the redo of this round. " +
-                "Do NOT repeat the same approach — it has not moved progress forward." +
-                buildEscalationNotice(),
-            check: "progress_stall",
+            action: "backtrack",
+            reason: stalledReason,
+            fix_instructions: flatline
+                ? "Progress is exactly flat. After rollback, choose a radically different approach."
+                : "After rollback, do not repeat the stalled approach; choose a different technique or task decomposition.",
+            check,
         });
     }
-    if (consecutiveRejections >= 1) {
+    if (flatline && !escalation) {
         return makeEnforcementResult({
             action: "terminate",
-            reason: `Progress stalled for 3+ rounds ` +
-                `(${stallDetail}) ` +
-                `and agent did not resolve after previous rejection. Terminating loop.`,
-            check: "progress_stall",
+            reason: `${stalledReason} The agent is making zero forward motion and cannot recover.`,
+            check,
         });
     }
     return makeEnforcementResult({
         action: "reject",
-        reason: `Progress has stalled: ${stallDetail} over the last 3 rounds` +
-            `${stallThreshold > 0 ? ` (delta < ${(stallThreshold * 100).toFixed(0)}% each round)` : ""}.`,
-        fix_instructions: "Your progress has been flat for 3 rounds. You must: " +
-            "(a) explain what is blocking progress, " +
-            "(b) propose a DIFFERENT technique or task decomposition, and " +
-            "(c) set a concrete, verifiable goal for the redo of this round. " +
-            "Do NOT repeat the same approach — it has not moved progress forward.",
-        check: "progress_stall",
+        reason: stalledReason,
+        fix_instructions: (flatline
+            ? "Explain the fundamental blocker, choose a radically different approach, and set a concrete verifiable goal."
+            : "Explain the blocker, choose a different technique or task decomposition, and set a concrete verifiable goal for this retry.") +
+            (escalated ? buildEscalationNotice() : ""),
+        check,
     });
 }
-/** R5: Progress completely stalled (delta = 0) for N consecutive rounds.
- *  Stricter than R4 (which triggers on delta < 5%). R4 gives the agent a chance
- *  to change approach via reject; this rule fires when progress has been exactly
- *  flat — the agent is making zero forward motion.
- *
- *  v2.7: When enforcement_escalation_enabled is true, the first occurrence
- *  issues a rejection with an escalation notice instead of terminating.
- *  Termination only happens on the second consecutive flatline detection.
- *
- *  Uses the engine.max_circuit_breaker policy value as the lookback window. */
-function enforceProgressStallTerminal(selfEval, _flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules = false) {
-    const breakerSize = getPolicy().engine.max_circuit_breaker;
-    if (currentRound < breakerSize || vaultEntries.length < breakerSize)
-        return null;
-    let allFlat = false;
-    let flatDetail = "";
-    if (skipEvidenceRules) {
-        // v3.2: heuristic path has no execution_evidence — fall back to machine
-        // observations: N consecutive rounds with no git change = flatline.
-        // No git signal → keep the legacy skip (the machine cannot observe).
-        const machine = machineProgressSeries(vaultEntries, currentRound, breakerSize);
-        if (machine === null)
-            return null;
-        allFlat = machine.every((value) => !value);
-        flatDetail = `no machine-observed changes for ${breakerSize} consecutive rounds`;
-    }
-    else {
-        const progressByRound = progressWindow(vaultEntries, currentRound, selfEval);
-        if (progressByRound.size < breakerSize)
-            return null;
-        const sortedRounds = [...progressByRound.keys()].sort((a, b) => a - b);
-        const recent = sortedRounds.slice(-breakerSize);
-        // v2.14: continuity guard (mirrors R4) — "consecutive" means the most
-        // recent rounds. Rounds without execution_evidence are unknown motion,
-        // not zero motion; taking "the last N rounds that happened to report
-        // progress" terminated loops whose recent rounds simply had no data.
-        if (recent[0] < currentRound - breakerSize)
-            return null;
-        // Check that progress values are ALL identical (delta = 0).
-        // Use epsilon comparison — JSON round-trips can produce float drift
-        // (e.g. 0.3 vs 0.30000000000000004) that would defeat strict === .
-        const EPSILON = 1e-10;
-        const first = progressByRound.get(recent[0]);
-        allFlat = recent.every((r) => Math.abs((progressByRound.get(r) ?? 0) - first) < EPSILON);
-        if (!allFlat || first >= 0.95)
-            return null;
-        flatDetail = `completely flat at ${(first * 100).toFixed(0)}%`;
-    }
-    if (!allFlat)
-        return null;
-    const escalation = getPolicy().engine.enforcement_escalation_enabled;
-    // v2.7: When escalation is enabled, give one rejection round with a
-    // "Seek Human Guidance" notice before terminating.
-    if (consecutiveRejections >= 1) {
-        return makeEnforcementResult({
-            action: "terminate",
-            reason: `Progress has been ${flatDetail} ` +
-                `for ${breakerSize} consecutive rounds and agent did not resolve ` +
-                `after escalation. The agent is making zero forward motion.`,
-            check: "progress_stall_terminal",
-        });
-    }
-    if (escalation) {
-        // v2.10: When backtrack is enabled, escalate to backtrack instead of
-        // reject. The agent is rolled back to the last clean round with a
-        // "radically different strategy" lesson injected.
-        if (getPolicy().engine.backtrack_enabled) {
-            // v2.14: Same deadlock guard as R4 — a backtrack that already fired
-            // for this round means the loop is re-walking rolled-back territory.
-            if (hasCommittedBacktrack(vaultEntries, currentRound)) {
-                return makeEnforcementResult({
-                    action: "terminate",
-                    reason: `Progress has been ${flatDetail} ` +
-                        `for ${breakerSize} consecutive rounds and a backtrack already ` +
-                        `fired for this round. Flatline persists after rollback — ` +
-                        `terminating the loop.`,
-                    check: "progress_stall_terminal",
-                });
-            }
-            return makeEnforcementResult({
-                action: "backtrack",
-                reason: `Progress has been ${flatDetail} ` +
-                    `for ${breakerSize} consecutive rounds. The agent is making zero ` +
-                    `forward motion.`,
-                fix_instructions: "Your progress has been exactly flat — zero forward motion. " +
-                    "You are being rolled back to the last clean round. " +
-                    "Choose a RADICALLY different approach. The previous one produced nothing.",
-                check: "progress_stall_terminal",
-            });
-        }
-        return makeEnforcementResult({
-            action: "reject",
-            reason: `Progress has been ${flatDetail} ` +
-                `for ${breakerSize} consecutive rounds. The agent is making zero ` +
-                `forward motion.`,
-            fix_instructions: "Your progress has been exactly flat — you are making zero forward " +
-                "motion. You must: (a) explain what is fundamentally blocking you, " +
-                "(b) propose a radically different approach, and " +
-                "(c) set a concrete verifiable goal. " +
-                "Do NOT resubmit the same output." +
-                buildEscalationNotice(),
-            check: "progress_stall_terminal",
-        });
-    }
-    return makeEnforcementResult({
-        action: "terminate",
-        reason: `Progress has been ${flatDetail} ` +
-            `for ${breakerSize} consecutive rounds. The agent is making zero ` +
-            `forward motion and cannot recover.`,
-        check: "progress_stall_terminal",
-    });
+/** v3.7: The single progress evaluator (former R4 stall and R5 flatline rows
+ *  merged into one). The stall-tier window is consulted first — under the
+ *  default positive threshold its predicate covers exactly-flat runs too,
+ *  reproducing the v3.6 R4-before-R5 shadowing; the flatline tier is
+ *  consulted only when the stall predicate cannot hold (threshold ≤ 0,
+ *  shorter lookback configs), where it applies its steeper disposition
+ *  ladder. Machine git motion is exculpatory only — it may veto a
+ *  self-reported stall but can never create one. */
+function enforceProgressStall(selfEval, _flags, currentRound, vaultEntries, consecutiveRejections) {
+    const verdict = evaluateStallWindow("progress_stall", selfEval, currentRound, vaultEntries)
+        ?? evaluateStallWindow("progress_flatline", selfEval, currentRound, vaultEntries);
+    return verdict
+        ? resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections)
+        : null;
 }
 /** R6: Two consecutive rejections → escalate (v2.7) or terminate.
  *
@@ -725,8 +677,8 @@ function extractAnchors(clarification) {
     for (const match of clarification.matchAll(/[c]r?-[a-f0-9]{8}|sg-[a-f0-9]{8}/gi)) {
         anchors.add(match[0].toLowerCase());
     }
-    for (const match of clarification.matchAll(/[\w./-]+\.[a-z]{2,6}\b/gi)) {
-        anchors.add(match[0]);
+    for (const path of extractFilePathTokens(clarification)) {
+        anchors.add(path);
     }
     return [...anchors];
 }
@@ -969,13 +921,38 @@ function buildDiagnosticGap(flags) {
     lines.push("");
     return lines.join("\n");
 }
+const RULE_TABLE = [
+    // R1/R2 join the contradiction umbrella per the documented four-class model
+    // (AGENTS/README/CHANGELOG): a row's category is its enforcement action
+    // class, NOT the trigger check's gate domain — claim-vs-self-reported-facts
+    // rows (outcome_success_contradiction included) belong to this class too.
+    { category: "evidence_contradiction", checks: ["success_with_remaining_criteria"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
+    { category: "evidence_contradiction", checks: ["recurring_violation"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
+    { category: "evidence_contradiction", checks: ["required_command_failed", "command_evidence_mismatch", "outcome_success_contradiction"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
+    { category: "evidence_contradiction", checks: ["verification_entrypoint_modified"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
+    { category: "contract_scope", checks: ["contract_completion_unverified"], ladder: "internal" },
+    { category: "contract_scope", checks: ["premature_boundary"], ladder: "internal" },
+    { category: "evidence_contradiction", checks: ["success_without_verified_evidence"], ladder: "internal" },
+    { category: "contract_scope", checks: ["round_scope_drift"], ladder: "internal", clarificationAllowed: true },
+    { category: "progress_recovery", checks: ["progress_stall"], ladder: "internal", backtrackAllowed: true },
+    { category: "progress_recovery", checks: ["max_rejections"], ladder: "counter" },
+    { category: "plan_drift", checks: ["intent_drift"], ladder: "internal", clarificationAllowed: true },
+    { category: "progress_recovery", checks: ["backtrack_workspace_not_restored"], ladder: "internal", backtrackAllowed: true },
+];
+const RULE_TABLE_BY_ID = new Map();
+for (const row of RULE_TABLE) {
+    for (const id of row.checks)
+        RULE_TABLE_BY_ID.set(id, row);
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // Main entry point
 // ═══════════════════════════════════════════════════════════════════════════
 /** Enforce round-boundary rules based on the verification gate's findings
  *  and the agent's self-evaluation integrity.
  *
- *  Rules run in priority order (R1 → R5). The first rule that fires wins.
+ *  Rules run in priority order — the rules array below IS the priority
+ *  order; numeric IDs (R1–R9, R-EVID) reflect insertion history, not
+ *  priority. The first rule that fires wins.
  *
  * @param selfEval              The agent's self-evaluation for the current round.
  * @param verifyResult          The verification gate's output (from verifySelfEvaluation).
@@ -984,32 +961,83 @@ function buildDiagnosticGap(flags) {
  * @param consecutiveRejections How many consecutive rounds have already been rejected.
  *                              Starts at 0; increments on each reject; resets on accept.
  */
-export function enforceRound(selfEval, verifyResult, currentRound, vaultEntries, consecutiveRejections = 0, skipEvidenceRules = false, 
+export function enforceRound(selfEval, verifyResult, currentRound, vaultEntries, consecutiveRejections = 0, 
 /** v2.12: Current clarification streak for R7 escalation. */
 driftClarificationStreak = 0) {
     const { flags } = verifyResult;
-    // Run enforcement rules in priority order.
-    // Earlier rules take higher precedence.
+    // Run enforcement rules in priority order — the array order IS the
+    // priority; the R-labels in the comments are historical (RULE_TABLE is
+    // the semantic description). The first rule that fires wins.
     const rules = [
         () => enforceSuccessWithRemainingCriteria(flags),
         () => enforceRecurringViolation(flags),
-        () => enforceEmptySuccess(selfEval, flags, skipEvidenceRules),
-        // v2.14: R-EVID — a required command failure or self-contradictory
-        // outcome claim contradicts the success claim before commit
+        // v2.14: R-EVID — a required command failure, hidden test failures, or
+        // a self-contradictory outcome claim contradicts the success claim
         () => enforceEvidenceContradiction(flags),
-        // v2.12: R8 — success with zero machine-verifiable evidence
+        // v3.3: R-EVID-VERIFY — the verification command entrypoint changed in
+        // the same round it ran. Runs before R8: when the entrypoint is tainted
+        // R8 also fires, but this reason is more specific.
+        () => enforceVerificationEntrypointTampered(flags),
+        // v3.5: contract completion claimed without its verification_plan
+        // commands passing — runs before R-C1: the completion-truth question
+        // outranks boundary nuance.
+        () => enforceContractCompletionUnverified(flags, consecutiveRejections),
+        // v3.3: R-C1 — contract boundary claimed prematurely (contract-specific
+        // wording and check counting; runs before R8 so contract rounds get the
+        // contract's own reason.)
+        () => enforcePrematureBoundary(flags, consecutiveRejections),
+        // v2.12/v3.7: R8 — the single success-evidence row (empty/missing-evidence
+        // arm merged from the former R3 empty_success posture + claims arm)
         () => enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections),
-        () => enforceProgressStall(selfEval, flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules),
-        () => enforceProgressStallTerminal(selfEval, flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules),
+        // v3.3: R-C2 — files changed outside the contract's declared scope
+        () => enforceScopeDrift(flags, selfEval, consecutiveRejections, vaultEntries),
+        // v3.7: single progress evaluator (former R4/R5 slots merged) —
+        // reject → backtrack → terminate with the deadlock guard
+        () => enforceProgressStall(selfEval, flags, currentRound, vaultEntries, consecutiveRejections),
+        // R6: rejection-counter catch-all (evaluated only when no row above
+        // fired — a clean-looking round carrying a high persisted counter)
         () => enforceMaxRejections(consecutiveRejections),
+        // v2.12: R7 — intent drift; its weak-clarification streak is a separate
+        // counter and never mixes with the global rejection count
         () => enforceIntentDrift(flags, selfEval, consecutiveRejections, driftClarificationStreak, vaultEntries),
         // v2.12: R9 — post-backtrack workspace not restored
         () => enforceBacktrackNotRestored(flags, vaultEntries, currentRound),
     ];
+    // v3.7: uniform-ladder escalation. Rows without their own escalation
+    // ladder (R1/R2/R-EVID/R-EVID-VERIFY) escalate on the session's
+    // consecutive-rejection count: repeat rejections carry the escalation
+    // notice (when enabled — the pre-v3.7 comment promised this notice but the
+    // UNLADDERED name-set patch never appended it), and a third consecutive
+    // occurrence terminates. This replaces the UNLADDERED_REJECT_CHECKS patch,
+    // which existed because the generic R6 ladder sits AFTER these rows and a
+    // persistent offender's round never reached it. Rows with their own ladder
+    // (RULE_TABLE.ladder === "internal" / "counter") are untouched.
     for (const rule of rules) {
-        const result = rule();
-        if (result)
-            return result;
+        let result = rule();
+        if (!result)
+            continue;
+        const row = result.check !== undefined
+            ? RULE_TABLE_BY_ID.get(result.check)
+            : undefined;
+        if (result.action === "reject" && row && row.ladder === "uniform") {
+            if (consecutiveRejections >= (row.terminalAfter ?? 2)) {
+                return makeEnforcementResult({
+                    action: "terminate",
+                    reason: `${consecutiveRejections + 1} consecutive rejections for the same ` +
+                        `issue (${result.check}) without resolution — the agent cannot ` +
+                        `correct it even after escalation.`,
+                    check: result.check,
+                });
+            }
+            if (consecutiveRejections >= 1 && row.noticeOnRepeat &&
+                getPolicy().engine.enforcement_escalation_enabled) {
+                result = makeEnforcementResult({
+                    ...result,
+                    fix_instructions: result.fix_instructions + buildEscalationNotice(),
+                });
+            }
+        }
+        return result;
     }
     // All rules passed — accept the round
     return makeEnforcementResult({