pi-goal-list-loop-audit 0.23.2 → 0.23.3

package/README.md

@@ -184,7 +184,7 @@ No external watchdog plugin needed.
 /glla notify='cmd "$1"'              # push on complete/pause/stop → GLOBAL
 /glla tokenlimit=10000000            # per-goal token budget (default: off) → GLOBAL
 /glla tokenlimit=0                   # explicitly no cap (the default)
-/glla wedgealert=30                  # hung-command alert minutes (default: 45, 0 = off)
+/glla wedgealert=30                  # hung-command alert minutes (default: 30, 0 = off)
 /glla project tokenlimit=500         # rare per-project override
 ```
 
@@ -208,10 +208,15 @@ this cap — it has its own brakes
 The turn-based watchdogs can't see one failure shape: the session is busy
 but silent for a long stretch because ONE unbounded command (a test suite
 that never exits, a dev server) is holding the whole goal hostage. The
-heartbeat watches the wall clock: busy + no activity for 45 minutes →
+heartbeat watches the wall clock: busy + no activity for 30 minutes →
 in-session warning + your configured notify push, once per interval while
 it persists. Tune with `/glla wedgealert=<minutes>` (0 = off).
 
+Every other wait is bounded too: continuation retries are milliseconds,
+stuck backoff caps at 5 minutes then pauses, measure commands get a 10m
+hard timeout, and the auditor aborts after 10m with zero session activity
+(infrastructure error, never a verdict).
+
 ## Compatibility (what goes well, what conflicts)
 
 **The Two-Driver Rule**: any plugin that drives agent turns on `agent_end`

package/extensions/goal-loop-auditor.ts

@@ -25,6 +25,7 @@ import {
 
 import type { Goal } from "./goal-loop-core.js";
 import { renderGoalMarkdown } from "./goal-loop-core.js";
+import { AUDITOR_STALL_MS } from "./goal-loop-backoff.js";
 
 // =================================================================
 // Result type
@@ -239,7 +240,22 @@ export async function runGoalCompletionAuditor(args: {
       tools: ["read", "grep", "find", "ls", "bash"],
     });
     let streamError: string | undefined;
+    // v0.23.3 stall watchdog: any session event is activity. An auditor
+    // with NO events for AUDITOR_STALL_MS is wedged (dead stream, hung
+    // provider call) — abort it and return an ERROR, never a verdict,
+    // and never let the completion gate hang forever (the pi-goal-x
+    // failure shape: unbounded silent waits).
+    let lastEventAt = Date.now();
+    let stalled = false;
+    const stallTimer = setInterval(() => {
+      if (Date.now() - lastEventAt > AUDITOR_STALL_MS) {
+        stalled = true;
+        void session.abort();
+      }
+    }, 15_000);
+    stallTimer.unref?.();
     const unsub = session.subscribe((event) => {
+      lastEventAt = Date.now();
       // Capture provider/stream errors (401/403/429/credits) — these often
       // arrive as events rather than thrown exceptions, and without this they
       // surface as a silent empty report that looks like a disapproval.
@@ -306,9 +322,21 @@ export async function runGoalCompletionAuditor(args: {
       }
       await session.prompt(buildGoalAuditorPrompt(args.goal, args.completionSummary, args.verificationSummary));
     } finally {
+      clearInterval(stallTimer);
       unsub();
     }
 
+    if (stalled) {
+      return {
+        approved: false,
+        disapproved: false,
+        output: outputParts.join("\n\n"),
+        model: modelLabel(model),
+        thinkingLevel,
+        error: `Auditor stalled — no session activity for ${Math.round(AUDITOR_STALL_MS / 60_000)}m, aborted. This is an infrastructure failure, not a verdict; retry completion (check the auditor model with /glla model=).`,
+      };
+    }
+
     const output = outputParts.join("\n\n");
 
     // SILENT-FAILURE GUARD (v0.9.9, wild-caught): an auditor that produced

package/extensions/goal-loop-backoff.ts

@@ -72,8 +72,23 @@ export const HEARTBEAT_MAX_NUDGES = 3;
  * activity for this long is almost always a hung unbounded command
  * (test suite / dev server) holding the whole goal hostage. The
  * turn-based watchdogs are blind to it (it's ONE long turn); only the
- * wall clock sees it. 0 in settings = off. */
-export const WEDGE_ALERT_DEFAULT_MINUTES = 45;
+ * wall clock sees it. 0 in settings = off.
+ * v0.23.3: 45 → 30. The alert is notification-only, so a false positive
+ * costs one notification while a false negative costs hours — that
+ * asymmetry argues tight. (pi-goal-x, the cautionary tale, had NO wall
+ * clock at all: a wedged session was silent forever.) */
+export const WEDGE_ALERT_DEFAULT_MINUTES = 30;
+/** v0.23.3: hard cap on one measure command. An unbounded measure is the
+ * same wedge shape as an unbounded test suite — it freezes the loop tick
+ * forever. Timeout → measure failure (null) → stall path → plateau stop,
+ * never a silent hang. Matches pi-loop-mode's --check-timeout default. */
+export const MEASURE_TIMEOUT_MS = 10 * 60_000;
+/** v0.23.3: auditor inactivity abort. The auditor legitimately runs the
+ * project's own verification (test suites!), so the bound is on
+ * INACTIVITY (no session events at all), not wall time. An auditor with
+ * no events for this long is wedged — abort and report an error, never
+ * disapprove, never hang the completion gate forever. */
+export const AUDITOR_STALL_MS = 10 * 60_000;
 
 export interface WedgeInput {
   /** A goal is active (autoContinue) or a loop is running. */

package/extensions/loops/goal.ts

@@ -77,6 +77,7 @@ import {
   HEARTBEAT_MAX_NUDGES,
   HEARTBEAT_STALL_MS,
   shouldHeartbeatRefire,
+  MEASURE_TIMEOUT_MS,
   WEDGE_ALERT_DEFAULT_MINUTES,
   shouldWedgeAlert,
 } from "../goal-loop-backoff.js";
@@ -958,7 +959,7 @@ function isLoopActive(): boolean {
 async function runMeasure(ctx: ExtensionContext, cmd: string): Promise<number | null> {
   if (!extensionApi) return null;
   try {
-    const result = await extensionApi.exec("bash", ["-c", cmd], { cwd: ctx.cwd });
+    const result = await extensionApi.exec("bash", ["-c", cmd], { cwd: ctx.cwd, timeout: MEASURE_TIMEOUT_MS });
     const stdout = (result as any)?.stdout ?? "";
     return parseMetric(String(stdout));
   } catch {
@@ -2197,7 +2198,7 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
   //   /glla thinking=high        write to GLOBAL config
   //   /glla notify='cmd $1'      write to GLOBAL config
   //   /glla tokenlimit=2000000   write to GLOBAL config
-  //   /glla wedgealert=30         hung-command alert minutes (0=off, unset=45)
+  //   /glla wedgealert=30         hung-command alert minutes (0=off, unset=30)
   //   /glla project model=...    write to PROJECT override (rare)
   //   /glla model=unset          remove key (from global; project model=unset for project)
   const trimmed = args.trim();

package/package.json

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