loopforge 3.0.0 → 3.6.0

package/dist/enforcement-gate.js

@@ -0,0 +1,1109 @@
+/** Enforcement Gate — Layer 2 round-boundary runtime enforcement (v1.13).
+ *
+ * Pure-function module. Receives the verification gate's findings plus
+ * round-level context and decides whether to accept the round, reject it
+ * (force the agent to redo), or terminate the loop.
+ *
+ * This is the "runtime" that prompt-only constraint systems lack.
+ * Verification gate detects WHAT is wrong; enforcement gate decides
+ * what to DO about it.
+ *
+ * Decision semantics:
+ * - accept:    round passes all checks; advance to next round as normal.
+ * - reject:    agent's self-evaluation or round output is invalid; the
+ *              agent receives a rejection prompt and must redo the SAME
+ *              round. Round counter does NOT increment.
+ * - terminate: loop has reached an unrecoverable state; stop immediately
+ *              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 { 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";
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+/** Collect progress estimates from vault entries into a round→estimate map.
+ *  Shared by R4 (progress_stall) and R5 (progress_flatline). */
+function collectProgressByRound(vaultEntries, currentRound) {
+    const progressByRound = new Map();
+    for (const round of committedRoundsFromEntries(vaultEntries, currentRound)) {
+        const progress = round.executionEvidence?.progress_estimate;
+        if (typeof progress === "number")
+            progressByRound.set(round.round, progress);
+    }
+    return progressByRound;
+}
+/** v3.2.1: R4/R5 progress window — after a backtrack committed for this
+ *  round, the agent's redo submission is the freshest data point. The
+ *  pre-rollback history (which triggered the stall) stays in the vault and
+ *  the redo does not commit while it is being evaluated, so without this
+ *  the window never changes: a genuinely fixed redo is rejected forever and
+ *  the loop dies in a spurious terminate. A redo that is STILL stalled
+ *  keeps the window flat and hits the normal reject → terminate ladder. */
+function progressWindow(vaultEntries, currentRound, selfEval) {
+    const progressByRound = collectProgressByRound(vaultEntries, currentRound);
+    if (hasCommittedBacktrack(vaultEntries, currentRound)) {
+        const pe = selfEval.execution_evidence?.progress_estimate;
+        if (typeof pe === "number")
+            progressByRound.set(currentRound, pe);
+    }
+    return progressByRound;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// v2.10: Backtrack helpers
+// ═══════════════════════════════════════════════════════════════════════════
+/** Extract the committed round decision's result from a vault entry.
+ *  The round commit entry (`loop:<id>:r<N>:feedback`) carries the full
+ *  decision under loop_lineage.round_transaction; lineage entries carry
+ *  nothing at the top level. */
+function committedRoundResult(entry) {
+    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
+ *  once. Guards against the reject↔backtrack deadlock on persistent stalls. */
+function hasCommittedBacktrack(vaultEntries, currentRound) {
+    return vaultEntries.some((entry) => {
+        if (entryRound(entry) < currentRound)
+            return false;
+        return committedRoundResult(entry)?.action === "backtrack";
+    });
+}
+/** 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.
+ *
+ *  v3.2.1: judged by the COMMITTED decision and gate flags, not by the
+ *  agent's self-reported success. A progress-stall round commits with
+ *  success=false but is accepted and carries no error flags — it is a
+ *  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(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) {
+    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 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((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);
+                    }
+                }
+            }
+        }
+        if (isCleanRound(round)) {
+            return { round: targetRound, skippedDiscoveries };
+        }
+    }
+    return null;
+}
+/** v2.12: Git HEAD commit hash at the restore point. Read from the restore
+ *  round's committed transaction snapshot (after evidence preferred, before
+ *  evidence as fallback). Returns null when the round has no git snapshot
+ *  or no committed feedback entry. */
+export function findBacktrackTargetGitHead(restoreRound, vaultEntries) {
+    const committed = committedRoundsFromEntries(vaultEntries)
+        .find((view) => view.round === restoreRound);
+    if (!committed)
+        return null;
+    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;
+        const head = item.data.head;
+        if (typeof head === "string" && head.length > 0)
+            return head;
+    }
+    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, 
+/** v2.13: Files changed in the skipped rounds (from evidence snapshots).
+ *  Used to show the agent exactly what needs to be reverted. */
+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) {
+    const lines = [
+        `## ⛔ Backtrack — Round ${fromRound} → Restored to Round ${toRound}`,
+        "",
+    ];
+    // ── Why This Happened ────────────────────────────────────────────────
+    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.", "");
+    }
+    // ── v2.13: Workspace Restore ──────────────────────────────────────────
+    lines.push("### ⚠️ Workspace Restore Required", "", `Your working directory still contains changes from the **failed** ` +
+        `rounds (${toRound + 1}–${fromRound}). You MUST discard those changes ` +
+        `before starting Round ${toRound + 1}. Working on top of stale changes ` +
+        `will cause the verification gate to reject your next submission.`, "");
+    if (skippedFiles.length > 0) {
+        lines.push("**Files modified in skipped rounds (must be reverted):**", "");
+        for (const f of skippedFiles.slice(0, 15)) {
+            lines.push(`- \`${f}\``);
+        }
+        if (skippedFiles.length > 15) {
+            lines.push(`- … and ${skippedFiles.length - 15} more files`);
+        }
+        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", "```", "");
+    // 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 ` +
+            "gate checks that your working tree returns to this commit before " +
+            "accepting your next submission.", "", "```bash", "# Option C: If the failed rounds created commits, reset HEAD to the restore point", `git reset --hard ${gitHead.slice(0, 12)}`, "```", "", "> Option C discards the failed rounds' commits — use it only when those", "> commits belong to the failed work.", "");
+    }
+    lines.push(`**If git is unavailable**, manually revert the files listed above ` +
+        `to their state at Round ${toRound}. Re-read the state file below — ` +
+        `it reflects the correct state at Round ${toRound}.`, "", "> 🛡️ **Verification:** The next round's evidence check will verify that " +
+        "> your workspace no longer contains the failed changes. Submissions " +
+        "> 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.", 
+    // 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) {
+        lines.push("### Preserved Discoveries", "", "These were discovered in the skipped rounds and remain valid:", "");
+        for (const d of skippedDiscoveries) {
+            lines.push(`- ${d}`);
+        }
+        lines.push("");
+    }
+    // ── Instructions ──────────────────────────────────────────────────────
+    lines.push("### Instructions", "", `You have been rolled back to Round ${toRound}. ` +
+        `You are now starting **Round ${toRound + 1}** with the lessons above.`, "", "1. **First**: restore your workspace using the commands above.", "2. Read the restored state below — it reflects Round " + toRound + ".", "3. The discoveries from skipped rounds (if any) have been merged " +
+        "into the active constraints.", "4. Do NOT retrace the steps that led to the stall. Choose a new path.", "");
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Individual enforcement rules — each returns EnforcementResult | null
+// Rules are ordered by priority. The first non-null result wins.
+// ═══════════════════════════════════════════════════════════════════════════
+/** R1: Agent claims success but success_criteria_remaining has items.
+ *  This is a lie — the agent must either finish the criteria or
+ *  set success=false honestly. Triggered by the verification gate's
+ *  "success_with_remaining_criteria" error flag. */
+function enforceSuccessWithRemainingCriteria(flags) {
+    const flag = flags.find((f) => f.check === CHECK_SUCCESS_WITH_REMAINING_CRITERIA && f.severity === "error");
+    if (!flag)
+        return null;
+    return makeEnforcementResult({
+        action: "reject",
+        reason: flag.detail,
+        fix_instructions: "You set success=true but success criteria remain unmet. " +
+            "Either: (a) complete the remaining criteria and re-submit your self-evaluation, " +
+            "or (b) set success=false and honestly report what remains to be done.",
+        check: "success_with_remaining_criteria",
+    });
+}
+/** R2: Same constraint violation appears in 3 consecutive rounds.
+ *  The agent is repeating the same mistake. Triggered by the verification
+ *  gate's "recurring_violation" error flag. */
+function enforceRecurringViolation(flags) {
+    const flag = flags.find((f) => f.check === CHECK_RECURRING_VIOLATION && f.severity === "error");
+    if (!flag)
+        return null;
+    return makeEnforcementResult({
+        action: "reject",
+        reason: flag.detail,
+        fix_instructions: "The same constraint violation has appeared in 3 consecutive rounds. " +
+            "You must: (a) explain WHY this violation keeps occurring, " +
+            "and (b) propose a DIFFERENT approach than what you used in the last 3 rounds. " +
+            "Do NOT retry the same strategy — it has failed 3 times.",
+        check: "recurring_violation",
+    });
+}
+/** R-EVID (v2.14): A required command failure, a test-results mismatch that
+ *  hides failures, or a self-contradictory outcome claim contradicts the
+ *  success claim before commit. The verification gate detects the
+ *  contradiction; this rule decides what to do about it — reject so the
+ *  agent redos the SAME round with honest claims. Same-check rejections
+ *  accumulate toward R6 via the per-check counter. */
+function enforceEvidenceContradiction(flags) {
+    const contradiction = flags.find((f) => f.severity === "error" &&
+        (f.check === CHECK_REQUIRED_COMMAND_FAILED ||
+            f.check === CHECK_COMMAND_EVIDENCE_MISMATCH ||
+            f.check === CHECK_OUTCOME_SUCCESS_CONTRADICTION));
+    if (!contradiction)
+        return null;
+    return makeEnforcementResult({
+        action: "reject",
+        reason: contradiction.detail,
+        fix_instructions: "A required verification command failed or your claims contradict " +
+            "the evidence. You must: (a) run the required command and report its " +
+            "actual output, (b) reconcile your success claim with the evidence — " +
+            "do NOT report success when the evidence contradicts it, and " +
+            "(c) resubmit an honest SelfEvaluation for the SAME round.",
+        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) {
+    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. */
+function enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections) {
+    const flag = flags.find((f) => f.check === CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE && f.severity === "error");
+    if (!flag)
+        return null;
+    if (consecutiveRejections >= 2) {
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: "Repeated success claims with zero machine-verifiable evidence.",
+            check: "success_without_verified_evidence",
+        });
+    }
+    const escalation = getPolicy().engine.enforcement_escalation_enabled &&
+        consecutiveRejections >= 1
+        ? buildEscalationNotice()
+        : "";
+    return makeEnforcementResult({
+        action: "reject",
+        reason: "Agent claims success but the runtime verified zero claims: no passing " +
+            "test evidence and no test results were observed. Success must be backed " +
+            "by machine-verifiable evidence.",
+        fix_instructions: "Provide verifiable evidence for your success claim: (a) run tests and " +
+            "report results in execution_evidence.test_results, or (b) configure a " +
+            "required verification command and run it, or (c) if no change was " +
+            "genuinely needed, declare no_change_reason explaining why." + escalation,
+        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
+ *  git HEAD. The agent must restore the workspace, not redo the round. */
+function enforceBacktrackNotRestored(flags, vaultEntries = [], currentRound = 0) {
+    const flag = flags.find((f) => f.check === CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED && f.severity === "error");
+    if (!flag)
+        return null;
+    if (!getPolicy().engine.backtrack_enabled)
+        return null;
+    // v2.14: same deadlock guard as R4/R5 — a backtrack that already fired
+    // for this round means a non-restoring agent would otherwise cycle
+    // R9-backtrack forever (backtracks do not increment the rejection
+    // counter). One rollback chance, then terminate.
+    if (currentRound > 0 && hasCommittedBacktrack(vaultEntries, currentRound)) {
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: "The workspace is still not restored after the previous backtrack: " +
+                flag.detail,
+            check: "backtrack_workspace_not_restored",
+        });
+    }
+    return makeEnforcementResult({
+        action: "backtrack",
+        reason: "The workspace was not restored after backtrack: " + flag.detail,
+        fix_instructions: "Restore the working directory to the clean round's state " +
+            "(git checkout -- . && git clean -fd, or git stash; if the failed " +
+            "rounds created commits, git reset --hard <restore-commit>) before " +
+            "submitting the next round.",
+        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. */
+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;
+    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;
+        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 machine = machineProgressSeries(vaultEntries, currentRound, window);
+        if (machine === null)
+            return null;
+        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 (!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;
+    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: `${stalledReason} The stall persisted after escalation. Terminating loop.`,
+            check: tier,
+        });
+    }
+    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: "terminate",
+                reason: `${stalledReason} A backtrack already fired for this round; the stall persists after rollback.`,
+                check: tier,
+            });
+        }
+        return makeEnforcementResult({
+            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 (flatline && !escalation) {
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: `${stalledReason} The agent is making zero forward motion and cannot recover.`,
+            check: tier,
+        });
+    }
+    return makeEnforcementResult({
+        action: "reject",
+        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,
+    });
+}
+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.
+ *
+ *  v2.7: When enforcement_escalation_enabled is true, the second consecutive
+ *  rejection issues an escalated rejection with a "Seek Human Guidance" notice
+ *  instead of terminating immediately. Termination occurs on the third
+ *  consecutive rejection. When the flag is disabled, behavior is unchanged
+ *  (terminate at ≥2 rejections). */
+function enforceMaxRejections(consecutiveRejections) {
+    const escalation = getPolicy().engine.enforcement_escalation_enabled;
+    if (escalation) {
+        if (consecutiveRejections >= 3) {
+            return makeEnforcementResult({
+                action: "terminate",
+                reason: `${consecutiveRejections} consecutive enforcement rejections for the ` +
+                    `same issue without resolution. The agent has been unable to correct ` +
+                    `the identified issue even after escalation. Terminating loop.`,
+                check: "max_rejections",
+            });
+        }
+        if (consecutiveRejections >= 2) {
+            return makeEnforcementResult({
+                action: "reject",
+                reason: `${consecutiveRejections} consecutive enforcement rejections for the ` +
+                    `same issue without resolution.`,
+                fix_instructions: "You have been rejected multiple times for the same issue. " +
+                    "You must address ALL items in the Evidence Gap section above. " +
+                    "If you do not understand why you are being rejected, explain " +
+                    "your confusion explicitly and ask for clarification." +
+                    buildEscalationNotice(),
+                check: "max_rejections",
+            });
+        }
+        return null;
+    }
+    if (consecutiveRejections < 2)
+        return null;
+    return makeEnforcementResult({
+        action: "terminate",
+        reason: `${consecutiveRejections} consecutive enforcement rejections for the ` +
+            `same issue without resolution. The agent has been unable to correct the identified issue.`,
+        check: "max_rejections",
+    });
+}
+/** v2.12: Check if a drift_clarification contains at least one semantic
+ *  anchor — a constraint/criterion/sub-goal ID (v2.11) or a file-path-like
+ *  reference. This distinguishes genuine explanations from filler text that
+ *  just happens to be ≥ 20 characters. */
+/** Extract anchor candidates from a clarification: c-/cr-/sg- IDs and
+ *  file-path-like tokens. */
+function extractAnchors(clarification) {
+    const anchors = new Set();
+    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]);
+    }
+    return [...anchors];
+}
+/** v2.12: A drift clarification is substantive only when at least one anchor
+ *  is REAL — a stable ID that derives from a known constraint/criterion/
+ *  sub-goal text in the vault, or a file path present in reported/observed
+ *  files. Regex patterns alone (e.g. a fabricated `c-00000000`) no longer
+ *  count, closing the v2.12 filler-text loophole. */
+function clarificationIsSubstantive(clarification, selfEval, vaultEntries) {
+    const anchors = extractAnchors(clarification);
+    if (anchors.length === 0)
+        return false;
+    const knownFiles = new Set();
+    const knownTexts = new Set();
+    const collect = (values) => {
+        if (!Array.isArray(values))
+            return;
+        for (const value of values) {
+            if (typeof value === "string" && value.length > 0)
+                knownTexts.add(value);
+        }
+    };
+    // The agent's own round report is a known set: its constraints, criteria,
+    // and files are legitimate anchor targets.
+    for (const file of selfEval.execution_evidence?.files_changed ?? [])
+        knownFiles.add(file);
+    collect(selfEval.discovered_constraints);
+    collect(selfEval.constraint_violations);
+    const selfEvidence = selfEval.execution_evidence;
+    if (selfEvidence) {
+        collect(selfEvidence.success_criteria_met);
+        collect(selfEvidence.success_criteria_remaining);
+    }
+    for (const entry of vaultEntries) {
+        collect(entry.constraint_violations);
+        collect(entry.discovered_constraints);
+        const ev = entry.execution_evidence;
+        if (ev) {
+            collect(ev.files_changed);
+            collect(ev.success_criteria_met);
+            collect(ev.success_criteria_remaining);
+        }
+    }
+    for (const anchor of anchors) {
+        if (STABLE_ID_RE.test(anchor)) {
+            const matches = anchor.startsWith("c-") && !anchor.startsWith("cr-")
+                ? [...knownTexts].some((text) => deriveConstraintId(text) === anchor)
+                : anchor.startsWith("cr-")
+                    ? [...knownTexts].some((text) => deriveCriterionId(text) === anchor)
+                    : [...knownTexts].some((text) => deriveSubGoalId(text) === anchor);
+            if (matches)
+                return true;
+            continue;
+        }
+        // File path: exact or suffix match against known files.
+        if ([...knownFiles].some((file) => file === anchor || file.endsWith(`/${anchor}`) || file.endsWith(`\\${anchor}`))) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Build a stronger rejection notice as the clarification streak grows. */
+function buildClarificationRejectionNotice(streak) {
+    const base = "Your declared next_action from the previous round does not match " +
+        "what you actually did this round. You must either: " +
+        "(a) explain why you pivoted in the drift_clarification field, " +
+        "mentioning specific constraint/criterion/sub-goal IDs or file paths " +
+        "that prompted the change, or " +
+        "(b) redo this round and do what you said you would do.";
+    if (streak >= 2) {
+        return (base +
+            "\n\n### ⚠️ Repeated Weak Clarification\n\n" +
+            `You have submitted drift_clarification without concrete references ` +
+            `for ${streak} consecutive rounds. Your explanation MUST include at ` +
+            `least one of: a constraint ID (c-XXXXXXXX), criterion ID (cr-XXXXXXXX), ` +
+            `sub-goal ID (sg-XXXXXXXX), or a file path you changed.\n\n` +
+            `🚨 If the next clarification also lacks concrete anchors, the loop ` +
+            `will be terminated.`);
+    }
+    return base;
+}
+/** R7: Agent declared a next_action but did something unrelated.
+ *
+ *  v2.8: When the agent provides a substantive drift_clarification (≥ 20
+ *  characters), the rejection is waived — the agent has acknowledged and
+ *  explained the pivot. An empty or absent clarification still triggers
+ *  the normal reject/terminate path.
+ *
+ *  v2.12: Clarification now requires a semantic anchor (constraint/criterion/
+ *  sub-goal ID or file path) in addition to the ≥ 20 char minimum. Weak
+ *  clarifications (no anchors) increment a streak counter; 3 consecutive
+ *  weak clarifications terminate the loop.
+ *
+ *  First occurrence → reject (agent must explain the gap or realign).
+ *  Second consecutive → terminate (agent cannot/will not follow its own plan). */
+function enforceIntentDrift(flags, selfEval, consecutiveRejections, driftClarificationStreak = 0, vaultEntries = []) {
+    const flag = flags.find((f) => f.check === "intent_drift");
+    if (!flag)
+        return null;
+    const clarification = selfEval.drift_clarification?.trim();
+    // v2.12: Substantive anchors — the referenced ID/path must actually exist
+    // in the vault or in reported files; a fabricated ID no longer counts.
+    const hasAnchor = clarification
+        ? clarificationIsSubstantive(clarification, selfEval, vaultEntries)
+        : false;
+    // v2.12: Substantive clarification = length check + semantic anchor
+    const isSubstantive = clarification
+        && clarification.length >= 20
+        && hasAnchor;
+    if (isSubstantive) {
+        // Genuine explanation with concrete references → accept the pivot
+        return makeEnforcementResult({
+            action: "accept",
+            reason: "",
+            fix_instructions: "",
+            check: "intent_drift",
+            clarification_accepted: true,
+        });
+    }
+    // v2.12: Clarification present but weak (no semantic anchors)
+    if (clarification && clarification.length >= 20 && !hasAnchor) {
+        const maxStreak = getPolicy().engine.drift_clarification_max_streak;
+        // When maxStreak is 0, disable the check (pre-v2.12 behavior)
+        if (maxStreak <= 0) {
+            return makeEnforcementResult({
+                action: "accept",
+                reason: "",
+                fix_instructions: "",
+                check: "intent_drift",
+                clarification_accepted: true,
+            });
+        }
+        const newStreak = driftClarificationStreak + 1;
+        if (newStreak >= maxStreak) {
+            return makeEnforcementResult({
+                action: "terminate",
+                reason: `Agent has submitted weak drift_clarification (no concrete IDs or ` +
+                    `file references) for ${newStreak} consecutive rounds. The agent ` +
+                    `systematically avoids following its own plan without substantive ` +
+                    `explanation.`,
+                check: "intent_drift",
+            });
+        }
+        return makeEnforcementResult({
+            action: "reject",
+            reason: flag.detail,
+            fix_instructions: buildClarificationRejectionNotice(newStreak),
+            check: "intent_drift",
+        });
+    }
+    // No clarification or too short — the worst form of drift. v2.14: counts
+    // toward the SAME streak as weak clarifications (maxStreak consecutive
+    // un-explained drifts terminate, per the README's "three consecutive weak
+    // clarifications"). Previously this branch used the GLOBAL
+    // consecutiveRejections counter, so an unrelated earlier rejection
+    // (e.g. R1) terminated the loop on the very first drift.
+    const maxStreak = getPolicy().engine.drift_clarification_max_streak;
+    // When maxStreak is 0, disable the check (pre-v2.12 behavior)
+    if (maxStreak <= 0) {
+        return makeEnforcementResult({
+            action: "accept",
+            reason: "",
+            fix_instructions: "",
+            check: "intent_drift",
+            clarification_accepted: true,
+        });
+    }
+    const newStreak = driftClarificationStreak + 1;
+    if (newStreak >= maxStreak) {
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: `Agent has drifted from its declared next_action for ${newStreak} ` +
+                `consecutive rounds without any drift_clarification. The agent ` +
+                `cannot or will not follow its own plan — terminating loop.`,
+            check: "intent_drift",
+        });
+    }
+    return makeEnforcementResult({
+        action: "reject",
+        reason: flag.detail,
+        fix_instructions: "Your declared next_action from the previous round does not match " +
+            "what you actually did this round. You must either: " +
+            "(a) explain why you pivoted and what you learned in the " +
+            "drift_clarification field, or " +
+            "(b) redo this round and do what you said you would do. " +
+            "If you intentionally changed direction, update your objective_refinement " +
+            "and set a new next_action that reflects the new plan.",
+        check: "intent_drift",
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Escalation notice builder (v2.7)
+// ═══════════════════════════════════════════════════════════════════════════
+/** Build an escalation notice urging the agent to seek human guidance.
+ *
+ *  Appended to fix_instructions when a rule would otherwise terminate.
+ *  Gives the agent one final chance to correct course with human input
+ *  before the loop is irreversibly stopped. */
+function buildEscalationNotice() {
+    return [
+        "",
+        "### 🆘 Escalation — Seek Human Guidance",
+        "",
+        "You have been rejected multiple times for the same issue. " +
+            "Before retrying, pause and ask a human for help:",
+        "",
+        "1. Explain what you've tried so far and why each approach failed.",
+        "2. Ask the human for specific guidance on what to try next.",
+        "3. Incorporate their feedback before re-submitting your self-evaluation.",
+        "",
+        "⚠️ If this round is rejected again, the loop will be **terminated**. " +
+            "Do NOT resubmit without meaningful changes.",
+    ].join("\n");
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Diagnostic gap builder (v2.7)
+// ═══════════════════════════════════════════════════════════════════════════
+/** Build a diagnostic gap section from verification flags.
+ *
+ *  Translates each error/warn-level VerificationFlag into a concrete
+ *  claim-vs-evidence mismatch statement. Info-level flags are excluded
+ *  because they are purely informational and do not represent gaps.
+ *
+ *  Returns an empty string when there are no diagnostic flags to report. */
+function buildDiagnosticGap(flags) {
+    const diagnosticFlags = flags.filter((f) => f.severity === "error" || f.severity === "warn");
+    if (diagnosticFlags.length === 0)
+        return "";
+    const lines = [
+        "### Evidence Gap",
+        "",
+        "The enforcement gate detected mismatches between your claims and the evidence. " +
+            "Each item below shows a specific discrepancy — address every one before re-submitting.",
+        "",
+    ];
+    for (const flag of diagnosticFlags) {
+        const icon = flag.severity === "error" ? "🚫" : "⚠️";
+        lines.push(`- ${icon} **[${flag.check}]** \`${flag.field}\` — ${flag.detail}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// 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 — 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).
+ * @param currentRound          Current round number (1-based, BEFORE increment).
+ * @param vaultEntries          Vault entries for this loop (used for progress tracking).
+ * @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, 
+/** v2.12: Current clarification streak for R7 escalation. */
+driftClarificationStreak = 0) {
+    const { flags } = verifyResult;
+    // Run enforcement rules in priority order.
+    // Earlier rules take higher precedence.
+    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
+        () => 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),
+        // 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)
+            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({
+        action: "accept",
+        reason: "",
+        fix_instructions: "",
+    });
+}
+/** Build a rejection prompt for the agent.
+ *
+ *  The prompt clearly states the round was rejected, why, what the agent
+ *  must fix, and that the agent must redo the SAME round (not advance).
+ *
+ *  v2.7: Accepts verificationFlags to render a diagnostic "Evidence Gap"
+ *  section. Each error/warn flag becomes a concrete claim-vs-evidence
+ *  mismatch statement so the agent knows exactly what to correct rather
+ *  than retrying blindly.
+ *
+ * @param currentRound      The round number that was rejected (NOT incremented).
+ * @param task              The original loop task description.
+ * @param enforceResult     The enforcement decision with reason and fix instructions.
+ * @param verificationFlags The verification gate's findings for this round.
+ *                          Used to build the Evidence Gap section. */
+export function buildRejectionPrompt(currentRound, task, enforceResult, verificationFlags = []) {
+    const lines = [
+        "## ⛔ Round " + currentRound + " — REJECTED",
+        "",
+        "Your self-evaluation for Round " + currentRound +
+            " was **rejected** by the enforcement gate.",
+        "",
+        "### Reason",
+        "",
+        enforceResult.reason,
+        "",
+    ];
+    // v2.7: Diagnostic gap — show the agent exactly what doesn't match.
+    const gap = buildDiagnosticGap(verificationFlags);
+    if (gap) {
+        lines.push(gap);
+    }
+    if (enforceResult.fix_instructions) {
+        lines.push("### Required Fix");
+        lines.push("");
+        lines.push(enforceResult.fix_instructions);
+        lines.push("");
+    }
+    lines.push("### Your Task (Round " + currentRound + " — Retry)");
+    lines.push("");
+    lines.push(task);
+    lines.push("");
+    lines.push("### Instructions");
+    lines.push("");
+    lines.push("1. Read and address each issue in **Required Fix** above.", "2. Re-execute **Round " + currentRound +
+        "** — do NOT advance to the next round.", "3. Submit a corrected self-evaluation via `loopforge_next`.", "4. Be honest in your self-evaluation — " +
+        "claiming success when criteria are unmet will be rejected again.", "5. If you believe this rejection is incorrect, " +
+        "explain why in your output_summary and the enforcement gate will re-evaluate.");
+    return lines.join("\n");
+}
+//# sourceMappingURL=enforcement-gate.js.map