pi-goal-list-loop-audit 0.26.0 → 0.26.1

package/extensions/goal-loop-core.ts

@@ -11,6 +11,17 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { execSync } from "node:child_process";
 
+/** v0.26.1: consecutive heartbeat refires without a real agent turn
+ * before the supervisor gives up (pauses the goal / stops the loop).
+ * 0 = never escalate (legacy silent-spin behavior). */
+export const DEFAULT_STALL_ESCALATION_REFIRES = 5;
+
+/** v0.26.1: pure gate — has the refire streak hit the escalation
+ * threshold? threshold 0 disables escalation entirely. */
+export function shouldEscalateStall(consecutiveStalls: number, threshold: number): boolean {
+  return threshold > 0 && consecutiveStalls >= threshold;
+}
+
 // =================================================================
 // Types
 // =================================================================

package/extensions/goal-loop-display.ts

@@ -81,17 +81,20 @@ export interface AuditDisplayProgress {
  * One-line status for ctx.ui.setStatus("pi-glla", …).
  * Returns undefined when nothing is being supervised (clears the segment).
  */
-export function buildStatusText(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme): string | undefined {
+export function buildStatusText(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, extras?: { stalls?: number }): string | undefined {
   if (state.loop?.active) {
     const l = state.loop;
+    // v0.26.1: surface the refire streak — a spinning supervisor is the
+    // zombie signature (hegemon incident: 619 refires, 0 turns).
+    const stallSuffix = (extras?.stalls ?? 0) > 0 ? ` · ${paint(theme, "warning", `stalls:${extras!.stalls}`)}` : "";
     // v0.23.0: metricless spec loop — no arrow/best/stall, no plateau.
     if (!l.measureCmd) {
-      return `glla: loop ${paint(theme, "accent", "∞")} iter ${l.iteration}${l.maxIterations > 0 ? `/${l.maxIterations}` : ""} · metricless`;
+      return `glla: loop ${paint(theme, "accent", "∞")} iter ${l.iteration}${l.maxIterations > 0 ? `/${l.maxIterations}` : ""} · metricless${stallSuffix}`;
     }
     const arrow = paint(theme, "accent", l.direction === "min" ? "↓" : "↑");
     const stallText = `stall ${l.stallCount}/${l.plateauWindow}`;
     const stall = l.stallCount >= l.plateauWindow - 1 ? paint(theme, "warning", stallText) : stallText;
-    return `glla: loop ${arrow} iter ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"} · best ${l.bestValue ?? "n/a"} · ${stall}`;
+    return `glla: loop ${arrow} iter ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"} · best ${l.bestValue ?? "n/a"} · ${stall}${stallSuffix}`;
   }
   const g = state.goal;
   if (!g) return undefined;
@@ -146,8 +149,8 @@ function countTotal(g: Goal): number {
  * Widget lines for ctx.ui.setWidget("pi-glla", lines).
  * Returns undefined when nothing is worth showing.
  */
-export function buildWidgetLines(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, width?: number): string[] | undefined {
-  if (state.loop?.active) return loopLines(state.loop, now, theme, width);
+export function buildWidgetLines(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, width?: number, extras?: { stalls?: number }): string[] | undefined {
+  if (state.loop?.active) return loopLines(state.loop, now, theme, width, extras);
   const g = state.goal;
   if (!g) return undefined;
   if (g.status === "complete" || g.status === "aborted") return undefined;
@@ -202,12 +205,14 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   return lines;
 }
 
-function loopLines(l: LoopState, now: number, theme?: DisplayTheme, width?: number): string[] {
+function loopLines(l: LoopState, now: number, theme?: DisplayTheme, width?: number, extras?: { stalls?: number }): string[] {
+  // v0.26.1: the refire streak, shown only while nonzero.
+  const stallNote = (extras?.stalls ?? 0) > 0 ? ` · ${paint(theme, "warning", `stalls:${extras!.stalls}`)}` : "";
   // v0.23.0: metricless spec loop — no arrow/best/stall, no plateau.
   if (!l.measureCmd) {
     const lines = [
       `${paint(theme, "accent", "●")} ${truncate(l.target, budgetFor(width, 3, 64))}`,
-      `├─ loop ∞ iter ${l.iteration}${l.maxIterations > 0 ? `/${l.maxIterations}` : ""} · ${fmtElapsed(now - Date.parse(l.startedAt))}`,
+      `├─ loop ∞ iter ${l.iteration}${l.maxIterations > 0 ? `/${l.maxIterations}` : ""} · ${fmtElapsed(now - Date.parse(l.startedAt))}${stallNote}`,
       `└─ ${paint(theme, "dim", "metricless — work the spec (no plateau)")}`,
     ];
     if (l.branchName) lines.push(`⎇ ${paint(theme, "muted", truncate(l.branchName, budgetFor(width, 3, 50)))}`);

package/extensions/goal-settings.ts

@@ -49,6 +49,9 @@ export interface Settings {
   /** Consecutive stuck interventions before a loop stops (default 5,
    * 10 under aggressiveMode). */
   stuckMaxInterventions?: number;
+  /** v0.26.1: consecutive heartbeat refires without a real turn before
+   * the goal pauses / loop stops (default 5; 0 = never escalate). */
+  stallEscalationRefires?: number;
   /** on → propose_* drafts activate WITHOUT the Confirm dialog and the
    * interview floor is skipped — the seed carries the intent (unattended
    * rigs). Default off: nothing activates before the user confirms. */
@@ -127,6 +130,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "aggressiveMode",
   "quotaRetryMinutes",
   "stuckMaxInterventions",
+  "stallEscalationRefires",
 ];
 
 /** Where each effective setting comes from (for the /glla display). */

package/extensions/loops/goal.ts

@@ -33,6 +33,7 @@ import {
   auditFeedbackExcerpt,
   DEFAULT_AUDIT_FEEDBACK_CHARS,
   DEFAULT_QUOTA_RETRY_MINUTES,
+  DEFAULT_STALL_ESCALATION_REFIRES,
   DEFAULT_TOKEN_LIMIT,
   classifyImpossibleReason,
   extractPendingTasks,
@@ -50,6 +51,7 @@ import {
   ledgerPath,
   crossRecommendMode,
   formatListDepth,
+  shouldEscalateStall,
   shouldSuppressHeartbeatForRecentShip,
   mergeSettings,
   parseListImport,
@@ -231,10 +233,16 @@ const countedLoopTokenMessages = new Set<string>();
 let lastActivityAt = Date.now();
 let lastWedgeAlertAt = 0;
 let heartbeatNudges = 0;
+// v0.26.1: consecutive heartbeat refires that produced NO real agent turn.
+// Resets only on real activity (agent_end / tool_call) — never on the
+// refire's own noteActivity, which is what made the hegemon zombie spin
+// self-sustaining (619 refires / 23.5h / zero turns).
+let consecutiveStalls = 0;
 let heartbeatTimer: NodeJS.Timeout | null = null;
 
-function noteActivity(): void {
+function noteActivity(real = false): void {
   lastActivityAt = Date.now();
+  if (real) consecutiveStalls = 0;
 }
 
 function isSupervising(): boolean {
@@ -256,8 +264,8 @@ function refreshUI(ctx: ExtensionContext): void {
     // Terminal width for truncation budgets: on wide terminals the widget
     // uses the room instead of cutting at fixed ~60-char floors.
     const width = process.stdout.columns || 80;
-    ctx.ui.setStatus("pi-glla", buildStatusText(state, latestAuditProgress, Date.now(), theme));
-    ctx.ui.setWidget("pi-glla", buildWidgetLines(state, latestAuditProgress, Date.now(), theme, width));
+    ctx.ui.setStatus("pi-glla", buildStatusText(state, latestAuditProgress, Date.now(), theme, { stalls: consecutiveStalls }));
+    ctx.ui.setWidget("pi-glla", buildWidgetLines(state, latestAuditProgress, Date.now(), theme, width, { stalls: consecutiveStalls }));
   } catch {
     // stale ctx — next event refreshes
   }
@@ -323,8 +331,36 @@ function heartbeatTick(): void {
     return;
   }
   noteActivity();
-  appendLedger(ctx.cwd, "heartbeat_refire", { nudgesSoFar: heartbeatNudges });
-  ctx.ui.notify("Heartbeat: supervisor active but session stalled — re-firing continuation.", "info");
+  consecutiveStalls++;
+  appendLedger(ctx.cwd, "heartbeat_refire", { nudgesSoFar: heartbeatNudges, consecutiveStalls });
+  // v0.26.1: a refire streak means the continuation is NOT landing (wedged
+  // message queue, stale API handle, dead turn trigger). Nudges can't catch
+  // this — they count turns, and a zombie runs none. Escalate to a loud,
+  // actionable stop instead of spinning silently forever.
+  const stallEscalation = loadSettings(ctx.cwd).stallEscalationRefires ?? DEFAULT_STALL_ESCALATION_REFIRES;
+  if (shouldEscalateStall(consecutiveStalls, stallEscalation)) {
+    consecutiveStalls = 0;
+    appendLedger(ctx.cwd, "stall_escalated", { threshold: stallEscalation, kind: isLoopActive() ? "loop" : "goal" });
+    if (isLoopActive()) {
+      clearLoopTimer();
+      state.loop = { ...state.loop!, active: false, stopReason: `stalled: ${stallEscalation} continuation refires landed no turn — the session is not continuing (wedged message queue or stale API). Restart pi, then /loop start again.` };
+      persistState(ctx);
+      ctx.ui.notify(`Loop stopped: ${stallEscalation} refires produced no turn — the continuation is not landing. Restart pi and /loop start.`, "warning");
+      notifyExternal(ctx, "Loop stopped: stalled (continuation not landing).");
+      return;
+    }
+    if (state.goal && state.goal.status === "active") {
+      updateGoal({
+        status: "paused",
+        pauseReason: `stalled: ${stallEscalation} continuation refires landed no turn`,
+        pauseSuggestedAction: "The continuation chain is broken in this process (wedged message queue or stale API). Restart pi, then /goal resume.",
+      }, ctx);
+      ctx.ui.notify(`Goal paused: ${stallEscalation} refires produced no turn. Restart pi, then /goal resume.`, "warning");
+      notifyExternal(ctx, "Goal paused: stalled (continuation not landing).");
+      return;
+    }
+  }
+  ctx.ui.notify(`Heartbeat: supervisor active but session stalled — re-firing continuation (stall ${consecutiveStalls}/${stallEscalation > 0 ? stallEscalation : "∞"}).`, "info");
   if (isLoopActive()) {
     scheduleLoopTick(ctx);
   } else {
@@ -415,7 +451,9 @@ function sendContinuation(goalId: string): void {
       content: continuationPrompt(state.goal!),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
-  } catch {
+    appendLedger(ctx.cwd, "goal_continuation_sent", { goalId });
+  } catch (err) {
+    appendLedger(ctx.cwd, "goal_continuation_send_failed", { goalId, error: err instanceof Error ? err.message : String(err) });
     // API went stale mid-flight; next agent_end/session_start will reschedule.
   }
 }
@@ -1300,8 +1338,13 @@ function sendLoopTurn(): void {
       content: loopPrompt(loop, regressionNote, strategyNote, boundsNote, interventionNote, variantNote),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
-  } catch {
-    // stale API — next agent_end reschedules
+    // v0.26.1: the send path is ledgered — the hegemon zombie spun 619
+    // refires with zero visibility into whether sends were landing.
+    appendLedger(ctx.cwd, "loop_turn_sent", { iteration: loop.iteration });
+  } catch (err) {
+    // stale API — next agent_end reschedules (but if none comes, the
+    // heartbeat's stall escalation stops the spin — v0.26.1).
+    appendLedger(ctx.cwd, "loop_turn_send_failed", { error: err instanceof Error ? err.message : String(err) });
   }
 }
 
@@ -3153,6 +3196,19 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
           ctx.ui.notify(`quotaretryminutes must be a positive integer, got: ${value}`, "warning");
         }
       }
+    } else if (key === "stallescalation" || key === "stallescalationrefires") {
+      if (["unset", "default"].includes(value)) {
+        patch.stallEscalationRefires = undefined;
+        changed = true;
+      } else {
+        const n = Number.parseInt(value, 10);
+        if (Number.isInteger(n) && n >= 0) {
+          patch.stallEscalationRefires = n;
+          changed = true;
+        } else {
+          ctx.ui.notify(`stallescalation must be a non-negative integer (0 = never escalate), got: ${value}`, "warning");
+        }
+      }
     } else if (key === "stuckmax" || key === "stuckmaxinterventions") {
       if (["unset", "default"].includes(value)) {
         patch.stuckMaxInterventions = undefined;
@@ -3302,6 +3358,7 @@ export default function (pi: ExtensionAPI): void {
       ["aggressivemode=", "on: keep-going defaults — autoResume, cap 10, stuck 10, wedge off, quota auto-retry, cap→TODOs"],
       ["quotaretryminutes=", "N: minutes before auto-retrying a quota-exhausted auditor (default 60)"],
       ["stuckmax=", "N: consecutive stuck interventions before a loop stops (default 5)"],
+      ["stallescalation=", "N: heartbeat refires without a turn before goal pauses / loop stops (default 5, 0 = never)"],
       ["stats", "per-project ledger rollups: /glla stats [json|premature|project=<path>]"],
       ["audits", "audit-log browser: /glla audits [N|full] — recent verdicts from .pi-glla/audits.jsonl"],
       ["autoaccept=", "on: drafts activate without the Confirm dialog (unattended rigs)"],
@@ -3367,6 +3424,30 @@ export default function (pi: ExtensionAPI): void {
     }
   }
 
+  // v0.26.1: compaction ends WITHOUT an agent_end (the compaction turn is
+  // not an agent turn), so the continuation chain can dangle until the
+  // 60s heartbeat notices. Re-arm it as soon as pi settles post-compact.
+  pi.on("session_compact", async (_event: any, ctx: ExtensionContext) => {
+    if (isForeignCtx(ctx)) return;
+    rememberCtx(ctx);
+    if (!isSupervising()) return;
+    appendLedger(ctx.cwd, "session_compact", {});
+    const settle = setTimeout(() => {
+      const c = freshCtx();
+      if (!c) return;
+      try {
+        if (c.isIdle() && !c.hasPendingMessages() && continuationTimer === null && loopTimer === null && isSupervising()) {
+          appendLedger(c.cwd, "compaction_refire", {});
+          if (isLoopActive()) scheduleLoopTick(c);
+          else scheduleContinuation(c, true);
+        }
+      } catch {
+        /* settle race — the 60s heartbeat covers it */
+      }
+    }, 2000);
+    settle.unref?.();
+  });
+
   pi.on("message_start", async (event: any, _ctx: ExtensionContext) => {
     // v0.14.0 drafting floor: count real user replies while drafting. Our
     // own injected draft prompt arrives as a user message — skip that one.
@@ -3549,7 +3630,7 @@ export default function (pi: ExtensionAPI): void {
     // v0.23.8: a subagent finishing must not drive the main session's
     // continuation loop.
     if (isForeignCtx(ctx)) return;
-    noteActivity();
+    noteActivity(true);
     // v0.25.2: per-goal turn telemetry (/glla stats).
     if (state.goal && state.goal.status === "active") {
       const t = state.goal.telemetry ?? { turns: 0, fileWrites: 0, bashCalls: 0 };
@@ -3650,7 +3731,7 @@ export default function (pi: ExtensionAPI): void {
 
   pi.on("tool_call", () => {
     toolCallsThisTurn++;
-    noteActivity();
+    noteActivity(true);
     // v0.24.0: count loop-iteration tool calls (narration-only detection).
     if (isLoopActive()) {
       state.loop!.toolsThisTurn = (state.loop!.toolsThisTurn ?? 0) + 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Goal. Loop. Audit. Done. — 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 — only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",