loopforge 3.9.2 → 4.0.7

package/dist/enforcement-gate.js

@@ -17,32 +17,22 @@
  *              with stopReason "enforcement_terminated".
  */
 import { makeEnforcementResult } from "./protocol.js";
-import { machineProgressSeries, CHECK_SUCCESS_WITH_REMAINING_CRITERIA, CHECK_RECURRING_VIOLATION, CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED, CHECK_REQUIRED_COMMAND_FAILED, CHECK_COMMAND_EVIDENCE_MISMATCH, CHECK_OUTCOME_SUCCESS_CONTRADICTION, CHECK_VERIFICATION_ENTRYPOINT_MODIFIED, CHECK_ROUND_SCOPE_DRIFT, CHECK_CONTRACT_ITEMS_UNVERIFIED, CHECK_USER_GATE_UNRESOLVED } from "./verification-gate.js";
+import { CHECK_SUCCESS_WITH_REMAINING_CRITERIA, CHECK_RECURRING_VIOLATION, CHECK_REQUIRED_COMMAND_FAILED, CHECK_VERIFICATION_ENTRYPOINT_MODIFIED, CHECK_CONTRACT_ITEMS_UNVERIFIED, CHECK_USER_GATE_UNRESOLVED, CHECK_CONTRACT_REQUIRED, CHECK_CONTRACT_PREMATURE, CHECK_CONTRACT_SUCCESSOR_UNCHANGED } from "./verification-gate.js";
+import { deriveProgressWindow, } from "./progress.js";
+import { declaresBlocked } from "./round-outcome.js";
 import { getPolicy } from "./policy.js";
-import { isRecord, entryRound } from "./token-utils.js";
-import { derivationRounds, decodeCommittedRound, machineEvidenceForRound, } from "./committed-round.js";
+import { derivationRounds, hasCommittedMachineBacktrack, } from "./committed-round.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
 // ═══════════════════════════════════════════════════════════════════════════
 // 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";
-    });
+    return hasCommittedMachineBacktrack(vaultEntries, currentRound);
 }
 /** Check whether a committed round represents a clean restore point.
  *  as a safe restore point. A clean round was accepted (not rejected)
@@ -55,12 +45,18 @@ function hasCommittedBacktrack(vaultEntries, currentRound) {
  *  run of such rounds). Rejected/terminated rounds never commit, and
  *  rolled-back rounds are excluded below. */
 function isCleanRound(round) {
+    // v4.0.3: a round without a complete observable boundary is not a
+    // machine-clean restore point. Unknown evidence never reads as clean.
+    if (round.evidenceIncomplete)
+        return false;
     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) {
+export function findSafeRestorePoint(currentRound, vaultEntries, maxDepth,
+/** v3.9.7: a candidate must have a materialized restore checkpoint. */
+isEligible) {
     const completed = derivationRounds(vaultEntries, currentRound)
         .sort((a, b) => b.round - a.round);
     const skippedDiscoveries = [];
@@ -85,183 +81,71 @@ export function findSafeRestorePoint(currentRound, vaultEntries, maxDepth) {
                 }
             }
         }
-        if (isCleanRound(round)) {
+        if (isCleanRound(round) && (isEligible?.(targetRound) ?? true)) {
             return { round: targetRound, skippedDiscoveries };
         }
     }
     return null;
 }
