loopforge 3.6.0 → 3.7.1

package/dist/enforcement-gate.js

@@ -17,17 +17,16 @@
  *              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, CHECK_VERIFICATION_ENTRYPOINT_MODIFIED, CHECK_PREMATURE_BOUNDARY, CHECK_ROUND_SCOPE_DRIFT, CHECK_CONTRACT_COMPLETION_UNVERIFIED } 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, CHECK_USER_GATE_UNRESOLVED } 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 { committedRoundsFromEntries, decodeCommittedRound, } from "./committed-round.js";
+import { STABLE_ID_RE, isRecord, entryRound, extractFilePathTokens } from "./token-utils.js";
+import { committedRoundsFromEntries, decodeCommittedRound, machineEvidenceForRound, } from "./committed-round.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
 /** Collect progress estimates from vault entries into a round→estimate map.
- *  Shared by R4 (progress_stall) and R5 (progress_flatline). */
+ *  Shared by the progress evaluator's stall and flatline tiers. */
 function collectProgressByRound(vaultEntries, currentRound) {
     const progressByRound = new Map();
     for (const round of committedRoundsFromEntries(vaultEntries, currentRound)) {
@@ -129,9 +128,7 @@ export function findBacktrackTargetGitHead(restoreRound, vaultEntries) {
         .find((view) => view.round === restoreRound);
     if (!committed)
         return null;
-    const evidence = committed.afterEvidence.length > 0
-        ? committed.afterEvidence
-        : committed.beforeEvidence;
+    const evidence = machineEvidenceForRound(committed);
     for (const item of evidence) {
         if (!isRecord(item) || item.provider !== "git" || !isRecord(item.data))
             continue;
@@ -141,31 +138,62 @@ export function findBacktrackTargetGitHead(restoreRound, vaultEntries) {
     }
     return null;
 }
-/** Build the backtrack prompt injected at the top of the restored round.
- *
- *  v2.13: Includes concrete workspace restore instructions with affected
- *  file lists from skipped rounds. The agent must restore the working tree
- *  to the clean round's state before proceeding. */
-export function buildBacktrackPrompt(fromRound, toRound, triggerRule, skippedDiscoveries, 
+export function buildBacktrackPrompt(fromRound, toRound, triggerRule, skippedDiscoveries,
 /** v2.13: Files changed in the skipped rounds (from evidence snapshots).
  *  Used to show the agent exactly what needs to be reverted. */
-skippedFiles = [], 
+skippedFiles = [],
 /** v2.12: Git HEAD commit hash at the backtrack point (current HEAD).
  *  The agent must discard work back to the clean round's state. */
-gitHead) {
+gitHead,
+/** v3.7.1: The redo submission's roundId (loop:<id>:round:<toRound+1>). */
+recoveryRoundId,
+/** v3.7.1: Derived Recovery Brief facts — committed facts + the
+ *  in-flight attempt only; never rejected payloads. */
+recovery) {
     const lines = [
         `## ⛔ Backtrack — Round ${fromRound} → Restored to Round ${toRound}`,
         "",
     ];
+    // ── Recovery Brief (v3.7.1) ──────────────────────────────────────────
+    // A compact structured summary at the top of the rollback directive. The
+    // detailed sections below (workspace restore, discoveries, instructions)
+    // keep their existing wording; the brief exists so the agent cannot miss
+    // why it was rolled back, what failed, and what the redo round is.
+    if (recovery) {
+        lines.push("### Recovery Brief", "");
+        lines.push(`- **Trigger**: ${triggerRule}`);
+        lines.push(`- **Restored to round**: ${toRound} (the redo is round ${toRound + 1})`);
+        if (recoveryRoundId) {
+            lines.push(`- **Recovery Round ID**: \`${recoveryRoundId}\``);
+        }
+        if (recovery.failedRounds.length > 0) {
+            lines.push(`- **Failed rounds**: ${recovery.failedRounds.join(", ")}`);
+            const shown = recovery.approaches.slice(0, 6);
+            for (const approach of shown) {
+                lines.push(`  - Failed approach: ${approach}`);
+            }
+            if (recovery.approaches.length > shown.length) {
+                lines.push(`  - … and ${recovery.approaches.length - shown.length} more failed approaches`);
+            }
+        }
+        if (recovery.wrongAssumptions.length > 0) {
+            lines.push("- **Falsified assumptions** (do not rebuild on these):");
+            for (const assumption of recovery.wrongAssumptions.slice(0, 5)) {
+                lines.push(`  - ${assumption}`);
+            }
+        }
+        lines.push("");
+    }
     // ── 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_flatline") {
-        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** ` +
@@ -182,7 +210,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 ` +
@@ -196,7 +227,7 @@ 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.", 
+        "(`subgoal_updates` to canceled) 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
@@ -305,51 +336,12 @@ function enforceVerificationEntrypointTampered(flags) {
         check: "verification_entrypoint_modified",
     });
 }
-/** 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) {
-    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)
-        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",
-    });
-}
-/** 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)
@@ -493,12 +485,22 @@ function enforceScopeDrift(flags, selfEval, consecutiveRejections, vaultEntries
     return makeEnforcementResult({
         action: "reject",
         reason: flag.detail,
+        // L3 (v3.7.x): option (b) previously told the agent to "extend the scope
+        // in your re-declared round_contract" — structurally unreachable: while a
+        // contract is ACTIVE, a replacement proposal is ignored as premature, so
+        // the guidance dead-ended into repeated rejects/termination. The only
+        // legal scope change is to CLOSE the active contract first: resubmit with
+        // outcome="blocked" (blocker naming the too-narrow scope) and the
+        // extended scope as the NEXT round's contract in the same submission.
         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,
+            "(a) revert the out-of-scope changes, or (b) legally extend the scope: " +
+            "a replacement contract is IGNORED while the current one is active, so " +
+            "resubmit this work with outcome: \"blocked\" (blocker naming the " +
+            "too-narrow scope) plus the extended scope as the next round's " +
+            "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",
     });
 }
@@ -534,8 +536,9 @@ function enforceBacktrackNotRestored(flags, vaultEntries = [], currentRound = 0)
         check: "backtrack_workspace_not_restored",
     });
 }
-/** Shared R4/R5 observation pipeline. Machine git motion is exculpatory
- * only: it may veto a self-reported stall but can never create one. */
+/** 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
@@ -582,8 +585,9 @@ function evaluateStallWindow(tier, selfEval, currentRound, vaultEntries) {
     }
     return { tier, detail, window, threshold };
 }
-/** Shared R4/R5 escalation and backtrack deadlock guard. The flatline tier
- * keeps its steeper threshold-0 ladder while using the same mechanics. */
+/** 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";
@@ -592,18 +596,21 @@ function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiv
         ? `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: `${stalledReason} The stall persisted after escalation. Terminating loop.`,
-            check: tier,
+            check,
         });
     }
     if (consecutiveRejections >= 1 && !escalation) {
         return makeEnforcementResult({
             action: "terminate",
             reason: `${stalledReason} The stall persisted after the previous rejection. Terminating loop.`,
-            check: tier,
+            check,
         });
     }
     const escalated = flatline ? escalation : consecutiveRejections >= 1 && escalation;
@@ -612,7 +619,7 @@ function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiv
             return makeEnforcementResult({
                 action: "terminate",
                 reason: `${stalledReason} A backtrack already fired for this round; the stall persists after rollback.`,
-                check: tier,
+                check,
             });
         }
         return makeEnforcementResult({
@@ -621,14 +628,14 @@ function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiv
             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: tier,
+            check,
         });
     }
     if (flatline && !escalation) {
         return makeEnforcementResult({
             action: "terminate",
             reason: `${stalledReason} The agent is making zero forward motion and cannot recover.`,
-            check: tier,
+            check,
         });
     }
     return makeEnforcementResult({
@@ -638,17 +645,20 @@ function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiv
             ? "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: tier,
+        check,
     });
 }
+/** 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);
-    return verdict
-        ? resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections)
-        : null;
-}
-function enforceProgressFlatline(selfEval, _flags, currentRound, vaultEntries, consecutiveRejections) {
-    const verdict = evaluateStallWindow("progress_flatline", selfEval, currentRound, vaultEntries);
+    const verdict = evaluateStallWindow("progress_stall", selfEval, currentRound, vaultEntries)
+        ?? evaluateStallWindow("progress_flatline", selfEval, currentRound, vaultEntries);
     return verdict
         ? resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections)
         : null;
@@ -707,8 +717,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];
 }
@@ -951,6 +961,31 @@ 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 },
+    // v3.7.1: cited gates without an approved human decision
+    { category: "contract_scope", checks: ["user_gate_unresolved"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: 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
 // ═══════════════════════════════════════════════════════════════════════════
@@ -968,84 +1003,119 @@ 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, 
+/** v3.7.1: user_gate_unresolved — the round cites gates without an
+ *  approved human decision. Reject; the uniform ladder escalates repeats
+ *  (the agent should pause and obtain approval — never resubmit a claim of
+ *  completed high-risk work). */
+function enforceUserGateUnresolved(flags) {
+    const flag = flags.find((f) => f.check === CHECK_USER_GATE_UNRESOLVED && f.severity === "error");
+    if (!flag)
+        return null;
+    return makeEnforcementResult({
+        action: "reject",
+        reason: flag.detail,
+        fix_instructions: "The round depends on a high-risk action with no approved human " +
+            "decision. Run loopforge_gate_check with the action, present the " +
+            "approval question, and call loopforge_gate_resolve only after the " +
+            "human decides. Then resubmit with the approved gate id in " +
+            "evaluation.gate_ids. Do NOT claim the action is done while it is " +
+            "unapproved — safe preparation work never needs a gate.",
+        check: CHECK_USER_GATE_UNRESOLVED,
+    });
+}
+export function enforceRound(selfEval, verifyResult, currentRound, vaultEntries, consecutiveRejections = 0,
 /** v2.12: Current clarification streak for R7 escalation. */
-driftClarificationStreak = 0) {
+driftClarificationStreak = 0,
+/** L4 (v3.7.x): which check rejected the PREVIOUS round. The coordinator
+ *  resets consecutiveRejections to 1 whenever the check changes, so the
+ *  counter only ever measures one check's streak — this field names that
+ *  check and lets uniform rows escalate on THEIR OWN streak instead of
+ *  inheriting an unrelated history. */
+lastRejectionCheck = "") {
     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),
-        // 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),
         // v3.3: R-EVID-VERIFY — the verification command entrypoint changed in
-        // the same round it ran; its result cannot back the success claim.
-        // Runs before R8: when the entrypoint is tainted, R8 also fires (the
-        // status degrades to unavailable), but this reason is more specific.
+        // 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 (a completing eval that also lies about its
-        // evidence gets the completion reason first).
+        // 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. R8 itself is untouched.)
+        // contract's own reason.)
         () => enforcePrematureBoundary(flags, consecutiveRejections),
-        // v2.12: R8 — success with zero machine-verifiable evidence
+        // 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),
         // v3.3: R-C2 — files changed outside the contract's declared scope
         () => enforceScopeDrift(flags, selfEval, consecutiveRejections, vaultEntries),
-        // v3.3.1: R4 is evaluated first and its stall predicate contains R5's
-        // flatness predicate — under the default ladder R4 proxies for flat runs
-        // too (reject → backtrack/terminate). R5 stays as the reserved severity
-        // tier (see its doc comment: active when progress_stall_threshold <= 0
-        // or after a future window split).
+        // v3.7: single progress evaluator (former R4/R5 slots merged) —
+        // reject → backtrack → terminate with the deadlock guard
         () => enforceProgressStall(selfEval, flags, currentRound, vaultEntries, consecutiveRejections),
-        () => enforceProgressFlatline(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)
+        // v3.7.1: cited gate without an approved human decision
+        () => enforceUserGateUnresolved(flags),
         () => 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.3.1: rules without an internal escalation ladder (R1/R2/R3/R-EVID/
-    // R-EVID-VERIFY) reject on EVERY occurrence of their check, and the
-    // generic R6 ladder sits AFTER them in this priority array — R6 is only
-    // evaluated when no earlier rule fires, which a persistent offender's
-    // round never is. The documented "same-check rejections accumulate toward
-    // R6" (per-check counter the session maintains) was therefore unreachable
-    // and a repeat offender was rejected forever without a terminating step.
-    // Escalate these rules' rejects on the session's consecutive-rejection
-    // count, mirroring the R8/R7 three-strike rhythm: reject, reject
-    // (escalation notice), terminate on the third consecutive occurrence.
-    // Rules with their own ladder (R4/R5/R6/R7/R8/R9/R-C1/R-C2) are untouched.
-    const UNLADDERED_REJECT_CHECKS = new Set([
-        "success_with_remaining_criteria", // R1
-        "recurring_violation", // R2
-        "empty_success", // R3
-        "required_command_failed", // R-EVID
-        "command_evidence_mismatch", // R-EVID
-        "outcome_success_contradiction", // R-EVID
-        "verification_entrypoint_modified", // R-EVID-VERIFY
-    ]);
+    // 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();
+        let result = rule();
         if (!result)
             continue;
-        if (result.action === "reject" &&
-            consecutiveRejections >= 2 &&
-            result.check !== undefined &&
-            UNLADDERED_REJECT_CHECKS.has(result.check)) {
-            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,
-            });
+        const row = result.check !== undefined
+            ? RULE_TABLE_BY_ID.get(result.check)
+            : undefined;
+        if (result.action === "reject" && row && row.ladder === "uniform") {
+            // L4: uniform rows escalate on their OWN consecutive streak only.
+            // consecutiveRejections is the streak of the PREVIOUS round's check
+            // (the coordinator resets it to 1 whenever the check changes) — a
+            // streak earned by a DIFFERENT check must not convert this first
+            // occurrence into termination. The user_gate row is the sharp case:
+            // its recovery is human approval, so a gate cited after unrelated
+            // rejections must reject with instructions, not kill the loop.
+            const ownStreak = lastRejectionCheck === result.check
+                ? consecutiveRejections
+                : 0;
+            if (ownStreak >= (row.terminalAfter ?? 2)) {
+                return makeEnforcementResult({
+                    action: "terminate",
+                    reason: `${ownStreak + 1} consecutive rejections for the same ` +
+                        `issue (${result.check}) without resolution — the agent cannot ` +
+                        `correct it even after escalation.`,
+                    check: result.check,
+                });
+            }
+            if (ownStreak >= 1 && row.noticeOnRepeat &&
+                getPolicy().engine.enforcement_escalation_enabled) {
+                result = makeEnforcementResult({
+                    ...result,
+                    fix_instructions: result.fix_instructions + buildEscalationNotice(),
+                });
+            }
         }
         return result;
     }