loopforge 3.2.1 → 3.6.0

package/dist/enforcement-gate.js

@@ -17,35 +17,23 @@
  *              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 { 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 { 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 { committedRoundsFromEntries, decodeCommittedRound, } 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 R4 (progress_stall) and R5 (progress_flatline). */
 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 +61,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 +73,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 +83,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 +114,7 @@ export function findSafeRestorePoint(currentRound, vaultEntries, maxDepth) {
                 }
             }
         }
-        if (isCleanRound(entry)) {
+        if (isCleanRound(round)) {
             return { round: targetRound, skippedDiscoveries };
         }
     }
@@ -174,23 +125,13 @@ 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 = committed.afterEvidence.length > 0
+        ? committed.afterEvidence
+        : committed.beforeEvidence;
     for (const item of evidence) {
         if (!isRecord(item) || item.provider !== "git" || !isRecord(item.data))
             continue;
@@ -222,7 +163,7 @@ gitHead) {
             `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") {
+    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.", "");
     }
@@ -255,7 +196,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,13 +283,33 @@ function enforceEvidenceContradiction(flags) {
         check: contradiction.check,
     });
 }
+/** 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: 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",
+    });
+}
 /** 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
+function enforceEmptySuccess(selfEval, _flags) {
     if (!effectiveSuccess(selfEval))
         return null;
     const ev = selfEval.execution_evidence;
@@ -407,6 +377,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 +534,124 @@ 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 R4/R5 observation pipeline. 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;
-        isStalling = machine.every((value) => !value);
-        stallDetail = "no machine-observed changes in the last 3 rounds";
+        const values = recent.map((round) => progressByRound.get(round));
+        if (values[values.length - 1] >= 0.95)
+            return null;
+        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 R4/R5 escalation and backtrack deadlock guard. The flatline tier
+ * keeps its steeper threshold-0 ladder while using the same mechanics. */
+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)` : ""}.`;
+    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: tier,
         });
     }
-    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: tier,
+        });
+    }
+    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: tier,
             });
         }
         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: tier,
         });
     }
-    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: tier,
         });
     }
     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: tier,
     });
 }
-/** 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",
-    });
+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);
+    return verdict
+        ? resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections)
+        : null;
 }
 /** R6: Two consecutive rejections → escalate (v2.7) or terminate.
  *
@@ -975,7 +957,9 @@ function buildDiagnosticGap(flags) {
 /** 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,7 +968,7 @@ 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;
@@ -993,23 +977,77 @@ driftClarificationStreak = 0) {
     const rules = [
         () => enforceSuccessWithRemainingCriteria(flags),
         () => enforceRecurringViolation(flags),
-        () => enforceEmptySuccess(selfEval, flags, skipEvidenceRules),
+        () => enforceEmptySuccess(selfEval, flags),
         // v2.14: R-EVID — a required command failure or self-contradictory
         // outcome claim contradicts the success claim before commit
         () => 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.
+        () => 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).
+        () => 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.)
+        () => enforcePrematureBoundary(flags, consecutiveRejections),
         // v2.12: R8 — success with zero machine-verifiable evidence
         () => 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.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).
+        () => enforceProgressStall(selfEval, flags, currentRound, vaultEntries, consecutiveRejections),
+        () => enforceProgressFlatline(selfEval, flags, currentRound, vaultEntries, consecutiveRejections),
         () => enforceMaxRejections(consecutiveRejections),
         () => 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
+    ]);
     for (const rule of rules) {
         const result = rule();
-        if (result)
-            return result;
+        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,
+            });
+        }
+        return result;
     }
     // All rules passed — accept the round
     return makeEnforcementResult({