pi-goal-list-loop-audit 0.29.9 → 0.29.11

package/extensions/goal-loop-display.ts

@@ -173,10 +173,11 @@ export function buildStatusText(state: State, audit?: AuditDisplayProgress | nul
     return `glla: ${paint(theme, pauseIsError(g) ? "error" : "warning", label)}${heldSuffix}`;
   }
   if (g.status === "active") {
-    // v0.28.1 (S1/S2): a stale-handle interrupt keeps the goal ACTIVE (the
-    // next fresh session auto-resumes it) — say so instead of looking healthy.
+    // v0.28.1 (S1/S2): a stale-handle interrupt keeps the goal ACTIVE.
+    // v0.29.11: the fresh session HOLDS it (hold-everything restore gate;
+    // autoresume=on resumes for you) — name the verb, don't promise auto.
     if (g.interruptedAt) {
-      return `glla: ${g.policy} ${paint(theme, "error", "⚠ interrupted — stale handle · auto-resumes on pi restart")}${heldSuffix}`;
+      return `glla: ${g.policy} ${paint(theme, "error", "⚠ interrupted — stale handle · restart pi → /glla resume")}${heldSuffix}`;
     }
     // v0.24.7: list policy gets its own wording — a queue item is not a goal.
     // v0.28.11 (U10): goal policy joins it — "list 29" read as a command

package/extensions/goal-loop-forever.ts

@@ -57,6 +57,10 @@ export interface LoopState {
   consecutiveNullMeasures?: number;
   bestValue: number | null;
   lastValue: number | null;
+  /** v0.29.10: audit loops (measure counts open findings) get a deferred
+   * baseline (first REAL measurement seeds best — the pre-discovery 0 is
+   * degenerate) and audit-flavoured regression wording. */
+  kind?: "audit";
   active: boolean;
   stopReason?: string;
   history: LoopMeasure[];

package/extensions/loops/goal.ts

@@ -219,7 +219,7 @@ function goStaleTerminal(ctx: ExtensionContext, where: string): void {
   if (extensionApiStale) return; // already terminal — don't re-spam
   extensionApiStale = true;
   appendLedger(ctx.cwd, "extension_api_stale", { where, kind: isLoopActive() ? "loop" : "goal" });
-  const guidance = "pi invalidated this session's extension handle (session replacement — compaction triggers it in pi 0.82.x). Sends can never land in this process. Restart pi (or reload extensions) — an active goal auto-resumes on the fresh session; loops need /loop start.";
+  const guidance = "pi invalidated this session's extension handle (session replacement — compaction triggers it in pi 0.82.x). Sends can never land in this process. Restart pi (or reload extensions) — the goal/loop holds on the fresh session: /glla resume continues it (autoresume=on resumes for you).";
   if (isLoopActive()) {
     clearLoopTimer();
     state.loop = { ...state.loop!, active: false, stopReason: `extension api stale: ${guidance}` };
@@ -260,7 +260,7 @@ function warnIfStaleAtEntry(ctx: ExtensionContext, what: string): boolean {
   if (!probeExtensionApiStale()) return false;
   appendLedger(ctx.cwd, "extension_api_stale", { where: `entry probe (${what})` });
   ctx.ui.notify(
-    `glla: this session's extension handle is stale (pi session replacement) — ${what} can't send continuations in this process. State is safe in .pi-glla/ — restart pi and the active goal auto-resumes.`,
+    `glla: this session's extension handle is stale (pi session replacement) — ${what} can't send continuations in this process. State is safe in .pi-glla/ — restart pi, then /glla resume (autoresume=on resumes for you).`,
     "warning",
   );
   return true;
@@ -544,9 +544,9 @@ function escalateSendRearmStorm(ctx: ExtensionContext, kind: "continuation" | "l
   appendLedger(ctx.cwd, "send_rearm_escalated", { kind, afterMinutes: mins, silentMinutes: silent });
   if (kind === "loop" && isLoopActive()) {
     clearLoopTimer();
-    state.loop = { ...state.loop!, active: false, stopReason: `send-retry storm: ${mins}m of re-arms with no session activity for ${silent}m — the session is wedged. Restart pi, then /loop start again.` };
+    state.loop = { ...state.loop!, active: false, stopReason: `send-retry storm: ${mins}m of re-arms with no session activity for ${silent}m — the session is wedged. Restart pi, then /loop resume (the loop holds on restore).` };
     persistState(ctx);
-    ctx.ui.notify(`Loop stopped: send-retry storm (${mins}m, session silent ${silent}m). Restart pi and /loop start.`, "warning");
+    ctx.ui.notify(`Loop stopped: send-retry storm (${mins}m, session silent ${silent}m). Restart pi, then /loop resume (the loop holds on restore).`, "warning");
     notifyExternal(ctx, "Loop stopped: send-retry storm.");
     return;
   }
@@ -583,9 +583,9 @@ function escalateStallNow(ctx: ExtensionContext, threshold: number): boolean {
   appendLedger(ctx.cwd, "stall_escalated", { threshold, kind: isLoopActive() ? "loop" : "goal" });
   if (isLoopActive()) {
     clearLoopTimer();
-    state.loop = { ...state.loop!, active: false, stopReason: `stalled: ${threshold} continuation refires landed no turn — the session is not continuing (wedged message queue or stale API). Restart pi, then /loop start again.` };
+    state.loop = { ...state.loop!, active: false, stopReason: `stalled: ${threshold} continuation refires landed no turn — the session is not continuing (wedged message queue or stale API). Restart pi, then /loop resume (the loop holds on restore).` };
     persistState(ctx);
-    ctx.ui.notify(`Loop stopped: ${threshold} refires produced no turn — the continuation is not landing. Restart pi and /loop start.`, "warning");
+    ctx.ui.notify(`Loop stopped: ${threshold} refires produced no turn — the continuation is not landing. Restart pi, then /loop resume (the loop holds on restore).`, "warning");
     notifyExternal(ctx, "Loop stopped: stalled (continuation not landing).");
     return true;
   }
@@ -619,12 +619,16 @@ function heartbeatTick(): void {
   // machinery below stays quiet for 3 minutes while the replaced session
   // settles (latch watchdog, wedge alert, refire counting all resume after).
   if (Date.now() < compactionGraceUntil) return;
-  // v0.28.27: a stale (session-replaced) handle can never land a send —
-  // the terminal warning already fired once. ALL stall machinery stays
-  // quiet from here on: refiring into a dead process is misleading, and
-  // worse, the stall escalation would PAUSE the goal — silently cancelling
-  // the interruptedAt → auto-resume-on-restart promise the footer shows.
-  if (extensionApiStale) return;
+  // v0.29.11: PROBE the handle before the stall machinery runs — a
+  // session-replaced handle can never land a refire, so detect it on the
+  // first tick after replacement and go terminal immediately, instead of
+  // burning refires into the void until a send happens to throw (field:
+  // polis stall 3/5, endless-td stall 1/5 before the warning fired).
+  // v0.28.27: once terminal, ALL stall machinery stays quiet from here
+  // on: refiring into a dead process is misleading, and worse, the stall
+  // escalation would PAUSE the goal — silently cancelling the
+  // interruptedAt → hold-on-restart promise the footer shows.
+  if (probeExtensionApiStale()) { goStaleTerminal(ctx, "heartbeat probe"); return; }
   // v0.29.1: stranded-audit recovery. A goal left in "auditing" with NO
   // in-flight audit means the auditor's result never landed (wedged queue
   // ate the tool result; compaction/restart mid-audit). Field-observed in
@@ -2240,9 +2244,20 @@ function sendLoopTurn(): void {
     return;
   }
   const loop = state.loop!;
-  const regressedLast = loop.history.length > 0 && !loop.history[loop.history.length - 1]!.improved && loop.lastValue !== null;
-  const regressionNote = regressedLast
-    ? "**Your last change REGRESSED the metric. Undo it first, then try a different small change.**"
+  // v0.29.10: "regressed" = the last two measurements moved the WRONG way
+  // — not merely "didn't beat best". The old trigger (any non-improving
+  // iteration) cried REGRESSED on stalls and on the audit loop's
+  // degenerate baseline-0, telling agents to undo GOOD fixes (junk-runner
+  // 2026-07-30: 17→16 was real progress; the prompt demanded a revert).
+  const hist = loop.history;
+  const prevValue = hist.length >= 2 ? hist[hist.length - 2]!.value : null;
+  const lastHistValue = hist.length >= 1 ? hist[hist.length - 1]!.value : null;
+  const trueRegression = prevValue !== null && lastHistValue !== null && loop.direction !== undefined &&
+    (loop.direction === "min" ? lastHistValue > prevValue : lastHistValue < prevValue);
+  const regressionNote = trueRegression
+    ? loop.kind === "audit"
+      ? "**The open-findings count went UP last iteration — either the fresh audit pass found new problems, or your fix didn't land. Check findings.md, then keep fixing the highest-severity OPEN items.**"
+      : "**Your last change REGRESSED the metric. Undo it first, then try a different small change.**"
     : "";
   // Strategy rotation (from pi-loop-mode's one good idea): one stall before
   // the plateau window closes, stop polishing and change approach entirely.
@@ -2462,6 +2477,14 @@ interface LoopConfig {
   tokenBudget?: number;
   /** v0.25.1: /loop start toolsamerepeat=N (0 = disable legacy check). */
   toolSameRepeat?: number;
+  /** v0.29.10: don't seed bestValue from the pre-work baseline measure —
+   * the first REAL measurement becomes the baseline. For loops whose
+   * metric is created BY the first iteration (the audit loop: 0 open
+   * findings just means findings.md doesn't exist yet); a seeded 0 pins
+   * best at a value no iteration can beat, stalling every iteration. */
+  deferBaseline?: boolean;
+  /** v0.29.10: audit loops get audit-flavoured regression wording. */
+  kind?: "audit";
 }
 
 /** Shared loop-start path: /loop start AND propose_loop_draft (after Confirm). */
@@ -2497,8 +2520,8 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
   // v0.23.0: metricless loops skip the baseline entirely — there is no
   // measure to run, and no plateau to protect.
   const metricless = !cfg.measureCmd;
-  const baseline = metricless ? null : await runMeasure(ctx, cfg.measureCmd);
-  if (!metricless && baseline === null && !(cfg as { force?: boolean }).force) {
+  const baseline = metricless || cfg.deferBaseline ? null : await runMeasure(ctx, cfg.measureCmd);
+  if (!metricless && !cfg.deferBaseline && baseline === null && !(cfg as { force?: boolean }).force) {
     ctx.ui.notify(
       `/loop start refused: the measure produced no number.\nCommand: ${cfg.measureCmd}\nFix it so it prints exactly one number, or re-run with force=1 if it only works after the agent builds something first.\n(Non-numeric goal — research, docs, features? Use /goal: the independent auditor verifies semantically. /loop only believes a number.)`,
       "warning",
@@ -2516,8 +2539,9 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
       maxIterations: cfg.maxIterations,
       plateauWindow: cfg.plateauWindow,
       stallCount: 0,
-      bestValue: baseline,
-      lastValue: baseline,
+      bestValue: cfg.deferBaseline ? null : baseline,
+      lastValue: cfg.deferBaseline ? null : baseline,
+      kind: cfg.kind,
       active: true,
       history: [],
       startedAt: nowIso(),
@@ -2536,7 +2560,7 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
     metricless
       ? `Loop started (metricless spec loop — NO plateau stop): ${cfg.target.slice(0, 60)}\nEnds only at ${cfg.maxIterations > 0 ? `max ${cfg.maxIterations} iterations` : "no iteration cap"}${cfg.timeLimitHours ? ` · ${cfg.timeLimitHours}h` : ""}${cfg.tokenBudget ? ` · ${cfg.tokenBudget.toLocaleString()} tokens` : ""} · /loop stop. Every iteration must make ONE real, inspectable change — cosmetic churn is the doorknob failure.` +
         (branchName ? `\nbranch mode: committing each iteration to ${branchName}` : "")
-      : `Loop started: ${cfg.target.slice(0, 60)}\nBaseline: ${baseline ?? "(forced without a number — first turn must produce one)"} · direction ${cfg.direction} · window ${cfg.plateauWindow} · ${cfg.maxIterations > 0 ? `max ${cfg.maxIterations}` : "no iteration cap"}` +
+      : `Loop started: ${cfg.target.slice(0, 60)}\nBaseline: ${cfg.deferBaseline ? "deferred — the first real measurement seeds it" : (baseline ?? "(forced without a number — first turn must produce one)")} · direction ${cfg.direction} · window ${cfg.plateauWindow} · ${cfg.maxIterations > 0 ? `max ${cfg.maxIterations}` : "no iteration cap"}` +
         (branchName ? `\nbranch mode: committing improvements to ${branchName}` : ""),
     "info",
   );
@@ -2695,6 +2719,11 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       maxIterations: 0,
       branch: false,
       force: false,
+      // v0.29.10: the audit loop's metric is CREATED by iteration 1 —
+      // seeding best from the pre-discovery 0 stalls every iteration and
+      // plateau-stops mid-work at the window. Defer the baseline.
+      deferBaseline: true,
+      kind: "audit",
     });
     return;
   }
@@ -5303,6 +5332,26 @@ export default function (pi: ExtensionAPI): void {
     ) {
       ctx.ui.notify("Auto-resume fired (event: session start). Continue working.", "info");
     }
+    // v0.29.11: loops stopped by the stale-handle terminal or the stall
+    // escalation told the user "restart pi, then /loop start" — but a
+    // fresh start discards iteration/best/history. Hold them on load like
+    // any restore-held loop: /loop resume continues from the saved state.
+    if (state.loop && !state.loop.active &&
+        (state.loop.stopReason?.startsWith("extension api stale") || state.loop.stopReason?.startsWith("stalled:") || state.loop.stopReason?.startsWith("send-retry storm:"))) {
+      appendLedger(ctx.cwd, "loop_held_for_resume", { was: (state.loop.stopReason ?? "").slice(0, 40) });
+      state.loop = { ...state.loop, stopReason: HELD_ON_RESTORE };
+      persistState(ctx);
+    }
+    // v0.29.10: reseed live/held audit loops stuck on the degenerate
+    // pre-discovery baseline-0 — best can never go below 0, so every
+    // iteration stalls and the prompt cries REGRESSED on real progress
+    // (junk-runner ran pinned like this). Null best = the next measurement
+    // becomes the honest baseline; stall streak resets with it.
+    if (state.loop && state.loop.measureCmd?.includes("audit-loop/findings.md") && state.loop.bestValue === 0) {
+      state.loop = { ...state.loop, bestValue: null, stallCount: 0, kind: state.loop.kind ?? "audit" };
+      persistState(ctx);
+      appendLedger(ctx.cwd, "audit_loop_baseline_reseeded", { from: 0 });
+    }
     if (isLoopActive()) {
       const l = state.loop!;
       if (autoResume) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.29.9",
+  "version": "0.29.11",
   "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",