pi-goal-list-loop-audit 0.26.3 → 0.26.5

package/extensions/goal-loop-backoff.ts

@@ -90,6 +90,44 @@ export const MEASURE_TIMEOUT_MS = 10 * 60_000;
  * disapprove, never hang the completion gate forever. */
 export const AUDITOR_STALL_MS = 10 * 60_000;
 
+/** v0.26.5: pending-latch watchdog threshold. Field-observed failure: a
+ * continuation sent right at compaction was ACCEPTED by pi (sendMessage
+ * returned) but the turn trigger was dropped — pi's pending-message flag
+ * then stayed set forever. sessionIdle (= isIdle && !hasPendingMessages)
+ * never went true, so the heartbeat refire path AND the stall escalation
+ * were both suppressed: 22 minutes of total silence until a manual nudge.
+ * The wedge alert was blind too (22m < 30m threshold, and its "hung
+ * command" framing would be wrong anyway). This watchdog owns that
+ * shape: idle + pending + silent >= threshold = the latch is stuck. */
+export const PENDING_LATCH_STUCK_MS = 3 * 60_000;
+
+export interface PendingLatchInput {
+  /** A goal is active (autoContinue) or a loop is running. */
+  supervising: boolean;
+  /** ctx.isIdle() — the session is NOT mid-turn. */
+  idle: boolean;
+  /** ctx.hasPendingMessages() — pi believes a message is still queued. */
+  pending: boolean;
+  /** A continuation or loop timer is already scheduled. */
+  timerPending: boolean;
+  /** Milliseconds since the last observed agent activity. */
+  silentMs: number;
+  /** Threshold in ms; 0 disables the watchdog. */
+  thresholdMs: number;
+}
+
+/** Should the pending-latch watchdog count a stall right now? It never
+ * re-sends: the message is ALREADY queued pi-side, and the hegemon
+ * zombie proved re-sends don't unstick a dropped trigger (619 sends,
+ * zero turns). Count + notify + escalate to a loud stop instead. */
+export function shouldFirePendingLatchWatchdog(input: PendingLatchInput): boolean {
+  if (!input.supervising) return false;
+  if (!input.idle || !input.pending) return false;
+  if (input.timerPending) return false;
+  if (input.thresholdMs <= 0) return false;
+  return input.silentMs >= input.thresholdMs;
+}
+
 export interface WedgeInput {
   /** A goal is active (autoContinue) or a loop is running. */
   supervising: boolean;

package/extensions/loops/goal.ts

@@ -160,6 +160,8 @@ import {
   MEASURE_TIMEOUT_MS,
   WEDGE_ALERT_DEFAULT_MINUTES,
   shouldWedgeAlert,
+  PENDING_LATCH_STUCK_MS,
+  shouldFirePendingLatchWatchdog,
 } from "../goal-loop-backoff.js";
 
 // =================================================================
@@ -280,15 +282,74 @@ function startUITicker(): void {
   uiTicker.unref?.();
 }
 
+/** v0.26.5: shared loud-stop for both stall paths (refire streak and
+ * pending-latch streak). Returns true when it escalated. */
+function escalateStallNow(ctx: ExtensionContext, threshold: number): boolean {
+  if (!shouldEscalateStall(consecutiveStalls, threshold)) return false;
+  consecutiveStalls = 0;
+  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.` };
+    persistState(ctx);
+    ctx.ui.notify(`Loop stopped: ${threshold} refires produced no turn — the continuation is not landing. Restart pi and /loop start.`, "warning");
+    notifyExternal(ctx, "Loop stopped: stalled (continuation not landing).");
+    return true;
+  }
+  if (state.goal && state.goal.status === "active") {
+    updateGoal({
+      status: "paused",
+      pauseReason: `stalled: ${threshold} 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: ${threshold} refires produced no turn. Restart pi, then /goal resume.`, "warning");
+    notifyExternal(ctx, "Goal paused: stalled (continuation not landing).");
+    return true;
+  }
+  return true;
+}
+
 function heartbeatTick(): void {
   const ctx = freshCtx();
   if (!ctx) return;
-  let sessionIdle = false;
+  let idle = false;
+  let pending = false;
   try {
-    sessionIdle = ctx.isIdle() && !ctx.hasPendingMessages();
+    idle = ctx.isIdle();
+    pending = ctx.hasPendingMessages();
   } catch {
     return;
   }
+  const sessionIdle = idle && !pending;
+  // v0.26.5: pending-latch watchdog — a queued continuation whose turn
+  // trigger was dropped (field-observed post-compaction: continuation
+  // ACCEPTED at compact+0s, then 22 minutes of silence). The stuck latch
+  // keeps sessionIdle false, which suppresses the refire path AND the
+  // stall escalation below — without this branch the session is silent
+  // forever. We never re-send here (the message is already queued
+  // pi-side; hegemon proved re-sends don't unstick a dropped trigger) —
+  // count, notify, escalate to a loud stop.
+  const latchSilentMs = Date.now() - lastActivityAt;
+  if (
+    shouldFirePendingLatchWatchdog({
+      supervising: isSupervising(),
+      idle,
+      pending,
+      timerPending: continuationTimer !== null || loopTimer !== null,
+      silentMs: latchSilentMs,
+      thresholdMs: PENDING_LATCH_STUCK_MS,
+    })
+  ) {
+    consecutiveStalls++;
+    appendLedger(ctx.cwd, "pending_latch_stuck", { consecutiveStalls, silentMs: latchSilentMs });
+    noteActivity(); // re-arm the 3-minute cadence; never resets the stall streak
+    const stallEscalation = loadSettings(ctx.cwd).stallEscalationRefires ?? DEFAULT_STALL_ESCALATION_REFIRES;
+    if (escalateStallNow(ctx, stallEscalation)) return;
+    const msg = `Heartbeat: a queued continuation never started its turn for ${Math.round(latchSilentMs / 60_000)}m — pi's pending-message latch appears stuck (known post-compaction failure; stall ${consecutiveStalls}/${stallEscalation > 0 ? stallEscalation : "∞"}). If this repeats, restart pi.`;
+    ctx.ui.notify(msg, "warning");
+    notifyExternal(ctx, msg);
+    return;
+  }
   const fire = shouldHeartbeatRefire({
     supervising: isSupervising(),
     sessionIdle,
@@ -305,7 +366,9 @@ function heartbeatTick(): void {
   if (
     shouldWedgeAlert({
       supervising: isSupervising(),
-      sessionBusy: !sessionIdle,
+      // v0.26.5: !idle, not !sessionIdle — an idle session with a stuck
+      // pending latch is the watchdog's job above, not a "hung command".
+      sessionBusy: !idle,
       silentMs: Date.now() - lastActivityAt,
       msSinceLastAlert: Date.now() - lastWedgeAlertAt,
       thresholdMs: wedgeMinutes * 60_000,
@@ -338,28 +401,7 @@ function heartbeatTick(): void {
   // 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;
-    }
-  }
+  if (escalateStallNow(ctx, stallEscalation)) return;
   ctx.ui.notify(`Heartbeat: supervisor active but session stalled — re-firing continuation (stall ${consecutiveStalls}/${stallEscalation > 0 ? stallEscalation : "∞"}).`, "info");
   if (isLoopActive()) {
     scheduleLoopTick(ctx);
@@ -595,8 +637,12 @@ function fireReviewer(
     } catch {
       /* archive md may not exist for manual review of a live goal */
     }
+    // v0.26.4 source curation: an APPROVED audit report is the executor's
+    // own completion claims — meta-text with zero finding signal (the
+    // 0.26.2/0.26.3 misfires both mined it). Disapprovals/errors carry the
+    // independent auditor's required-fixes — the real findings.
     const auditTexts = readAuditLog(ctx.cwd)
-      .filter((e) => e.goalId === source.goalId)
+      .filter((e) => e.goalId === source.goalId && (e.verdict === "disapproved" || e.verdict === "error"))
       .map((e) => e.report);
     for (const t of auditTexts) sources.push({ name: "audit", text: t });
     let ledgerEntries: Array<{ type: string; at?: string; value?: any }> = [];

package/extensions/reviewer.ts

@@ -80,11 +80,13 @@ const CLASS_PATTERNS: Array<{ class: FindingClass; re: RegExp }> = [
  * the reviewer's own report/config vocabulary. Observed false positives
  * from the 0.26.2 completion: a test("…architectural…") name, the
  * INSTALL.md mode-matrix row, and ship-doc prose. */
-const SKIP_LINE = /^\s*(test|it|describe|assert|expect)\s*\(|^\s*(const|let|var|function|import|export|require)\b|\{\s*\.\.\.\s*\}|,\s*\.\.\.$|^\s*\|/;
-const REVIEWER_VOCAB = /architectural-class|bug-class|refactor-class|strategic-class|reviewer found|cascade step|\*\*Mode\*\*|problems\s*\/\s*(improvements|architectural)/i;
+const SKIP_LINE = /^\s*(test|it|describe|assert|expect)\s*\(|^\s*(const|let|var|function|import|export|require)\b|\{\s*\.\.\.\s*\}|,\s*\.\.\.$|^\s*\||^\s*[{\[\]}]|^\s*['"]|^\s*ℹ/; // ℹ = test-runner/status noise ("ℹ todo 0" was enqueued as a /list item by the 0.26.2 reviewer)
+const REVIEWER_VOCAB = /architectural-class|bug-class|refactor-class|strategic-class|reviewer found|cascade step|\*\*Mode\*\*|problems\s*\/\s*\(?(improvements|architectural)/i;
 
 export function classifyFindingText(line: string): FindingClass | undefined {
-  const t = line.trim();
+  // Strip list markers here too (extractFindings already does, but direct
+  // callers/tests pass raw report lines like "- ℹ todo 0").
+  const t = line.trim().replace(/^[-*>\s\[\]x]+/, "");
   if (t.length < 8) return undefined;
   if (SKIP_LINE.test(t) || REVIEWER_VOCAB.test(t)) return undefined;
   for (const { class: cls, re } of CLASS_PATTERNS) {
@@ -93,12 +95,23 @@ export function classifyFindingText(line: string): FindingClass | undefined {
   return undefined;
 }
 
-/** Scan source texts line-by-line for finding-shaped content. */
+/** v0.26.4: remove fenced code blocks and inline code spans. Quoted
+ * code is how completion summaries leak vocabulary into extraction —
+ * the 0.26.3 misfire matched a backticked reviewer.ts line containing
+ * four architectural patterns. */
+export function stripCodeSpans(text: string): string {
+  return text
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/`[^`\n]*`/g, " ");
+}
+
+/** Scan source texts line-by-line for finding-shaped content. Code
+ * spans are stripped first (v0.26.4) — findings live in prose. */
 export function extractFindings(sources: Array<{ name: string; text: string }>, max: number): Finding[] {
   const out: Finding[] = [];
   const seen = new Set<string>();
   for (const { name, text } of sources) {
-    for (const line of text.split("\n")) {
+    for (const line of stripCodeSpans(text).split("\n")) {
       const cls = classifyFindingText(line);
       if (!cls) continue;
       const clean = line.trim().replace(/^[-*>\s\[\]x]+/, "").slice(0, 200);

package/package.json

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