loopforge 2.11.0 → 3.2.1

package/dist/enforcement-gate.js

@@ -17,8 +17,12 @@
  *              with stopReason "enforcement_terminated".
  */
 import { makeEnforcementResult } from "./protocol.js";
-import { entryRound } from "./verification-gate.js";
+import { entryRound, machineProgressSeries, CHECK_SUCCESS_WITH_REMAINING_CRITERIA, CHECK_RECURRING_VIOLATION, CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE, CHECK_BACKTRACK_WORKSPACE_NOT_RESTORED, CHECK_REQUIRED_COMMAND_FAILED, CHECK_COMMAND_EVIDENCE_MISMATCH, CHECK_OUTCOME_SUCCESS_CONTRADICTION } from "./verification-gate.js";
+import { effectiveSuccess } from "./self-eval.js";
+import { deriveConstraintId, deriveCriterionId, deriveSubGoalId } from "./loop-compiler.js";
 import { getPolicy } from "./policy.js";
+import { STABLE_ID_RE, isRecord } from "./token-utils.js";
+import { isProcessResult } from "./round-transaction.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
@@ -45,28 +49,76 @@ function collectProgressByRound(vaultEntries, currentRound) {
     }
     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) {
+    const lineage = isRecord(entry.loop_lineage) ? entry.loop_lineage : null;
+    const rt = lineage && isRecord(lineage.round_transaction)
+        ? lineage.round_transaction
+        : null;
+    if (!rt)
+        return null;
+    return isProcessResult(rt.result) ? rt.result : null;
+}
+/** 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 vault entry represents a "clean" round that can serve
  *  as a safe restore point. A clean round was accepted (not rejected)
- *  and had no error-level verification flags. */
+ *  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(entry) {
-    const lineage = entry.loop_lineage;
-    // Rejected rounds are not clean
-    const success = typeof entry.success === "boolean"
-        ? entry.success
-        : typeof lineage?.success === "boolean" ? lineage.success : undefined;
-    if (success === false)
+    const committed = committedRoundResult(entry);
+    // A rolled-back round (already backtracked) is not a valid restore point.
+    if (committed?.action === "backtrack")
         return false;
+    // Rejected/terminated rounds are not clean. (They never commit in the
+    // real vault — this guards legacy or mixed-shape data.)
+    if (committed && (committed.action === "reject" || committed.action === "terminate")) {
+        return false;
+    }
     // Rounds with error-level verification flags are not clean
-    const flags = entry.verification_flags;
-    if (Array.isArray(flags)) {
-        for (const f of flags) {
-            if (f !== null && typeof f === "object" &&
-                f.severity === "error")
-                return false;
-        }
+    const flags = Array.isArray(entry.verification_flags)
+        ? entry.verification_flags
+        : committed?.verificationFlags ?? [];
+    for (const f of flags) {
+        if (f !== null && typeof f === "object" &&
+            f.severity === "error")
+            return false;
     }
     return true;
 }
@@ -74,10 +126,17 @@ function isCleanRound(entry) {
  *  Collects discovered_constraints from skipped rounds along the way.
  *  Returns null when no clean round is found within maxDepth. */
 export function findSafeRestorePoint(currentRound, vaultEntries, maxDepth) {
+    // v3.2.1: exclude compile-time lineage entries — every committed round
+    // writes one (engine.ts hardcodes `success: true` on it, and it carries no
+    // round_transaction), and it precedes the feedback entry in the flat view.
+    // Treating it as a decision made every round look clean, so the restore
+    // point was always currentRound-1: dirty/rejected rounds were never
+    // skipped, depth > 1 never collected skippedDiscoveries, and the restore
+    // prompt's file list (round-coordinator) was always empty.
     const completed = vaultEntries
         .filter((e) => {
         const rnd = entryRound(e);
-        return rnd >= 1 && rnd < currentRound;
+        return rnd >= 1 && rnd < currentRound && e.task_type !== "loop_lineage";
     })
         .sort((a, b) => entryRound(b) - entryRound(a)); // newest first
     const skippedDiscoveries = [];
@@ -110,6 +169,37 @@ export function findSafeRestorePoint(currentRound, vaultEntries, maxDepth) {
     }
     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 feedback = vaultEntries.find((entry) => String(entry.task_id ?? "") === `loop:${entry.loop_id}:r${restoreRound}:feedback`);
+    const lineage = feedback && isRecord(feedback.loop_lineage)
+        ? feedback.loop_lineage
+        : null;
+    const transaction = lineage && isRecord(lineage.round_transaction)
+        ? lineage.round_transaction
+        : null;
+    const snapshot = transaction && isRecord(transaction.snapshot)
+        ? transaction.snapshot
+        : null;
+    if (!snapshot)
+        return null;
+    const evidence = Array.isArray(snapshot.afterEvidence) && snapshot.afterEvidence.length > 0
+        ? snapshot.afterEvidence
+        : Array.isArray(snapshot.beforeEvidence)
+            ? snapshot.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
@@ -119,9 +209,9 @@ export function buildBacktrackPrompt(fromRound, toRound, triggerRule, skippedDis
 /** v2.13: Files changed in the skipped rounds (from evidence snapshots).
  *  Used to show the agent exactly what needs to be reverted. */
 skippedFiles = [], 
-/** v2.13: Git HEAD commit hash at the backtrack point (current HEAD).
+/** v2.12: Git HEAD commit hash at the backtrack point (current HEAD).
  *  The agent must discard work back to the clean round's state. */
-_gitHead) {
+gitHead) {
     const lines = [
         `## ⛔ Backtrack — Round ${fromRound} → Restored to Round ${toRound}`,
         "",
@@ -151,7 +241,14 @@ _gitHead) {
         }
         lines.push("");
     }
-    lines.push("**To restore a clean workspace, run:**", "", "```bash", "# Option A: Discard all uncommitted changes (recommended)", "git checkout -- .", "git clean -fd", "", "# Option B: If you have unrelated work to keep", `git stash push -m "backtrack-safety-net-round-${fromRound}"`, "git checkout -- .", "git clean -fd", "```", "", `**If git is unavailable**, manually revert the files listed above ` +
+    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 " +
@@ -183,7 +280,7 @@ _gitHead) {
  *  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 === "success_with_remaining_criteria" && f.severity === "error");
+    const flag = flags.find((f) => f.check === CHECK_SUCCESS_WITH_REMAINING_CRITERIA && f.severity === "error");
     if (!flag)
         return null;
     return makeEnforcementResult({
@@ -199,7 +296,7 @@ function enforceSuccessWithRemainingCriteria(flags) {
  *  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 === "recurring_violation" && f.severity === "error");
+    const flag = flags.find((f) => f.check === CHECK_RECURRING_VIOLATION && f.severity === "error");
     if (!flag)
         return null;
     return makeEnforcementResult({
@@ -212,6 +309,30 @@ function enforceRecurringViolation(flags) {
         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,
+    });
+}
 /** 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).
@@ -219,7 +340,7 @@ function enforceRecurringViolation(flags) {
 function enforceEmptySuccess(selfEval, _flags, skipEvidenceRules = false) {
     if (skipEvidenceRules)
         return null; // Requires execution_evidence
-    if (!selfEval.success)
+    if (!effectiveSuccess(selfEval))
         return null;
     const ev = selfEval.execution_evidence;
     // v1.17: Missing evidence when claiming success → reject.
@@ -255,35 +376,112 @@ function enforceEmptySuccess(selfEval, _flags, skipEvidenceRules = false) {
         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",
+    });
+}
+/** 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",
+    });
+}
 /** R4: Progress has stalled for 3+ consecutive rounds.
  *  Detected by checking progress_estimate deltas across vault entries.
  *  First occurrence → REJECT (agent must change approach).
  *  Second consecutive occurrence → TERMINATE (agent cannot recover). */
-function enforceProgressStall(_selfEval, _flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules = false) {
-    if (skipEvidenceRules)
-        return null; // Requires execution_evidence
+function enforceProgressStall(selfEval, _flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules = false) {
     // Need at least 3 rounds of history
     if (currentRound < 3)
         return null;
-    const progressByRound = collectProgressByRound(vaultEntries, currentRound);
-    if (progressByRound.size < 3)
-        return null;
-    const sortedRounds = [...progressByRound.keys()].sort((a, b) => a - b);
-    const last3 = sortedRounds.slice(-3);
-    // Require all three data points to be within [currentRound-3, currentRound-1].
-    const expectedMin = currentRound - 3;
-    if (last3[0] < expectedMin || last3[2] > currentRound - 1)
-        return null;
-    const p1 = progressByRound.get(last3[0]);
-    const p2 = progressByRound.get(last3[1]);
-    const p3 = progressByRound.get(last3[2]);
-    const stallThreshold = getPolicy().evolution.progress_stall_threshold;
-    const delta12 = p2 - p1;
-    const delta23 = p3 - p2;
-    // Both deltas must be below threshold AND not near completion
-    const isStalling = delta12 < stallThreshold &&
-        delta23 < stallThreshold &&
-        p3 < 0.95;
+    let isStalling = false;
+    let stallDetail = "";
+    let stallThreshold = 0;
+    if (skipEvidenceRules) {
+        // v3.2: heuristic path has no execution_evidence — fall back to machine
+        // observations: three consecutive rounds with no git change = stall.
+        // No git signal → keep the legacy skip (the machine cannot observe).
+        const machine = machineProgressSeries(vaultEntries, currentRound, 3);
+        if (machine === null)
+            return null;
+        isStalling = machine.every((value) => !value);
+        stallDetail = "no machine-observed changes in the last 3 rounds";
+    }
+    else {
+        const progressByRound = progressWindow(vaultEntries, currentRound, selfEval);
+        if (progressByRound.size < 3)
+            return null;
+        const sortedRounds = [...progressByRound.keys()].sort((a, b) => a - b);
+        const last3 = sortedRounds.slice(-3);
+        // Require all three data points to be within [currentRound-3, currentRound-1].
+        // (collectProgressByRound already filters rnd < currentRound, so the upper
+        // bound is always satisfied — the lower bound is the real continuity guard.)
+        const expectedMin = currentRound - 3;
+        if (last3[0] < expectedMin)
+            return null;
+        const p1 = progressByRound.get(last3[0]);
+        const p2 = progressByRound.get(last3[1]);
+        const p3 = progressByRound.get(last3[2]);
+        stallThreshold = getPolicy().evolution.progress_stall_threshold;
+        const delta12 = p2 - p1;
+        const delta23 = p3 - p2;
+        // Both deltas must be below threshold AND not near completion
+        isStalling = delta12 < stallThreshold && delta23 < stallThreshold && p3 < 0.95;
+        stallDetail = `${(p1 * 100).toFixed(0)}% → ${(p2 * 100).toFixed(0)}% → ${(p3 * 100).toFixed(0)}%`;
+    }
     if (!isStalling)
         return null;
     const escalation = getPolicy().engine.enforcement_escalation_enabled;
@@ -294,7 +492,7 @@ function enforceProgressStall(_selfEval, _flags, currentRound, vaultEntries, con
         return makeEnforcementResult({
             action: "terminate",
             reason: `Progress stalled for 3+ rounds ` +
-                `(${(p1 * 100).toFixed(0)}% → ${(p2 * 100).toFixed(0)}% → ${(p3 * 100).toFixed(0)}%) ` +
+                `(${stallDetail}) ` +
                 `and agent did not resolve after escalation. Terminating loop.`,
             check: "progress_stall",
         });
@@ -304,11 +502,23 @@ function enforceProgressStall(_selfEval, _flags, currentRound, vaultEntries, con
         // reject. The agent is rolled back to the last clean round with lessons
         // injected, rather than redoing the same round with an escalation notice.
         if (getPolicy().engine.backtrack_enabled) {
+            // v2.14: A backtrack that already committed for this round (the loop
+            // is re-walking rolled-back territory with the same stall) must not
+            // loop forever — terminate instead. Without this, consecutive
+            // rejections reset on every backtrack and the R4 cycle has no exit.
+            if (hasCommittedBacktrack(vaultEntries, currentRound)) {
+                return makeEnforcementResult({
+                    action: "terminate",
+                    reason: `Progress has stalled over the last 3 rounds ` +
+                        `(${stallDetail}) and a backtrack already fired for ` +
+                        `this round. The stall persists after rollback — terminating.`,
+                    check: "progress_stall",
+                });
+            }
             return makeEnforcementResult({
                 action: "backtrack",
-                reason: `Progress has stalled: ${(p1 * 100).toFixed(0)}% → ` +
-                    `${(p2 * 100).toFixed(0)}% → ${(p3 * 100).toFixed(0)}% over the ` +
-                    `last 3 rounds (delta < ${(stallThreshold * 100).toFixed(0)}% each round).`,
+                reason: `Progress has stalled: ${stallDetail} over the last 3 rounds` +
+                    `${stallThreshold > 0 ? ` (delta < ${(stallThreshold * 100).toFixed(0)}% each round)` : ""}.`,
                 fix_instructions: "Your progress has been flat for 3 rounds. You are being rolled back " +
                     "to the last clean round. Do NOT repeat the approach that led to the stall. " +
                     "Choose a different technique or task decomposition.",
@@ -317,9 +527,8 @@ function enforceProgressStall(_selfEval, _flags, currentRound, vaultEntries, con
         }
         return makeEnforcementResult({
             action: "reject",
-            reason: `Progress has stalled: ${(p1 * 100).toFixed(0)}% → ` +
-                `${(p2 * 100).toFixed(0)}% → ${(p3 * 100).toFixed(0)}% over the ` +
-                `last 3 rounds (delta < ${(stallThreshold * 100).toFixed(0)}% each round).`,
+            reason: `Progress has stalled: ${stallDetail} over the last 3 rounds` +
+                `${stallThreshold > 0 ? ` (delta < ${(stallThreshold * 100).toFixed(0)}% each round)` : ""}.`,
             fix_instructions: "Your progress has been flat for 3 rounds. You must: " +
                 "(a) explain what is blocking progress, " +
                 "(b) propose a DIFFERENT technique or task decomposition, and " +
@@ -333,16 +542,15 @@ function enforceProgressStall(_selfEval, _flags, currentRound, vaultEntries, con
         return makeEnforcementResult({
             action: "terminate",
             reason: `Progress stalled for 3+ rounds ` +
-                `(${(p1 * 100).toFixed(0)}% → ${(p2 * 100).toFixed(0)}% → ${(p3 * 100).toFixed(0)}%) ` +
+                `(${stallDetail}) ` +
                 `and agent did not resolve after previous rejection. Terminating loop.`,
             check: "progress_stall",
         });
     }
     return makeEnforcementResult({
         action: "reject",
-        reason: `Progress has stalled: ${(p1 * 100).toFixed(0)}% → ` +
-            `${(p2 * 100).toFixed(0)}% → ${(p3 * 100).toFixed(0)}% over the ` +
-            `last 3 rounds (delta < ${(stallThreshold * 100).toFixed(0)}% each round).`,
+        reason: `Progress has stalled: ${stallDetail} over the last 3 rounds` +
+            `${stallThreshold > 0 ? ` (delta < ${(stallThreshold * 100).toFixed(0)}% each round)` : ""}.`,
         fix_instructions: "Your progress has been flat for 3 rounds. You must: " +
             "(a) explain what is blocking progress, " +
             "(b) propose a DIFFERENT technique or task decomposition, and " +
@@ -361,24 +569,45 @@ function enforceProgressStall(_selfEval, _flags, currentRound, vaultEntries, con
  *  Termination only happens on the second consecutive flatline detection.
  *
  *  Uses the engine.max_circuit_breaker policy value as the lookback window. */
-function enforceProgressStallTerminal(_selfEval, _flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules = false) {
-    if (skipEvidenceRules)
-        return null; // Requires execution_evidence
+function enforceProgressStallTerminal(selfEval, _flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules = false) {
     const breakerSize = getPolicy().engine.max_circuit_breaker;
     if (currentRound < breakerSize || vaultEntries.length < breakerSize)
         return null;
-    const progressByRound = collectProgressByRound(vaultEntries, currentRound);
-    if (progressByRound.size < breakerSize)
-        return null;
-    const sortedRounds = [...progressByRound.keys()].sort((a, b) => a - b);
-    const recent = sortedRounds.slice(-breakerSize);
-    // Check that progress values are ALL identical (delta = 0).
-    // Use epsilon comparison — JSON round-trips can produce float drift
-    // (e.g. 0.3 vs 0.30000000000000004) that would defeat strict === .
-    const EPSILON = 1e-10;
-    const first = progressByRound.get(recent[0]);
-    const allFlat = recent.every((r) => Math.abs((progressByRound.get(r) ?? 0) - first) < EPSILON);
-    if (!allFlat || first >= 0.95)
+    let allFlat = false;
+    let flatDetail = "";
+    if (skipEvidenceRules) {
+        // v3.2: heuristic path has no execution_evidence — fall back to machine
+        // observations: N consecutive rounds with no git change = flatline.
+        // No git signal → keep the legacy skip (the machine cannot observe).
+        const machine = machineProgressSeries(vaultEntries, currentRound, breakerSize);
+        if (machine === null)
+            return null;
+        allFlat = machine.every((value) => !value);
+        flatDetail = `no machine-observed changes for ${breakerSize} consecutive rounds`;
+    }
+    else {
+        const progressByRound = progressWindow(vaultEntries, currentRound, selfEval);
+        if (progressByRound.size < breakerSize)
+            return null;
+        const sortedRounds = [...progressByRound.keys()].sort((a, b) => a - b);
+        const recent = sortedRounds.slice(-breakerSize);
+        // v2.14: continuity guard (mirrors R4) — "consecutive" means the most
+        // recent rounds. Rounds without execution_evidence are unknown motion,
+        // not zero motion; taking "the last N rounds that happened to report
+        // progress" terminated loops whose recent rounds simply had no data.
+        if (recent[0] < currentRound - breakerSize)
+            return null;
+        // Check that progress values are ALL identical (delta = 0).
+        // Use epsilon comparison — JSON round-trips can produce float drift
+        // (e.g. 0.3 vs 0.30000000000000004) that would defeat strict === .
+        const EPSILON = 1e-10;
+        const first = progressByRound.get(recent[0]);
+        allFlat = recent.every((r) => Math.abs((progressByRound.get(r) ?? 0) - first) < EPSILON);
+        if (!allFlat || first >= 0.95)
+            return null;
+        flatDetail = `completely flat at ${(first * 100).toFixed(0)}%`;
+    }
+    if (!allFlat)
         return null;
     const escalation = getPolicy().engine.enforcement_escalation_enabled;
     // v2.7: When escalation is enabled, give one rejection round with a
@@ -386,7 +615,7 @@ function enforceProgressStallTerminal(_selfEval, _flags, currentRound, vaultEntr
     if (consecutiveRejections >= 1) {
         return makeEnforcementResult({
             action: "terminate",
-            reason: `Progress has been completely flat at ${(first * 100).toFixed(0)}% ` +
+            reason: `Progress has been ${flatDetail} ` +
                 `for ${breakerSize} consecutive rounds and agent did not resolve ` +
                 `after escalation. The agent is making zero forward motion.`,
             check: "progress_stall_terminal",
@@ -397,9 +626,21 @@ function enforceProgressStallTerminal(_selfEval, _flags, currentRound, vaultEntr
         // reject. The agent is rolled back to the last clean round with a
         // "radically different strategy" lesson injected.
         if (getPolicy().engine.backtrack_enabled) {
+            // v2.14: Same deadlock guard as R4 — a backtrack that already fired
+            // for this round means the loop is re-walking rolled-back territory.
+            if (hasCommittedBacktrack(vaultEntries, currentRound)) {
+                return makeEnforcementResult({
+                    action: "terminate",
+                    reason: `Progress has been ${flatDetail} ` +
+                        `for ${breakerSize} consecutive rounds and a backtrack already ` +
+                        `fired for this round. Flatline persists after rollback — ` +
+                        `terminating the loop.`,
+                    check: "progress_stall_terminal",
+                });
+            }
             return makeEnforcementResult({
                 action: "backtrack",
-                reason: `Progress has been completely flat at ${(first * 100).toFixed(0)}% ` +
+                reason: `Progress has been ${flatDetail} ` +
                     `for ${breakerSize} consecutive rounds. The agent is making zero ` +
                     `forward motion.`,
                 fix_instructions: "Your progress has been exactly flat — zero forward motion. " +
@@ -410,7 +651,7 @@ function enforceProgressStallTerminal(_selfEval, _flags, currentRound, vaultEntr
         }
         return makeEnforcementResult({
             action: "reject",
-            reason: `Progress has been completely flat at ${(first * 100).toFixed(0)}% ` +
+            reason: `Progress has been ${flatDetail} ` +
                 `for ${breakerSize} consecutive rounds. The agent is making zero ` +
                 `forward motion.`,
             fix_instructions: "Your progress has been exactly flat — you are making zero forward " +
@@ -424,7 +665,7 @@ function enforceProgressStallTerminal(_selfEval, _flags, currentRound, vaultEntr
     }
     return makeEnforcementResult({
         action: "terminate",
-        reason: `Progress has been completely flat at ${(first * 100).toFixed(0)}% ` +
+        reason: `Progress has been ${flatDetail} ` +
             `for ${breakerSize} consecutive rounds. The agent is making zero ` +
             `forward motion and cannot recover.`,
         check: "progress_stall_terminal",
@@ -477,15 +718,74 @@ function enforceMaxRejections(consecutiveRejections) {
  *  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. */
-function hasSemanticAnchor(clarification) {
-    // v2.11: Constraint / criterion / sub-goal ID patterns
-    if (/[c]r?-[a-f0-9]{8}/.test(clarification))
-        return true;
-    if (/sg-[a-f0-9]{8}/.test(clarification))
-        return true;
-    // File path references (e.g. "src/auth/login.ts", "lib/utils.go")
-    if (/[\w./-]+\.[a-z]{2,6}\b/i.test(clarification))
-        return true;
+/** 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. */
@@ -522,13 +822,16 @@ function buildClarificationRejectionNotice(streak) {
  *
  *  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) {
+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: Semantic anchor detection — requires concrete references
-    const hasAnchor = clarification ? hasSemanticAnchor(clarification) : false;
+    // 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
@@ -574,13 +877,30 @@ function enforceIntentDrift(flags, selfEval, consecutiveRejections, driftClarifi
             check: "intent_drift",
         });
     }
-    // No clarification or too short — original behavior
-    if (consecutiveRejections >= 1) {
+    // 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 was warned about intent-action drift but continues to do ` +
-                `work unrelated to its declared next_action without explanation. ` +
-                `The agent cannot or will not follow its own plan — terminating loop.`,
+            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",
         });
     }
@@ -674,10 +994,17 @@ driftClarificationStreak = 0) {
         () => enforceSuccessWithRemainingCriteria(flags),
         () => enforceRecurringViolation(flags),
         () => enforceEmptySuccess(selfEval, flags, skipEvidenceRules),
+        // v2.14: R-EVID — a required command failure or self-contradictory
+        // outcome claim contradicts the success claim before commit
+        () => enforceEvidenceContradiction(flags),
+        // v2.12: R8 — success with zero machine-verifiable evidence
+        () => enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections),
         () => enforceProgressStall(selfEval, flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules),
         () => enforceProgressStallTerminal(selfEval, flags, currentRound, vaultEntries, consecutiveRejections, skipEvidenceRules),
         () => enforceMaxRejections(consecutiveRejections),
-        () => enforceIntentDrift(flags, selfEval, consecutiveRejections, driftClarificationStreak),
+        () => enforceIntentDrift(flags, selfEval, consecutiveRejections, driftClarificationStreak, vaultEntries),
+        // v2.12: R9 — post-backtrack workspace not restored
+        () => enforceBacktrackNotRestored(flags, vaultEntries, currentRound),
     ];
     for (const rule of rules) {
         const result = rule();