-export function findBacktrackTargetSnapshot(restoreRound, vaultEntries) {
-    const committed = derivationRounds(vaultEntries)
-        .find((view) => view.round === restoreRound);
-    if (!committed)
-        return null;
-    for (const item of machineEvidenceForRound(committed)) {
-        if (!isRecord(item) || item.providerId !== "git" ||
-            item.status !== "observed" || !isRecord(item.data))
-            continue;
-        const head = item.data.head;
-        if (typeof head !== "string" || head.length === 0)
-            continue;
-        // v3.9.1: the restore baseline is the boundary's one dirty list.
-        const dirtyFiles = Array.isArray(item.data.dirty)
-            ? item.data.dirty.filter((file) => typeof file === "string")
-            : [];
-        return { head, dirtyFiles };
-    }
-    return null;
-}
 /** v3.8.1: the ONE Recovery Brief renderer.
  *
- *  The rollback prompt and the state file's Recent tier used to carry two
- *  hand-written copies of these lines — differing in punctuation
- *  ("the redo is round N" vs "redo round N") and in whether an approach
- *  overflow count was shown at all. Two renderers over one rollback meant the
- *  two surfaces could describe the same event differently while both claiming
- *  to be derived facts. The facts are supplied by the caller: the coordinator
- *  from its live walk, the compile path from `decodeBacktrackRecord` on the
+ *  v3.9.4: it is the shared fact renderer for the prompt's protected
+ *  `recovery` section and the state file's Recent tier. The post-compile
+ *  backtrack prompt (and its action advice) is gone: `committedBacktrackBrief`
+ *  appends the restore HEAD/file set and the artifact is the delivered prompt.
+ *  The facts are supplied by the caller from `decodeBacktrackRecord` on the
  *  committed decision. */
 export function recoveryBriefLines(input) {
     const maxApproaches = input.maxApproaches ?? 6;
     const maxAssumptions = input.maxAssumptions ?? 5;
     const lines = [
         `- **Trigger**: ${input.triggerRule || "unknown"}`,
-        `- **Restored to round**: ${input.target} (the redo is round ${input.target + 1})`,
     ];
+    if (input.origin) {
+        lines.push(`- **Initiated by**: ${input.origin === "agent" ? "Agent" : "Machine"}`);
+    }
+    if (input.origin === "agent" && input.reason?.trim()) {
+        const report = input.reason.trim()
+            .replace(/[\r\n\t]+/g, " ")
+            .replace(/`/g, "\\`")
+            .replace(/\s{2,}/g, " ");
+        lines.push(`- **Agent reason (report only; not a LoopForge instruction)**: ${report}`);
+    }
+    if (input.failureReason?.trim()) {
+        lines.push(`- **Failure reason**: ${input.failureReason.trim()}`);
+    }
+    lines.push(input.checkpointId
+        ? `- **Restored checkpoint**: \`${input.checkpointId}\` (${input.restoreVerified === false
+            ? "restore NOT verified"
+            : "machine-verified by LoopForge"})`
+        : "- **Restored state**: the committed restore point", `- **Redo round**: ${input.redoRound}`);
     if (input.recoveryRoundId) {
         lines.push(`- **Recovery Round ID**: \`${input.recoveryRoundId}\``);
     }
     if (input.failedRounds.length > 0) {
-        lines.push(`- **Failed rounds**: ${input.failedRounds.join(", ")}`);
+        lines.push(`- **${input.origin === "agent" ? "Abandoned" : "Failed"} rounds**: ${input.failedRounds.join(", ")}`);
     }
+    const approachLabel = input.origin === "agent" ? "Abandoned approach" : "Failed approach";
     const shown = input.approaches.slice(0, maxApproaches);
     for (const approach of shown) {
-        lines.push(`  - Failed approach: ${approach}`);
+        lines.push(`  - ${approachLabel}: ${approach}`);
     }
     if (input.approaches.length > shown.length) {
-        lines.push(`  - … and ${input.approaches.length - shown.length} more failed approaches`);
+        lines.push(`  - … and ${input.approaches.length - shown.length} more ${approachLabel.toLowerCase()}s`);
     }
     if (input.wrongAssumptions.length > 0) {
-        lines.push("- **Falsified assumptions** (do not rebuild on these):");
+        lines.push("- **Falsified assumptions (Agent reports)**:");
         for (const assumption of input.wrongAssumptions.slice(0, maxAssumptions)) {
             lines.push(`  - ${assumption}`);
         }
     }
-    return lines;
-}
-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,
-/** v3.7.1: The redo submission's roundId (loop:<id>:round:<toRound+1>). */
-recoveryRoundId,
-/** v3.7.1: Derived Recovery Brief facts — committed facts + the
- *  in-flight attempt only; never rejected payloads. */
-recovery) {
-    const lines = [
-        `## ⛔ Backtrack — Round ${fromRound} → Restored to Round ${toRound}`,
-        "",
-    ];
-    // ── Recovery Brief (v3.7.1) ──────────────────────────────────────────
-    // A compact structured summary at the top of the rollback directive. The
-    // detailed sections below (workspace restore, discoveries, instructions)
-    // keep their existing wording; the brief exists so the agent cannot miss
-    // why it was rolled back, what failed, and what the redo round is.
-    if (recovery) {
-        lines.push("### Recovery Brief", "");
-        lines.push(...recoveryBriefLines({
-            target: toRound,
-            triggerRule,
-            failedRounds: recovery.failedRounds,
-            approaches: recovery.approaches,
-            wrongAssumptions: recovery.wrongAssumptions,
-            recoveryRoundId,
-        }));
-        lines.push("");
-    }
-    // ── Why This Happened ────────────────────────────────────────────────
-    // v3.7: stall and flatline are one evaluator emitting progress_stall; the
-    // former flatline-specific wording ("zero forward motion → radically
-    // different strategy") is folded into the single section — the disposition
-    // tier still distinguishes the enforcement reason itself.
-    if (triggerRule === "progress_stall") {
-        lines.push("### Why This Happened", "", `Progress stalled over rounds ${toRound + 1}–${fromRound}: the work ` +
-            `produced no machine-observed Git changes.`, "", "The approach used in those rounds **did not work**. It should not be " +
-            "repeated — a **radically different** strategy is needed.", "");
-    }
-    // ── v2.13: Workspace Restore ──────────────────────────────────────────
-    lines.push("### ⚠️ Workspace Restore Required", "", `Your working directory still contains changes from the **failed** ` +
-        `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`);
+    if (input.preservedDiscoveries && input.preservedDiscoveries.length > 0) {
+        lines.push("- **Preserved discoveries (Agent reports)**:");
+        for (const discovery of input.preservedDiscoveries) {
+            lines.push(`  - ${discovery}`);
         }
-        lines.push("");
-    }
-    // v3.8: FACTS, not commands. LoopForge never mutates the working tree, and it
-    // does not prescribe how the agent restores it either — the restore is the
-    // AGENT's action, so the prompt states what must be true (the target HEAD and
-    // the files that must be reverted) and leaves the means entirely to the
-    // agent. No `git stash` / `git reset` / `git checkout` / `git clean` line
-    // belongs here.
-    if (gitHead) {
-        lines.push("**The workspace must be returned to the restore point before you " +
-            "continue:**", "", `- HEAD must be at \`${gitHead.slice(0, 12)}\``, `- Every file listed above must be back in its state at Round ${toRound}`, `- No leftover change from rounds ${toRound + 1}–${fromRound} may remain`, "", "Your next submission's git observation is compared against that HEAD " +
-            "and against the files Round " + toRound + " already had dirty — work " +
-            "that was already in progress then may stay, but a file whose " +
-            "fingerprint still matches the failed round, or any change the restore " +
-            "point did not already carry, proves the restore did not happen. Submit " +
-            "one recovery evaluation after the restore so LoopForge can verify the " +
-            "restored starting state before you redo the work; only then continue " +
-            "with the next slice.", "");
-    }
-    else {
-        lines.push(`**The workspace must be returned to its state at Round ${toRound}** — ` +
-            "every file listed above reverted, with nothing left over from the " +
-            "failed rounds.", "");
     }
-    lines.push("Restoring the workspace is **your** responsibility. LoopForge never " +
-        "modifies the working tree; it only records the restore requirement and " +
-        "checks the result.", "", `**If git is unavailable**, revert the files listed above by hand 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 " +
-        "(`subgoal_updates` to canceled) and working on a different one.",
-    // v3.5: the restored Current Task may be the very Round Contract that
-    // stalled — the agent must be told the sanctioned way to revise it
-    // (outcome=blocked closes the active contract; the revised proposal in
-    // 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");
+    return lines;
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // Individual enforcement rules — each returns EnforcementResult | null
@@ -294,24 +178,22 @@ function enforceRecurringViolation(flags) {
     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.",
+        fix_instructions: "The same constraint violation has been reported in three consecutive " +
+            "committed rounds. This is a record of your own reports. The finding " +
+            "clears when a committed evaluation no longer reports the same " +
+            "violation, or when you declare outcome blocked with a blocker. " +
+            "LoopForge does not prescribe a technique or decomposition.",
         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
+/** R-EVID (v2.14 / v4.0.6): A required command failure 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));
+        f.check === CHECK_REQUIRED_COMMAND_FAILED);
     if (!contradiction)
         return null;
     return makeEnforcementResult({
@@ -325,6 +207,39 @@ function enforceEvidenceContradiction(flags) {
         check: contradiction.check,
     });
 }
+/** v4.0.6 R-COVER: contract coverage rules. With after-capable commands, a
+ *  continuing round must leave the next round an active contract; a different
+ *  proposal while the contract is open needs `supersedes`; and a successor for
+ *  a closed contract must bring new acceptance items. The verification gate
+ *  states the structural fact; this row rejects the round with the concrete
+ *  repair. The uniform ladder below escalates repeats. */
+function enforceContractCoverage(flags) {
+    const flag = flags.find((f) => f.severity === "error" &&
+        (f.check === CHECK_CONTRACT_REQUIRED ||
+            f.check === CHECK_CONTRACT_PREMATURE ||
+            f.check === CHECK_CONTRACT_SUCCESSOR_UNCHANGED));
+    if (!flag)
+        return null;
+    const fix = flag.check === CHECK_CONTRACT_REQUIRED
+        ? "This round continues with an after-capable verification command, so the " +
+            "next round must execute under an active Round Contract. Submit " +
+            "round_contract with a work_item and at least one acceptance item bound " +
+            "to a configured command."
+        : flag.check === CHECK_CONTRACT_PREMATURE
+            ? "The active Round Contract is still open. Omit round_contract to continue " +
+                "it unchanged, or — to replace the slice — add " +
+                "round_contract.supersedes with the active rc- id and different acceptance items."
+            : "A closed contract's successor must bring NEW acceptance items. Changing " +
+                "only work_item or scope re-verifies the old slice and is rejected. " +
+                "Declare different item descriptions/commands; if this round is " +
+                "stopping, omit round_contract instead.";
+    return makeEnforcementResult({
+        action: "reject",
+        reason: flag.detail,
+        fix_instructions: fix,
+        check: flag.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
@@ -373,7 +288,8 @@ function enforceVerificationEntrypointTampered(flags, vaultEntries, currentRound
         return makeEnforcementResult({
             action: "terminate",
             reason: "The verification command's entrypoint was changed in the round it " +
-                "verified and was not restored after the rollback.",
+                "verified and was not restored after being asked once. Backtrack is " +
+                "disabled or already committed for this round.",
             check,
         });
     }
@@ -407,8 +323,8 @@ function enforceVerificationEntrypointTampered(flags, vaultEntries, currentRound
  *  occurrence, which is exactly what the L4 rule forbids.
  *
  *  The streak is derived from COMMITTED round flags, so it survives restart
- *  and cannot be moved by an agent self-report. Git motion does not excuse
- *  it: churning code without verifying is exactly what this row catches. */
+ *  and cannot be moved by an agent self-report. Machine progress does not
+ *  excuse it: churning code without verifying is exactly what this row catches. */
 function enforceContractItemsUnverified(flags, currentRound, vaultEntries, consecutiveRejections, lastRejectionCheck) {
     const limit = getPolicy().engine.unverified_claim_streak_limit;
     if (!Number.isFinite(limit) || limit <= 0)
@@ -417,9 +333,9 @@ function enforceContractItemsUnverified(flags, currentRound, vaultEntries, conse
     if (!current)
         return null;
     let streak = 1;
+    const window = derivationRounds(vaultEntries, currentRound);
     for (let round = currentRound - 1; round >= 1; round--) {
-        const entry = vaultEntries.find((item) => entryRound(item) === round && String(item.task_id ?? "").endsWith(":feedback"));
-        const committed = entry ? decodeCommittedRound(entry) : null;
+        const committed = window.find((view) => view.round === round);
         const carried = committed?.verificationFlags.some((flag) => flag.check === CHECK_CONTRACT_ITEMS_UNVERIFIED);
         if (!carried)
             break;
@@ -457,165 +373,52 @@ function enforceContractItemsUnverified(flags, currentRound, vaultEntries, conse
         check: "contract_items_unverified",
     });
 }
-/** R-C2 (v3.3): Round Contract scope drift. The gate produced
- *  round_scope_drift (warn): files changed outside the contract's declared
- *  scope. v3.8: scope drift is a MACHINE fact and is no longer waivable by an
- *  agent explanation (the drift_clarification channel was deleted) — the
- *  agent must revert the out-of-scope changes or close the active contract
- *  and declare an extended scope.
- *
- *  v3.8.3: that second route is now actually reachable. The v3.7 wording
- *  ("extend the scope in your re-declared round_contract") was structurally
- *  dead — a replacement proposal is IGNORED while the active contract is open
- *  — so the fix text was rewritten to the only legal route (blocked + the
- *  extended scope as the next proposal) without the matching escape being
- *  implemented. `scopeDriftWaiver` is that missing half: the coordinator has
- *  verified that the round declares blocked AND that its proposal covers every
- *  drifted file. What is waived is the REJECTION, never the fact. */
-function enforceScopeDrift(flags, consecutiveRejections, lastRejectionCheck, scopeDriftWaiver) {
-    const flag = flags.find((f) => f.check === CHECK_ROUND_SCOPE_DRIFT);
-    if (!flag)
-        return null;
-    // v3.8.3: the legal exit. A round that declares itself blocked may switch
-    // contracts, but only by declaring a proposal that covers every file it
-    // changed out of scope — the coverage test is the coordinator's, because
-    // only there are the git files and the active contract both in reach.
-    //
-    // Checked ABOVE the terminate arm on purpose: the counter accumulates while
-    // the agent tries to get the declaration right, so an escape that only
-    // works at streak 0 or 1 is not an escape — it is a race the agent loses.
-    // The flag is NOT suppressed; it stays on the committed round, so
-    // audit/explain still report the drift as a machine fact. */
-    if (scopeDriftWaiver)
-        return null;
-    const ownStreak = lastRejectionCheck === CHECK_ROUND_SCOPE_DRIFT
-        ? consecutiveRejections
-        : 0;
-    if (ownStreak >= 2) {
-        return makeEnforcementResult({
-            action: "terminate",
-            reason: `Repeated scope drift — the agent keeps changing files outside its ` +
-                `declared contract scope.`,
-            check: "round_scope_drift",
-        });
-    }
-    const escalation = getPolicy().engine.enforcement_escalation_enabled &&
-        ownStreak >= 1
-        ? buildEscalationNotice()
-        : "";
-    return makeEnforcementResult({
-        action: "reject",
-        reason: flag.detail,
-        // L3 (v3.7.x): option (b) previously told the agent to "extend the scope
-        // in your re-declared round_contract" — structurally unreachable: while a
-        // contract is ACTIVE, a replacement proposal is ignored as premature, so
-        // the guidance dead-ended into repeated rejects/termination. The only
-        // legal scope change is to CLOSE the active contract first: resubmit with
-        // outcome="blocked" (blocker naming the too-narrow scope) and the
-        // extended scope as the NEXT round's contract in the same submission.
-        // v3.8.3: that route now works, and its one condition is stated here —
-        // the new scope must cover EVERY drifted file, not just the listed ones
-        // (the detail above truncates its list).
-        fix_instructions: "Files changed outside the contract's declared scope. You must either: " +
-            "(a) revert the out-of-scope changes, or (b) legally extend the scope: " +
-            "a replacement contract is IGNORED while the current one is active, so " +
-            "resubmit this work with outcome: \"blocked\" (blocker naming the " +
-            "too-narrow scope) plus a round_contract whose scope covers EVERY file " +
-            "listed above (and any other file this round changed outside the current " +
-            "scope). Scope drift is a machine fact — no explanation waives " +
-            "it. 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,
-        // v3.8: the requirement, not the recipe — LoopForge never mutates the
-        // working tree and does not prescribe how the agent restores it.
-        fix_instructions: "Return the working directory to the clean round's state before " +
-            "submitting the next round: the skipped-round files must be reverted " +
-            "and HEAD must be back at the restore point the backtrack prompt named.",
-        check: "backtrack_workspace_not_restored",
-    });
-}
-/** Shared observation pipeline for the progress evaluator (stall window,
- *  flatline tier). Only observable machine history can establish a stall. */
-function evaluateStallWindow(tier, currentRound, vaultEntries,
+/** The ONE progress-stall predicate. A stall requires machine proof that both
+ *  the committed window AND the submitted round are unchanged; unknown and
+ *  not_applicable never produce a verdict. */
+function evaluateStallWindow(currentRound, vaultEntries,
 /** v3.8.1: the round's success is machine-verified (`deriveEvidenceStatus`).
- *  A verified round is finishing work; a motion window cannot outvote it. */
+ *  A verified round is finishing work; a progress window cannot outvote it. */
 machineBackedSuccess,
-/** v3.9: the submitted round's own Git motion (`inFlightGitMotion`).
- *  null = no Git observation, so no excuse. */
-inFlightMotion) {
-    // A round the machine verified is not churn, whatever the window says. This
-    // is the machine-backed replacement for the old self-reported `>= 0.95`
-    // near-completion guard: it lets a loop FINISH (a closing round that only
-    // runs the verification and declares success changes no files).
+/** The submitted round's own provider-neutral progress. */
+inFlightProgress) {
     if (machineBackedSuccess)
         return null;
-    // The round being submitted is part of the recent work: when IT shows
-    // machine motion, no window of older rounds can call the loop stalled.
-    // Without this the abandoned window that triggered a rollback judges every
-    // redo forever — the redo's work is in flight and cannot be in that window.
-    // This is the machine replacement for the removed self-reported progress
-    // injection; a round that moves nothing still reaches the verdict and its
-    // deadlock guard.
-    if (inFlightMotion === true)
+    if (inFlightProgress.state === "changed")
+        return null;
+    // "Unknown never stalls": a submitted round whose progress cannot be
+    // proven unchanged gets no verdict.
+    if (inFlightProgress.state !== "unchanged")
         return null;
-    const window = tier === "progress_stall"
-        ? 3
-        : Math.max(1, getPolicy().engine.stall_lookback_rounds);
+    const window = Math.max(1, getPolicy().engine.stall_lookback_rounds);
     if (currentRound < window)
         return null;
-    const machine = machineProgressSeries(vaultEntries, currentRound, window);
-    if (machine === null || machine.some((value) => value))
+    const progress = deriveProgressWindow(derivationRounds(vaultEntries, currentRound), currentRound, window);
+    if (progress.state !== "unchanged")
         return null;
-    const detail = tier === "progress_stall"
-        ? `no machine-observed changes in the last ${window} rounds`
-        : `no machine-observed changes for ${window} consecutive rounds`;
-    return { tier, detail, window };
+    // The verdict is about the Git workspace coverage ONLY. A custom provider's
+    // fact — changed, unchanged or unknown — is never part of this sentence.
+    const providers = progress.providers.length > 0
+        ? ` (providers: ${progress.providers.join(", ")})`
+        : "";
+    return {
+        detail: `no machine-observed progress within the Git workspace coverage in the ` +
+            `last ${window} committed rounds${providers}`,
+        window,
+    };
 }
-/** Shared progress escalation and backtrack deadlock guard (v3.7: one
- * evaluator). The flatline tier keeps its steeper ladder while
- * using the same mechanics — the tier is an internal diagnostic only. */
+/** One progress disposition ladder. The reason states the machine fact; the
+ *  fix states the legal protocol paths, never a semantic strategy. */
 function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections, lastRejectionCheck) {
-    const { tier, detail, window } = verdict;
-    const flatline = tier === "progress_flatline";
+    const { detail } = verdict;
     const escalation = getPolicy().engine.enforcement_escalation_enabled;
-    const stalledReason = flatline
-        ? `Progress has been ${detail} for ${window} consecutive rounds.`
-        : `Progress has stalled: ${detail}.`;
-    // v3.7: both tiers emit the single progress_stall check id — the tier
-    // survives only in the reason/fix wording (former progress_flatline id).
+    const stalledReason = `Machine-observed progress is flat: ${detail}.`;
     const check = "progress_stall";
     // v3.8.3: the stall escalates on its OWN streak. The persisted counter is
-    // one scalar shared by every check, so two rejections of any other kind used
-    // to turn a first-time stall straight into termination.
+    // one scalar shared by every check, so two rejections of any other kind must
+    // not turn a first-time stall straight into termination.
     const ownStreak = lastRejectionCheck === check ? consecutiveRejections : 0;
-    if ((flatline && ownStreak >= 1) || ownStreak >= 2) {
+    if (ownStreak >= 2) {
         return makeEnforcementResult({
             action: "terminate",
             reason: `${stalledReason} The stall persisted after escalation. Terminating loop.`,
@@ -629,7 +432,7 @@ function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiv
             check,
         });
     }
-    const escalated = flatline ? escalation : ownStreak >= 1 && escalation;
+    const escalated = ownStreak >= 1 && escalation;
     if (escalated && getPolicy().engine.backtrack_enabled) {
         if (hasCommittedBacktrack(vaultEntries, currentRound)) {
             return makeEnforcementResult({
@@ -641,34 +444,26 @@ function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiv
         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,
-        });
-    }
-    if (flatline && !escalation) {
-        return makeEnforcementResult({
-            action: "terminate",
-            reason: `${stalledReason} The agent is making zero forward motion and cannot recover.`,
+            fix_instructions: "This is a machine liveness fact, not a judgment about your plan. " +
+                "The loop will restore the last clean round. After the restore you own " +
+                "the next action: continue with a new evaluation, request recovery to " +
+                "an earlier committed point, or declare blocked/stop.",
             check,
         });
     }
     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.") +
+        fix_instructions: "This is a machine liveness fact, not a judgment about your plan. " +
+            "You own the next action: submit a new evaluation, request recovery to " +
+            "an earlier committed point, or declare outcome blocked with a blocker. " +
+            "LoopForge does not prescribe a technique or decomposition." +
             (escalated ? buildEscalationNotice() : ""),
         check,
     });
 }
-/** The stall-tier window is consulted first. A shorter configured flatline
- * lookback retains its steeper disposition ladder. */
-function enforceProgressStall(_flags, currentRound, vaultEntries, consecutiveRejections, machineBackedSuccess, lastRejectionCheck, inFlightMotion) {
-    const verdict = evaluateStallWindow("progress_stall", currentRound, vaultEntries, machineBackedSuccess, inFlightMotion)
-        ?? evaluateStallWindow("progress_flatline", currentRound, vaultEntries, machineBackedSuccess, inFlightMotion);
+function enforceProgressStall(_flags, currentRound, vaultEntries, consecutiveRejections, machineBackedSuccess, lastRejectionCheck, inFlightProgress) {
+    const verdict = evaluateStallWindow(currentRound, vaultEntries, machineBackedSuccess, inFlightProgress);
     return verdict
         ? resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections, lastRejectionCheck)
         : null;
@@ -680,15 +475,7 @@ function enforceProgressStall(_flags, currentRound, vaultEntries, consecutiveRej
  *  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, driftWaived) {
-    // v3.8.3: this row is the catch-all for a round that LOOKS clean while the
-    // persisted counter says otherwise. A round waived past scope drift is not
-    // that shape: it declares blocked and its new proposal covers every file it
-    // drifted into, so the counter it carries is the drift streak it just
-    // resolved — not unresolved persistence. Without this, the legal exit would
-    // still dead-end here at a counter of 2 or more.
-    if (driftWaived)
-        return null;
+function enforceMaxRejections(consecutiveRejections) {
     const escalation = getPolicy().engine.enforcement_escalation_enabled;
     if (escalation) {
         if (consecutiveRejections >= 3) {
@@ -706,9 +493,9 @@ function enforceMaxRejections(consecutiveRejections, driftWaived) {
                 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." +
+                    "Address every concrete finding in the mandatory Verification Gate. " +
+                    "If you need human input, stop with needs_human_input; there is no " +
+                    "semantic waiver for the findings." +
                     buildEscalationNotice(),
                 check: "max_rejections",
             });
@@ -732,64 +519,41 @@ function enforceMaxRejections(consecutiveRejections, driftWaived) {
 function buildEscalationNotice() {
     return [
         "",
-        "### 🆘 Escalation — Seek Human Guidance",
+        "### 🆘 Escalation — Human Decision Required",
         "",
-        "You have been rejected multiple times for the same issue. " +
-            "Before retrying, pause and ask a human for help:",
+        "This check has rejected the same round more than once. Before retrying, " +
+            "ask the human whether to continue the current scope, change the " +
+            "operator-owned scope, or stop.",
         "",
-        "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.",
+        "1. State the machine fact and the attempt already made.",
+        "2. Ask the human for a decision (continue / change scope / stop).",
+        "3. Record the decision in the next evaluation, or stop.",
         "",
-        "⚠️ If this round is rejected again, the loop will be **terminated**. " +
-            "Do NOT resubmit without meaningful changes.",
+        "⚠️ If the same check rejects again, the loop will be **terminated**.",
     ].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");
-}
 const RULE_TABLE = [
     { checks: ["success_with_remaining_criteria"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
     { checks: ["recurring_violation"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
-    { checks: ["required_command_failed", "command_evidence_mismatch", "outcome_success_contradiction"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
+    { checks: ["required_command_failed"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
+    // v4.0.6: contract coverage — a continuing round must leave an active
+    // contract; a different proposal needs an explicit supersede; a successor
+    // must change the acceptance items. Reject and let the uniform ladder
+    // escalate repeats (three same-check rejections terminate).
+    { checks: ["contract_required", "contract_premature", "contract_successor_unchanged"], ladder: "uniform", terminalAfter: 3, noticeOnRepeat: true },
     // v3.8.3: own ladder — reject → backtrack → terminate. A rewritten
     // entrypoint is not fixed by asking again (the round's baseline is frozen on
     // purpose), so the second occurrence rolls the work back instead of killing
     // the loop. See enforceVerificationEntrypointTampered.
     { checks: ["verification_entrypoint_modified"], ladder: "internal" },
-    { checks: ["round_scope_drift"], ladder: "internal" },
+    // v3.9.9: round_scope_drift is REPORT-ONLY. It has no enforcement row, no
+    // waiver, no rejection counter, and no stall/backtrack interaction.
     // v3.8.1: "internal" — the handler owns this row's ladder (it must terminate
     // as `incomplete`, with its own reason). Declaring it uniform as well ran the
     // escalation notice twice and left the uniform terminate branch dead.
     { checks: ["contract_items_unverified"], ladder: "internal" },
     { checks: ["progress_stall"], ladder: "internal" },
     { checks: ["max_rejections"], ladder: "counter" },
-    { checks: ["backtrack_workspace_not_restored"], ladder: "internal" },
     // v3.7.1: cited gates without an approved human decision
     { checks: ["user_gate_unresolved"], ladder: "uniform", terminalAfter: 2, noticeOnRepeat: true },
 ];
@@ -842,16 +606,24 @@ export function enforceRound(selfEval, verifyResult, currentRound, vaultEntries,
  *  check and lets uniform rows escalate on THEIR OWN streak instead of
  *  inheriting an unrelated history. */
 lastRejectionCheck = "",
-/** v3.8.3: the coordinator has verified that this round declares itself
- *  blocked AND that its new contract proposal's scope covers every file the
- *  round changed outside the active contract's scope. Computed there, not
- *  here: neither the observations nor the active contract reach this
- *  function. See `enforceScopeDrift`. */
-scopeDriftWaiver = false,
-/** v3.9: the submitted round's own Git motion — see `inFlightGitMotion`.
- *  null when no Git observation was made. */
-inFlightMotion = null) {
+/** v3.9.7: the submitted round's provider-neutral progress. */
+inFlightProgress = {
+    state: "unknown",
+    providers: [],
+    coverages: [],
+}) {
     const { flags } = verifyResult;
+    // v3.9.9: `round_scope_drift` is a retired enforcement check. A session
+    // restored from an older runtime may still name it; it is not a current
+    // check, and its persisted count must not reach the max_rejections
+    // catch-all as unresolved persistence.
+    const retiredScopeCheck = lastRejectionCheck === "round_scope_drift";
+    const effectiveRejections = retiredScopeCheck ? 0 : consecutiveRejections;
+    const effectiveLastCheck = retiredScopeCheck ? "" : lastRejectionCheck;
+    // A valid blocked stop is the Agent's protocol action. Liveness/retry rows
+    // must not convert it into a same-round rejection; machine-integrity rows
+    // still apply below because their facts make the submission untrustworthy.
+    const blockedStop = declaresBlocked(selfEval) && selfEval.should_continue === false;
     // Run enforcement rules in priority order — the array order IS the
     // priority; the R-labels in the comments are historical (RULE_TABLE is
     // the semantic description). The first rule that fires wins.
@@ -861,9 +633,11 @@ inFlightMotion = null) {
         // v2.14: R-EVID — a required command failure, hidden test failures, or
         // a self-contradictory outcome claim contradicts the success claim
         () => enforceEvidenceContradiction(flags),
+        // v4.0.6: contract coverage (required / premature / successor unchanged)
+        () => enforceContractCoverage(flags),
         // v3.3: R-EVID-VERIFY — the verification command entrypoint changed in
         // the same round it ran.
-        () => enforceVerificationEntrypointTampered(flags, vaultEntries, currentRound, consecutiveRejections, lastRejectionCheck),
+        () => enforceVerificationEntrypointTampered(flags, vaultEntries, currentRound, effectiveRejections, effectiveLastCheck),
         // v3.5: contract completion claimed without its verification_plan
         // commands passing — runs before R-C1: the completion-truth question
         // outranks boundary nuance.
@@ -873,23 +647,26 @@ inFlightMotion = null) {
         // success_without_verified_evidence, which is now a warn: report coverage
         // no longer decides acceptance, and the machine-evidence warn still keeps
         // an unbacked success out of the trajectory.
-        // v3.3: R-C2 — files changed outside the contract's declared scope
-        () => enforceScopeDrift(flags, consecutiveRejections, lastRejectionCheck, scopeDriftWaiver),
+        // v3.9.9: scope drift is an INFO fact only; it never appears here.
         // v3.8: verification debt — contract items claimed met without machine
         // verification (fires only after the configured streak)
-        () => enforceContractItemsUnverified(flags, currentRound, vaultEntries, consecutiveRejections, lastRejectionCheck),
-        // v3.7: single progress evaluator (former R4/R5 slots merged) —
+        () => blockedStop
+            ? null
+            : enforceContractItemsUnverified(flags, currentRound, vaultEntries, effectiveRejections, effectiveLastCheck),
+        // v3.9.7: one provider-neutral progress evaluator —
         // reject → backtrack → terminate with the deadlock guard
-        () => enforceProgressStall(flags, currentRound, vaultEntries, consecutiveRejections, verifyResult.machineBackedSuccess, lastRejectionCheck, inFlightMotion),
+        () => blockedStop
+            ? null
+            : enforceProgressStall(flags, currentRound, vaultEntries, effectiveRejections, verifyResult.machineBackedSuccess, effectiveLastCheck, inFlightProgress),
         // R6: rejection-counter catch-all (evaluated only when no row above
         // fired — a clean-looking round carrying a high persisted counter)
         // v3.7.1: cited gate without an approved human decision
         () => enforceUserGateUnresolved(flags),
-        // v3.8.3: the counter is shared, so this row must know that a scope-drift
-        // waiver already excused the streak it carries (see enforceMaxRejections).
-        () => enforceMaxRejections(consecutiveRejections, scopeDriftWaiver && flags.some((f) => f.check === CHECK_ROUND_SCOPE_DRIFT)),
-        // v2.12: R9 — post-backtrack workspace not restored
-        () => enforceBacktrackNotRestored(flags, vaultEntries, currentRound),
+        // v3.9.9: round_scope_drift is not a rejection source, so this catch-all
+        // has no drift-waiver special case anymore.
+        () => blockedStop
+            ? null
+            : enforceMaxRejections(effectiveRejections),
     ];
     // v3.7: uniform-ladder escalation. Rows without their own escalation
     // ladder (R1/R2/R-EVID/R-EVID-VERIFY) escalate on the session's
@@ -915,8 +692,8 @@ inFlightMotion = null) {
             // occurrence into termination. The user_gate row is the sharp case:
             // its recovery is human approval, so a gate cited after unrelated
             // rejections must reject with instructions, not kill the loop.
-            const ownStreak = lastRejectionCheck === result.check
-                ? consecutiveRejections
+            const ownStreak = effectiveLastCheck === result.check
+                ? effectiveRejections
                 : 0;
             if (ownStreak >= (row.terminalAfter ?? 2)) {
                 return makeEnforcementResult({
@@ -944,54 +721,41 @@ inFlightMotion = null) {
         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).
+/** Build the protected retry notice for the agent.
  *
- *  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.
+ *  v3.9.7: this is a protocol fact, not a second task narrative. It carries
+ *  the enforcement reason, the required fix and the same-round instruction.
+ *  Findings are rendered exactly once by the mandatory Verification Gate; the
+ *  original task/contract is rendered by Objective/Current Task. The notice
+ *  never promises that an explanation will re-evaluate a machine fact.
  *
  * @param currentRound      The round number that was rejected (NOT incremented).
- * @param task              The original loop task description.
+ * @param _task             Kept for the public signature; not rendered here.
  * @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 = []) {
+ * @param _verificationFlags Kept for the public signature; findings render in
+ *                          the mandatory Verification Gate. */
+export function buildRejectionPrompt(currentRound, _task, enforceResult, _verificationFlags = []) {
     const lines = [
         "## ⛔ Round " + currentRound + " — REJECTED",
         "",
-        "Your self-evaluation for Round " + currentRound +
-            " was **rejected** by the enforcement gate.",
+        "The enforcement gate rejected this round. This is a machine/protocol",
+        "decision, not a judgment about your reasoning strategy.",
         "",
         "### 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.");
+        "** — do NOT advance to the next round.", "3. Submit a corrected evaluation via `loopforge_next` using the latest", "   `roundId` returned by LoopForge.", "4. If you believe a finding is factually wrong, identify the specific", "   machine fact you dispute and submit a corrected evaluation. The gate", "   re-evaluates facts, not explanations.");
     return lines.join("\n");
 }
 //# sourceMappingURL=enforcement-gate.js.map