loopforge 3.8.2 → 3.9.0

package/dist/enforcement-gate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enforcement-gate.d.ts","sourceRoot":"","sources":["../src/enforcement-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AA0FvB;;iEAEiE;AACjE,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,UAAU,EAAE,EAC1B,QAAQ,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAgCxD;AAED;;;sCAGsC;AACtC,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,UAAU,EAAE,GACzB,MAAM,GAAG,IAAI,CAWf;AAED;;;;oDAIoD;AACpD,MAAM,WAAW,sBAAsB;IACrC,sEAAsE;IACtE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,yEAAyE;IACzE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,sEAAsE;IACtE,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;;;;;;;;0BAS0B;AAC1B,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAClC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,EAAE,CA6BX;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,EAAE;AAC5B;gEACgE;AAChE,YAAY,GAAE,MAAM,EAAO;AAC3B;mEACmE;AACnE,OAAO,CAAC,EAAE,MAAM;AAChB,2EAA2E;AAC3E,eAAe,CAAC,EAAE,MAAM;AACxB;uDACuD;AACvD,QAAQ,CAAC,EAAE,sBAAsB,GAChC,MAAM,CAmKR;AAwrBD,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,kBAAkB,EAChC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,UAAU,EAAE,EAC1B,qBAAqB,GAAE,MAAU;AACjC;;;;uCAIuC;AACvC,kBAAkB,GAAE,MAAW,GAC9B,iBAAiB,CAoGnB;AAED;;;;;;;;;;;;;;sEAcsE;AACtE,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,iBAAiB,EAChC,iBAAiB,GAAE,gBAAgB,EAAO,GACzC,MAAM,CA6CR"}
+{"version":3,"file":"enforcement-gate.d.ts","sourceRoot":"","sources":["../src/enforcement-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AAwDvB;;iEAEiE;AACjE,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,UAAU,EAAE,EAC1B,QAAQ,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAgCxD;AAED;;;;;;mCAMmC;AACnC,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,UAAU,EAAE,GACzB,uBAAuB,GAAG,IAAI,CAmBhC;AAED;;;;oDAIoD;AACpD,MAAM,WAAW,sBAAsB;IACrC,sEAAsE;IACtE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,yEAAyE;IACzE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,sEAAsE;IACtE,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;;;;;;;;0BAS0B;AAC1B,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAClC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,EAAE,CA6BX;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,EAAE;AAC5B;gEACgE;AAChE,YAAY,GAAE,MAAM,EAAO;AAC3B;mEACmE;AACnE,OAAO,CAAC,EAAE,MAAM;AAChB,2EAA2E;AAC3E,eAAe,CAAC,EAAE,MAAM;AACxB;uDACuD;AACvD,QAAQ,CAAC,EAAE,sBAAsB,GAChC,MAAM,CAuKR;AAswBD,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,kBAAkB,EAChC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,UAAU,EAAE,EAC1B,qBAAqB,GAAE,MAAU;AACjC;;;;uCAIuC;AACvC,kBAAkB,GAAE,MAAW;AAC/B;;;;yCAIyC;AACzC,gBAAgB,GAAE,OAAe;AACjC;6CAC6C;AAC7C,cAAc,GAAE,OAAO,GAAG,IAAW,GACpC,iBAAiB,CA2GnB;AAED;;;;;;;;;;;;;;sEAcsE;AACtE,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,iBAAiB,EAChC,iBAAiB,GAAE,gBAAgB,EAAO,GACzC,MAAM,CA6CR"}

package/dist/enforcement-gate.js

@@ -24,33 +24,6 @@ import { derivationRounds, decodeCommittedRound, machineEvidenceForRound, } from
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
-/** Collect progress estimates from vault entries into a round→estimate map.
- *  Shared by the progress evaluator's stall and flatline tiers. */
-function collectProgressByRound(vaultEntries, currentRound) {
-    const progressByRound = new Map();
-    for (const round of derivationRounds(vaultEntries, currentRound)) {
-        const progress = round.executionReport?.progress_estimate;
-        if (typeof progress === "number")
-            progressByRound.set(round.round, progress);
-    }
-    return progressByRound;
-}
-/** v3.2.1: R4/R5 progress window — after a backtrack committed for this
- *  round, the agent's redo submission is the freshest data point. The
- *  pre-rollback history (which triggered the stall) stays in the vault and
- *  the redo does not commit while it is being evaluated, so without this
- *  the window never changes: a genuinely fixed redo is rejected forever and
- *  the loop dies in a spurious terminate. A redo that is STILL stalled
- *  keeps the window flat and hits the normal reject → terminate ladder. */
-function progressWindow(vaultEntries, currentRound, selfEval) {
-    const progressByRound = collectProgressByRound(vaultEntries, currentRound);
-    if (hasCommittedBacktrack(vaultEntries, currentRound)) {
-        const pe = selfEval.execution_report?.progress_estimate;
-        if (typeof pe === "number")
-            progressByRound.set(currentRound, pe);
-    }
-    return progressByRound;
-}
 // ═══════════════════════════════════════════════════════════════════════════
 // v2.10: Backtrack helpers
 // ═══════════════════════════════════════════════════════════════════════════
@@ -118,22 +91,28 @@ 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) {
+export function findBacktrackTargetSnapshot(restoreRound, vaultEntries) {
     const committed = derivationRounds(vaultEntries)
         .find((view) => view.round === restoreRound);
     if (!committed)
         return null;
-    const evidence = machineEvidenceForRound(committed);
-    for (const item of evidence) {
+    for (const item of machineEvidenceForRound(committed)) {
         if (!isRecord(item) || item.providerId !== "git" || !isRecord(item.data))
             continue;
         const head = item.data.head;
-        if (typeof head === "string" && head.length > 0)
-            return head;
+        if (typeof head !== "string" || head.length === 0)
+            continue;
+        const dirtyFiles = [];
+        for (const field of ["tracked", "staged", "untracked"]) {
+            const list = item.data[field];
+            if (!Array.isArray(list))
+                continue;
+            for (const file of list) {
+                if (typeof file === "string" && !dirtyFiles.includes(file))
+                    dirtyFiles.push(file);
+            }
+        }
+        return { head, dirtyFiles };
     }
     return null;
 }
@@ -215,8 +194,7 @@ recovery) {
     // 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 verifiable forward motion — no new files changed, no ` +
-            `criteria met, no progress estimates moving.`, "", "The approach used in those rounds **did not work**. It should not be " +
+            `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 ──────────────────────────────────────────
@@ -242,9 +220,14 @@ recovery) {
     // 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 a file whose fingerprint still matches the failed round proves the " +
-            "restore did not happen.", "");
+            "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}** — ` +
@@ -350,23 +333,69 @@ function enforceEvidenceContradiction(flags) {
 /** v3.3: R-EVID-VERIFY — the verification command's entrypoint changed in
  *  the same round the command ran. The runtime executed a script the agent
  *  just rewrote, so the "machine observation" has no stable baseline and
- *  cannot back the success claim. Reject so the agent resubmits the SAME
- *  round with the entrypoint unchanged (a freshly created entrypoint passes
- *  on the redo — the diff no longer contains it). */
-function enforceVerificationEntrypointTampered(flags) {
+ *  cannot back the success claim.
+ *
+ *  v3.8.3: the row owns its whole ladder (RULE_TABLE ladder: "internal").
+ *
+ *  The old text said "resubmit with the entrypoint unchanged", which is not an
+ *  instruction the agent can carry out when the round CREATED the file — it
+ *  did not exist to keep unchanged — and the round's baseline never moves, so
+ *  the same file was re-detected on every retry until the uniform ladder
+ *  terminated the loop. The recovery text now states the round-start state of
+ *  each file (the gate puts it in the detail) and the two routes that exist:
+ *  restore it, or take the rollback so the work is redone in a round whose
+ *  baseline already contains the entrypoint. Repeated non-restoration is a
+ *  rollback, not a kill. */
+function enforceVerificationEntrypointTampered(flags, vaultEntries, currentRound, consecutiveRejections, lastRejectionCheck) {
     const flag = flags.find((f) => f.check === CHECK_VERIFICATION_ENTRYPOINT_MODIFIED && f.severity === "error");
     if (!flag)
         return null;
+    const check = "verification_entrypoint_modified";
+    const ownStreak = lastRejectionCheck === check ? consecutiveRejections : 0;
+    if (ownStreak >= 1) {
+        // The agent has already been told, once, exactly what to restore and has
+        // not restored it. Retrying the same round cannot help — the baseline is
+        // frozen on purpose — so escalate to the rollback, which redoes the work
+        // in a fresh round where the entrypoint is part of the starting state.
+        // `backtrack_enabled` off, or a rollback already committed for this round
+        // (which would loop), leaves termination as the honest end.
+        if (getPolicy().engine.backtrack_enabled &&
+            !hasCommittedBacktrack(vaultEntries, currentRound)) {
+            return makeEnforcementResult({
+                action: "backtrack",
+                reason: "The verification command's entrypoint is still not back to its " +
+                    "round-start state after being asked once, so this round cannot " +
+                    "produce a trustworthy observation.",
+                fix_instructions: "After the rollback, restore the workspace as the Recovery Brief " +
+                    "states. The restore check requires every skipped file to differ " +
+                    "from its state at the rollback, so no entrypoint may still be an " +
+                    "uncommitted change: revert it, or make a script you intend to keep " +
+                    "part of the committed workspace before the round that runs it. " +
+                    "Then redo the round.",
+                check,
+            });
+        }
+        return makeEnforcementResult({
+            action: "terminate",
+            reason: "The verification command's entrypoint was changed in the round it " +
+                "verified and was not restored after the rollback.",
+            check,
+        });
+    }
     return makeEnforcementResult({
         action: "reject",
         reason: flag.detail,
         fix_instructions: "The verification command entrypoint changed in this round, so its " +
-            "result cannot be trusted as machine evidence. You must: (a) keep the " +
-            "verification command (and its entrypoint files) stable, (b) resubmit " +
-            "your SelfEvaluation for the SAME round with the entrypoint unchanged " +
-            "so the runtime can re-run it against a stable baseline, and (c) do " +
-            "NOT rewrite the verification script to make it pass.",
-        check: "verification_entrypoint_modified",
+            "result cannot be trusted as machine evidence — the runtime executed a " +
+            "script this round rewrote. To make this round verifiable again: restore " +
+            "each of those files to the state it had when the round started (for a " +
+            "file that did not exist then, that means removing it), then resubmit " +
+            "this same round's SelfEvaluation. Do NOT rewrite the verification " +
+            "script to make it pass. If the work genuinely needs that file, this " +
+            "round cannot verify it: make the file part of the committed workspace " +
+            "first — a script that is not an uncommitted change — and let a later " +
+            "round run it.",
+        check,
     });
 }
 /** R8 (v2.12/v3.7): The single success-evidence row. The verification gate
@@ -374,12 +403,20 @@ function enforceVerificationEntrypointTampered(flags) {
  *  missing-evidence arm (v3.7: the ex-R3 empty_success posture moved into
  *  checkSuccessWithoutVerifiedEvidence) or the claims arm (zero verified
  *  claims). First occurrence → reject with concrete evidence requirements;
- *  second consecutive → terminate. */
-function enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections) {
+ *  second consecutive → terminate.
+ *
+ *  v3.8.3: "consecutive" means consecutive for THIS check (L4's own-streak
+ *  rule, which until now reached only the uniform rows and the contract row).
+ *  The persisted counter is one scalar, so a success-evidence round arriving
+ *  after two unrelated rejections used to terminate on its FIRST occurrence. */
+function enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections, lastRejectionCheck) {
     const flag = flags.find((f) => f.check === CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE && f.severity === "error");
     if (!flag)
         return null;
-    if (consecutiveRejections >= 2) {
+    const ownStreak = lastRejectionCheck === CHECK_SUCCESS_WITHOUT_VERIFIED_EVIDENCE
+        ? consecutiveRejections
+        : 0;
+    if (ownStreak >= 2) {
         return makeEnforcementResult({
             action: "terminate",
             reason: "Repeated success claims with zero machine-verifiable evidence.",
@@ -387,7 +424,7 @@ function enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections) {
         });
     }
     const escalation = getPolicy().engine.enforcement_escalation_enabled &&
-        consecutiveRejections >= 1
+        ownStreak >= 1
         ? buildEscalationNotice()
         : "";
     return makeEnforcementResult({
@@ -471,12 +508,36 @@ function enforceContractItemsUnverified(flags, currentRound, vaultEntries, conse
  *  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. Repeated drift terminates. */
-function enforceScopeDrift(flags, consecutiveRejections) {
+ *  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;
-    if (consecutiveRejections >= 2) {
+    // 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 ` +
@@ -485,7 +546,7 @@ function enforceScopeDrift(flags, consecutiveRejections) {
         });
     }
     const escalation = getPolicy().engine.enforcement_escalation_enabled &&
-        consecutiveRejections >= 1
+        ownStreak >= 1
         ? buildEscalationNotice()
         : "";
     return makeEnforcementResult({
@@ -498,12 +559,16 @@ function enforceScopeDrift(flags, consecutiveRejections) {
         // 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 the extended scope as the next round's " +
-            "round_contract. Scope drift is a machine fact — no explanation waives " +
+            "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",
@@ -543,101 +608,74 @@ function enforceBacktrackNotRestored(flags, vaultEntries = [], currentRound = 0)
     });
 }
 /** Shared observation pipeline for the progress evaluator (stall window,
- *  flatline tier). Machine git motion is exculpatory only: it may veto a
- *  self-reported stall but can never create one. */
-function evaluateStallWindow(tier, selfEval, currentRound, vaultEntries,
+ *  flatline tier). Only observable machine history can establish a stall. */
+function evaluateStallWindow(tier, 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. */
-machineBackedSuccess) {
+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).
     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)
+        return null;
     const window = tier === "progress_stall"
         ? 3
         : Math.max(1, getPolicy().engine.stall_lookback_rounds);
     if (currentRound < window)
         return null;
-    const progressByRound = progressWindow(vaultEntries, currentRound, selfEval);
-    const threshold = getPolicy().evolution.progress_stall_threshold;
-    let stalled = false;
-    let detail = "";
-    // v3.8.1: when the MACHINE series is observable it decides the verdict, and
-    // the agent's own estimates are not consulted at all. Reading the estimates
-    // first (the pre-3.8.1 order) let an agent cancel a stall by writing a
-    // rising `progress_estimate` every round — a verdict about machine motion
-    // that the agent's own report could move, which is the one thing an external
-    // verifier must not allow. Machine motion still only ever EXCUSES: it can
-    // veto a stall it did not create; it can never create one.
-    //
-    // The self-reported window is the FALLBACK for a loop with no machine
-    // history to read (no git provider, or fewer rounds than the window). There
-    // the evaluator can only catch a stall the agent's own reports state, and
-    // the near-completion guard keeps it from rejecting a loop that reports
-    // itself nearly done.
     const machine = machineProgressSeries(vaultEntries, currentRound, window);
-    if (machine !== null) {
-        stalled = machine.every((value) => !value);
-        detail = tier === "progress_stall"
-            ? `no machine-observed changes in the last ${window} rounds`
-            : `no machine-observed changes for ${window} consecutive rounds`;
-    }
-    else if (progressByRound.size >= window) {
-        const recent = [...progressByRound.keys()].sort((a, b) => a - b).slice(-window);
-        if (recent[0] < currentRound - window)
-            return null;
-        const values = recent.map((round) => progressByRound.get(round));
-        if (values[values.length - 1] >= 0.95)
-            return null;
-        if (tier === "progress_stall") {
-            stalled = values.slice(1).every((value, index) => value - values[index] < threshold);
-            detail = `${values.map((value) => `${(value * 100).toFixed(0)}%`).join(" → ")}` +
-                " (agent-reported, no machine history to read)";
-        }
-        else {
-            const first = values[0];
-            stalled = values.every((value) => Math.abs(value - first) < 1e-10);
-            detail = `completely flat at ${(first * 100).toFixed(0)}%`;
-        }
-    }
-    else {
-        return null;
-    }
-    if (!stalled)
+    if (machine === null || machine.some((value) => value))
         return null;
-    return { tier, detail, window, threshold };
+    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 };
 }
 /** Shared progress escalation and backtrack deadlock guard (v3.7: one
- * evaluator). The flatline tier keeps its steeper threshold-0 ladder while
+ * evaluator). The flatline tier keeps its steeper ladder while
  * using the same mechanics — the tier is an internal diagnostic only. */
-function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections) {
-    const { tier, detail, window, threshold } = verdict;
+function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections, lastRejectionCheck) {
+    const { tier, detail, window } = verdict;
     const flatline = tier === "progress_flatline";
     const escalation = getPolicy().engine.enforcement_escalation_enabled;
     const stalledReason = flatline
         ? `Progress has been ${detail} for ${window} consecutive rounds.`
-        : `Progress has stalled: ${detail} over the last ${window} rounds` +
-            `${threshold > 0 ? ` (delta < ${(threshold * 100).toFixed(0)}% each round)` : ""}.`;
+        : `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 check = "progress_stall";
-    if ((flatline && consecutiveRejections >= 1) || consecutiveRejections >= 2) {
+    // 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.
+    const ownStreak = lastRejectionCheck === check ? consecutiveRejections : 0;
+    if ((flatline && ownStreak >= 1) || ownStreak >= 2) {
         return makeEnforcementResult({
             action: "terminate",
             reason: `${stalledReason} The stall persisted after escalation. Terminating loop.`,
             check,
         });
     }
-    if (consecutiveRejections >= 1 && !escalation) {
+    if (ownStreak >= 1 && !escalation) {
         return makeEnforcementResult({
             action: "terminate",
             reason: `${stalledReason} The stall persisted after the previous rejection. Terminating loop.`,
             check,
         });
     }
-    const escalated = flatline ? escalation : consecutiveRejections >= 1 && escalation;
+    const escalated = flatline ? escalation : ownStreak >= 1 && escalation;
     if (escalated && getPolicy().engine.backtrack_enabled) {
         if (hasCommittedBacktrack(vaultEntries, currentRound)) {
             return makeEnforcementResult({
@@ -672,19 +710,13 @@ function resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiv
         check,
     });
 }
-/** v3.7: The single progress evaluator (former R4 stall and R5 flatline rows
- *  merged into one). The stall-tier window is consulted first — under the
- *  default positive threshold its predicate covers exactly-flat runs too,
- *  reproducing the v3.6 R4-before-R5 shadowing; the flatline tier is
- *  consulted only when the stall predicate cannot hold (threshold ≤ 0,
- *  shorter lookback configs), where it applies its steeper disposition
- *  ladder. Machine git motion is exculpatory only — it may veto a
- *  self-reported stall but can never create one. */
-function enforceProgressStall(selfEval, _flags, currentRound, vaultEntries, consecutiveRejections, machineBackedSuccess) {
-    const verdict = evaluateStallWindow("progress_stall", selfEval, currentRound, vaultEntries, machineBackedSuccess)
-        ?? evaluateStallWindow("progress_flatline", selfEval, currentRound, vaultEntries, machineBackedSuccess);
+/** 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);
     return verdict
-        ? resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections)
+        ? resolveStallDisposition(verdict, currentRound, vaultEntries, consecutiveRejections, lastRejectionCheck)
         : null;
 }
 /** R6: Two consecutive rejections → escalate (v2.7) or terminate.
@@ -694,7 +726,15 @@ function enforceProgressStall(selfEval, _flags, currentRound, vaultEntries, cons
  *  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) {
+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;
     const escalation = getPolicy().engine.enforcement_escalation_enabled;
     if (escalation) {
         if (consecutiveRejections >= 3) {
@@ -783,7 +823,11 @@ 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: ["verification_entrypoint_modified"], ladder: "uniform", terminalAfter: 2, 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: ["success_without_verified_evidence"], ladder: "internal" },
     { checks: ["round_scope_drift"], ladder: "internal" },
     // v3.8.1: "internal" — the handler owns this row's ladder (it must terminate
@@ -844,7 +888,16 @@ export function enforceRound(selfEval, verifyResult, currentRound, vaultEntries,
  *  counter only ever measures one check's streak — this field names that
  *  check and lets uniform rows escalate on THEIR OWN streak instead of
  *  inheriting an unrelated history. */
-lastRejectionCheck = "") {
+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) {
     const { flags } = verifyResult;
     // Run enforcement rules in priority order — the array order IS the
     // priority; the R-labels in the comments are historical (RULE_TABLE is
@@ -858,7 +911,7 @@ lastRejectionCheck = "") {
         // v3.3: R-EVID-VERIFY — the verification command entrypoint changed in
         // the same round it ran. Runs before R8: when the entrypoint is tainted
         // R8 also fires, but this reason is more specific.
-        () => enforceVerificationEntrypointTampered(flags),
+        () => enforceVerificationEntrypointTampered(flags, vaultEntries, currentRound, consecutiveRejections, lastRejectionCheck),
         // v3.5: contract completion claimed without its verification_plan
         // commands passing — runs before R-C1: the completion-truth question
         // outranks boundary nuance.
@@ -867,20 +920,22 @@ lastRejectionCheck = "") {
         // contract's own reason.)
         // v2.12/v3.7: R8 — the single success-evidence row (empty/missing-evidence
         // arm merged from the former R3 empty_success posture + claims arm)
-        () => enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections),
+        () => enforceSuccessWithoutVerifiedEvidence(flags, consecutiveRejections, lastRejectionCheck),
         // v3.3: R-C2 — files changed outside the contract's declared scope
-        () => enforceScopeDrift(flags, consecutiveRejections),
+        () => enforceScopeDrift(flags, consecutiveRejections, lastRejectionCheck, scopeDriftWaiver),
         // 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) —
         // reject → backtrack → terminate with the deadlock guard
-        () => enforceProgressStall(selfEval, flags, currentRound, vaultEntries, consecutiveRejections, verifyResult.machineBackedSuccess),
+        () => enforceProgressStall(flags, currentRound, vaultEntries, consecutiveRejections, verifyResult.machineBackedSuccess, lastRejectionCheck, inFlightMotion),
         // R6: rejection-counter catch-all (evaluated only when no row above
         // fired — a clean-looking round carrying a high persisted counter)
         // v3.7.1: cited gate without an approved human decision
         () => enforceUserGateUnresolved(flags),
-        () => enforceMaxRejections(consecutiveRejections),
+        // 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),
     ];