pi-goal-list-loop-audit 0.29.18 → 0.29.19

package/extensions/goal-loop-forever.ts

@@ -10,7 +10,7 @@
  * self-reports progress.
  */
 
-import { existsSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 
 export type LoopDirection = "min" | "max";
@@ -55,6 +55,22 @@ export interface LoopState {
    * (a real number that didn't improve); a broken measure says nothing
    * about movement and must stop the loop with its own loud reason. */
   consecutiveNullMeasures?: number;
+  /** v0.29.19: consecutive provider-error/user-abort turns. Exempt from
+   * stall/stuck/plateau accounting (the model never got a say — a dead
+   * turn is not evidence about the work); capped so an outage stops the
+   * loop with an honest reason instead of burning turns forever. Field
+   * 2026-07-31 (MiniMax token-plan 429 storm): hegemon false-plateau'd
+   * with 13 open findings, polis with 3+, hellhunter stuck-stopped at
+   * iter 93 — every counted turn was a dead 429 turn. */
+  consecutiveErrors?: number;
+  /** v0.29.19: audit plateau reprieves used so far (open findings remain
+   * = the well isn't dry, so the plateau stop stands down). Bounded by
+   * AUDIT_PLATEAU_MAX_REPRIEVES — the next plateau stop stands, honestly
+   * named. */
+  auditPlateauReprieves?: number;
+  /** v0.29.19: one-shot shove injected into the next iteration's prompt
+   * after a plateau reprieve; cleared on use. */
+  auditReprieveNote?: string;
   bestValue: number | null;
   lastValue: number | null;
   /** v0.29.10: audit loops (measure counts open findings) get a deferred
@@ -430,6 +446,24 @@ export function auditTarget(): string {
   return `Audit the project for real problems and fix them, iteration by iteration — FIX-FIRST: the open backlog comes down before new hunting (user design 2026-07-30: "audit to fix then audit then fix again" — not find-and-present). Every iteration: (1) FIX the highest-severity OPEN finding(s) in ${AUDIT_FINDINGS_REL} — real fixes, committed — then check the box: "- [x] … — fixed in <commit>". An iteration that closes nothing while OPEN findings remain is a wasted iteration: if the top findings are genuinely blocked, say what blocks them in one line and work the first unblocked one — "no new action this turn" is never an acceptable iteration while open boxes exist. (2) RE-AUDIT on cadence, not every iteration — run a fresh audit pass (spawn Explore subagents for breadth; hunting real issues: bugs, broken flows, regressions, drift between docs and code, dead code, security holes; not style nits, not speculative refactors) ONLY when no OPEN findings remain, when roughly ten iterations have passed since the last pass, or when your own fixes plausibly broke something. (3) Append every NEW finding as one checkbox line "- [ ] SEVERITY: short description (file:line)" to ${AUDIT_FINDINGS_REL} (create the file on the first finding; append-only — never delete, rewrite, or reorder existing lines; never re-report a finding already listed). (4) Honesty law: never fabricate findings to look busy; never mark a finding fixed without the fix commit existing. The orchestrator counts CLOSED findings every iteration (direction=max): discovery alone does not move the metric — landing fixes does. When a full audit pass surfaces nothing new AND no open findings remain, say so plainly — the plateau stop ends the loop when the well is dry.`;
 }
 
+/** v0.29.19: how many times an audit loop's plateau stop stands down
+ * while open findings remain. The plateau after the last reprieve stops
+ * the loop with the honest "no closure despite K open findings" reason. */
+export const AUDIT_PLATEAU_MAX_REPRIEVES = 2;
+
+/** v0.29.19: orchestrator-side count of OPEN audit findings — the honest
+ * "is the well dry" signal for audit-loop plateau decisions. The plateau
+ * stop means "the well is dry"; with K open boxes it is objectively not. */
+export function countOpenAuditFindings(cwd: string): number {
+  try {
+    const p = join(cwd, AUDIT_FINDINGS_REL);
+    if (!existsSync(p)) return 0;
+    return readFileSync(p, "utf-8").split("\n").filter((l) => /^- \[ \]/.test(l)).length;
+  } catch {
+    return 0;
+  }
+}
+
 // ---- /goal audit-project (v0.29.8) ----
 
 /**

package/extensions/loops/goal.ts

@@ -171,7 +171,11 @@ import {
   respecTarget,
   auditMeasureCmd,
   auditTarget,
+  AUDIT_PLATEAU_MAX_REPRIEVES,
+  countOpenAuditFindings,
+  AUDIT_FINDINGS_REL,
   projectAuditTarget,
+  type LoopTickOutcome,
   HELD_ON_RESTORE,
   type LoopState,
 } from "../goal-loop-forever.js";
@@ -267,6 +271,13 @@ export function __testOnlyResetStaleFlag(): void {
   extensionApiStale = false;
 }
 
+/** Test-only: release the claimed session owner so a later test file can
+ * drive agent_end with its own sessionManager identity (ownerSession is
+ * process-wide module state; behavioral-orchestrator claims it first). */
+export function __testOnlyResetOwnerSession(): void {
+  ownerSession = null;
+}
+
 /** v0.28.1 (S3): side-effect-free staleness probe — getSessionName()
  * routes through pi's assertActive() and throws the stale signature iff
  * pi invalidated this factory handle (session replacement). A positive
@@ -461,6 +472,11 @@ let heartbeatTimer: NodeJS.Timeout | null = null;
 
 const ZOMBIE_RUN_SILENT_MS = 20 * 60_000;
 const ZOMBIE_RUN_ALERT_THROTTLE_MS = 10 * 60_000;
+// v0.29.19: dead-turn caps (agent_end exemption path). 6 consecutive
+// provider-error turns = a real outage, not bad luck — stop honestly.
+// 3 consecutive user aborts = the user means it (user aborts mean STOP).
+const LOOP_MAX_CONSECUTIVE_ERRORS = 6;
+const LOOP_MAX_CONSECUTIVE_ABORTS = 3;
 
 function noteActivity(real = false): void {
   lastActivityAt = Date.now();
@@ -2338,9 +2354,13 @@ function sendLoopTurn(): void {
   }
   // v0.24.0: a stuck intervention REPLACES the pep talk — the rotating
   // directive names why the loop is stuck and what rung of the ladder it's on.
-  const interventionNote = (loop.consecutiveStuck ?? 0) > 0 && loop.lastStuckReason
+  // v0.29.19: a plateau reprieve's one-shot shove takes priority over the
+  // stuck directive (they can't both be meaningful in the same iteration).
+  const reprieveNote = loop.auditReprieveNote ?? "";
+  if (reprieveNote) loop.auditReprieveNote = undefined;
+  const interventionNote = reprieveNote || ((loop.consecutiveStuck ?? 0) > 0 && loop.lastStuckReason
     ? loopInterventionDirective(loop.consecutiveStuck!, loop.lastStuckReason, loop.recentTexts ?? [])
-    : "";
+    : "");
   // v0.24.0: identical prompts invite identical answers — rotate the base
   // instruction (metricless loops; metric loops already vary via values).
   const variantNote = metricless ? continueVariant(loop.iteration) : "";
@@ -2455,7 +2475,7 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     loop.consecutiveStuck = 0;
     loop.lastStuckReason = undefined;
   }
-  const outcome = metricless ? applyMetriclessTick(loop, nowIso()) : applyMeasurement(loop, value, nowIso());
+  let outcome: LoopTickOutcome = metricless ? applyMetriclessTick(loop, nowIso()) : applyMeasurement(loop, value, nowIso());
   persistState(ctx);
   appendLedger(ctx.cwd, "loop_measured", {
     iteration: loop.iteration,
@@ -2494,6 +2514,34 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     return;
   }
   if (outcome.kind === "stop") {
+    // v0.29.19: an audit loop's plateau is only honest when the well is
+    // ACTUALLY dry. Plateauing with open findings means the agent fumbled
+    // (or the provider ate) N turns — not "nothing left" (field: hegemon
+    // stopped at best 74 with 13 OPEN boxes; polis at best 46 with 3+).
+    // Stand the stop down with a strategy shove — bounded: the plateau
+    // after the last reprieve stops with an honest blocked-named reason.
+    if (loop.kind === "audit" && outcome.reason.startsWith("plateau —")) {
+      const open = countOpenAuditFindings(ctx.cwd);
+      if (open > 0) {
+        const reprieves = (loop.auditPlateauReprieves ?? 0) + 1;
+        if (reprieves <= AUDIT_PLATEAU_MAX_REPRIEVES) {
+          loop.active = true;
+          loop.stopReason = undefined;
+          loop.stallCount = 0;
+          loop.auditPlateauReprieves = reprieves;
+          loop.auditReprieveNote = `PLATEAU REPRIEVE (${reprieves}/${AUDIT_PLATEAU_MAX_REPRIEVES}): ${open} finding(s) still OPEN in ${AUDIT_FINDINGS_REL} — the plateau stop does not fire while the well isn't dry. Stop hunting and stop narrating: pick the smallest OPEN finding and CLOSE it this iteration (fix commit + checked box). ${AUDIT_PLATEAU_MAX_REPRIEVES - reprieves} reprieve(s) remain.`;
+          persistState(ctx);
+          appendLedger(ctx.cwd, "audit_plateau_reprieve", { open, reprieves, best: loop.bestValue });
+          ctx.ui.notify(`Audit loop plateau reprieve (${reprieves}/${AUDIT_PLATEAU_MAX_REPRIEVES}): ${open} open findings — the well isn't dry, continuing.`, "info");
+          scheduleLoopTick(ctx);
+          return;
+        }
+        const honest = `plateau — no closure in ${loop.plateauWindow}×${reprieves} iterations despite ${open} open findings (treat as blocked; /loop resume to push again)`;
+        loop.stopReason = honest;
+        persistState(ctx);
+        outcome = { kind: "stop", reason: honest };
+      }
+    }
     await finishLoopGit(ctx, loop);
     ctx.ui.notify(`Loop stopped: ${outcome.reason}. ${loop.history.length} iterations recorded.`, "info");
     appendLedger(ctx.cwd, "loop_stopped", { reason: outcome.reason, iterations: loop.iteration, best: loop.bestValue });
@@ -2637,14 +2685,23 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       return;
     }
     const stored = state.loop;
-    if (stored && !stored.active && stored.stopReason === HELD_ON_RESTORE) {
+    const RESUMABLE_STOP = (r?: string): boolean =>
+      r === HELD_ON_RESTORE ||
+      !!r?.startsWith("provider errors —") ||
+      !!r?.startsWith("stopped by user —") ||
+      !!r?.startsWith("plateau — no closure in") ||
+      !!r?.startsWith("stuck —");
+    if (stored && !stored.active && RESUMABLE_STOP(stored.stopReason)) {
       // v0.28.14: one-active-thing — a held loop must not resume over an
       // active goal/list-item (this was the last unguarded stacking path).
       if (state.goal && state.goal.status === "active") {
         ctx.ui.notify("A goal is active — the held loop stays held. /goal pause or /goal cancel it first, then /loop resume.", "warning");
         return;
       }
-      state.loop = { ...stored, active: true, stopReason: undefined };
+      // An explicit resume re-arms the counters: fresh stall window,
+      // cleared dead-turn/stuck streaks, reprieves restored — the user
+      // saying "push again" wins over the ladder's memory (v0.29.19).
+      state.loop = { ...stored, active: true, stopReason: undefined, consecutiveErrors: 0, consecutiveStuck: 0, lastStuckReason: undefined, stallCount: 0, auditPlateauReprieves: 0 };
       persistState(ctx);
       scheduleLoopTick(ctx);
       ctx.ui.notify(
@@ -5672,6 +5729,36 @@ export default function (pi: ExtensionAPI): void {
     // Loop 3 runs on the same heartbeat: measure after every agent turn.
     if (isLoopActive()) {
       clearLoopTimer();
+      // v0.29.19: provider-error / user-abort turns are NOT iterations —
+      // the model never got a say, so a dead turn carries no stall/stuck/
+      // plateau signal (field 2026-07-31, MiniMax token-plan 429 storm:
+      // hegemon false-plateau'd with 13 open findings, polis with 3+,
+      // hellhunter stuck-stopped at iter 93 — every counted turn was a
+      // dead 429 turn; the v0.28.13/v0.29.4 exemptions only covered the
+      // goal nudge counter). Skip the measure and refire — bounded, so a
+      // real outage stops the loop honestly instead of burning turns.
+      const sr = lastA?.stopReason;
+      if (sr === "error" || sr === "aborted") {
+        const loop = state.loop!;
+        loop.consecutiveErrors = (loop.consecutiveErrors ?? 0) + 1;
+        persistState(ctx);
+        appendLedger(ctx.cwd, "loop_turn_exempt_error", { stopReason: sr, consecutive: loop.consecutiveErrors, iteration: loop.iteration });
+        const cap = sr === "aborted" ? LOOP_MAX_CONSECUTIVE_ABORTS : LOOP_MAX_CONSECUTIVE_ERRORS;
+        if (loop.consecutiveErrors >= cap) {
+          loop.active = false;
+          loop.stopReason = sr === "aborted"
+            ? `stopped by user — ${loop.consecutiveErrors} consecutive aborts (iteration ${loop.iteration} preserved; /loop resume to continue)`
+            : `provider errors — ${loop.consecutiveErrors} consecutive error turns (iteration ${loop.iteration} preserved; /loop resume when the provider recovers)`;
+          persistState(ctx);
+          ctx.ui.notify(`Loop stopped: ${loop.stopReason}`, "warning");
+          appendLedger(ctx.cwd, "loop_stopped", { reason: loop.stopReason, iterations: loop.iteration, best: loop.bestValue });
+          notifyExternal(ctx, `Loop stopped: ${sr === "aborted" ? "user aborts" : "provider errors"} (${loop.consecutiveErrors}×)`);
+          return;
+        }
+        scheduleLoopTick(ctx);
+        return;
+      }
+      if ((state.loop!.consecutiveErrors ?? 0) > 0) state.loop!.consecutiveErrors = 0; // a real turn clears the streak (runLoopTick persists)
       await runLoopTick(ctx, event);
       return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.29.18",
+  "version": "0.29.19",
   "description": "Goal. Loop. Audit. Done. \u2014 a pi-coding-agent extension that supervises long-running work, with isolated auditor on each completion. Beat bamboozling by design: the auditor runs in a fresh session with no extensions, no skills, no editor \u2014 only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",