pi-goal-list-loop-audit 0.28.28 → 0.28.30

package/extensions/goal-loop-display.ts

@@ -276,11 +276,16 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   // queue work were a standalone goal.
   const isList = g.policy === "list";
   const statusWord = g.status === "active" ? paint(theme, "success", "active") : g.status;
+  // v0.28.30: the status line ALWAYS names the type (user note: "I don't
+  // always see the type — I'd need to scroll up to see if goal/list/loop").
+  // Before, only list items were named; a plain goal's card said "paused ·
+  // 3m" with no type word. The loop surface has its own card.
+  const typeWord = isList ? "list item · " : "goal · ";
   // Token segment only when a budget is set (v0.22.0): the guard is opt-in,
   // and "0/0 tok" carried no information when off.
   const tokenLimit = g.usage?.tokensLimit ?? 0;
   const tokens = tokenLimit > 0 ? ` · ${paint(theme, "dim", `${fmtTokens(g.usage?.tokensUsed ?? 0)}/${fmtTokens(tokenLimit)} tok`)}` : "";
-  const lines = [head, `├─ ${isList ? "list item · " : ""}${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))}${tokens}`];
+  const lines = [head, `├─ ${typeWord}${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))}${tokens}`];
   if (g.status === "auditing") {
     lines.push(`├─ auditor: ${audit?.label ?? "running"}${audit?.currentTool ? ` · ${truncate(audit.currentTool, 30)}` : ""}`);
     // v0.25.4: auditor-quiet stall — progress events stopped arriving

package/extensions/loops/goal.ts

@@ -482,35 +482,65 @@ const COMPACTION_GRACE_MS = 3 * 60_000;
 // brake (1m, 2m, 4m, 8m, 16m cap). A successful turn resets both.
 const ERROR_RETRY_LADDER_MS = [5_000, 15_000, 45_000, 90_000, 180_000];
 let errorBrakeStreak = 0;
-const SEND_REARM_LEDGER_EVERY = 600; // 600 × 50ms = 30s
-const SEND_REARM_ESCALATE_AT = 6000; // 6000 × 50ms = 5 minutes
+const SEND_REARM_LEDGER_MILESTONES_MS = [2 * 60_000, 5 * 60_000, 10 * 60_000];
+// v0.28.29: escalation is TIME-based and ACTIVITY-gated. A busy session is
+// NORMAL — the user conversing, or one long subagent turn — and the old
+// flat-50ms × 6000-count rule misread 5 minutes of busy as "wedged" and
+// paused the goal (the polis field report). Escalate only after 15 minutes
+// of failed sends AND no session activity in the last 5 minutes (a wedged
+// queue shows no events at all; a busy one streams constantly).
+const SEND_REARM_ESCALATE_AFTER_MS = 15 * 60_000;
+const SEND_REARM_ESCALATE_SILENT_MS = 5 * 60_000;
+let continuationRearmSince = 0;
+let loopRearmSince = 0;
+let continuationRearmMilestone = 0;
+let loopRearmMilestone = 0;
+
+/** v0.28.29: busy-retry cadence backs off — 50ms for the first beats
+ * (instant pickup right after a turn ends), then 250ms, 1s, 5s, 15s, 30s
+ * cap. agent_end reschedules independently, so the slow tail costs nothing
+ * in the common case; it only caps the ledger/CPU spam of a long busy stretch. */
+function sendRearmDelayMs(streak: number): number {
+  if (streak <= 4) return 50;
+  if (streak <= 8) return 250;
+  if (streak <= 12) return 1_000;
+  if (streak === 13) return 5_000;
+  if (streak === 14) return 15_000;
+  return 30_000;
+}
 
 function accountSendRearm(ctx: ExtensionContext, kind: "continuation" | "loop"): void {
   const streak = kind === "continuation" ? ++continuationRearmStreak : ++loopRearmStreak;
   if (streak === 1) {
+    if (kind === "continuation") { continuationRearmSince = Date.now(); continuationRearmMilestone = 0; } else { loopRearmSince = Date.now(); loopRearmMilestone = 0; }
     appendLedger(ctx.cwd, "send_rearm_start", { kind });
     return;
   }
-  if (streak % SEND_REARM_LEDGER_EVERY === 0) {
-    appendLedger(ctx.cwd, "send_rearm_storm", { kind, streak, minutes: Math.round((streak * BACKOFF_IDLE_RETRY_MS) / 60000) });
+  const since = kind === "continuation" ? continuationRearmSince : loopRearmSince;
+  const elapsed = Date.now() - since;
+  const milestone = kind === "continuation" ? continuationRearmMilestone : loopRearmMilestone;
+  if (milestone < SEND_REARM_LEDGER_MILESTONES_MS.length && elapsed >= SEND_REARM_LEDGER_MILESTONES_MS[milestone]!) {
+    if (kind === "continuation") continuationRearmMilestone++; else loopRearmMilestone++;
+    appendLedger(ctx.cwd, "send_rearm_storm", { kind, streak, minutes: Math.round(elapsed / 60000) });
   }
-  if (streak >= SEND_REARM_ESCALATE_AT) {
-    if (kind === "continuation") continuationRearmStreak = 0; else loopRearmStreak = 0;
+  if (elapsed >= SEND_REARM_ESCALATE_AFTER_MS && Date.now() - lastActivityAt >= SEND_REARM_ESCALATE_SILENT_MS) {
+    if (kind === "continuation") { continuationRearmStreak = 0; continuationRearmSince = 0; } else { loopRearmStreak = 0; loopRearmSince = 0; }
     escalateSendRearmStorm(ctx, kind);
   }
 }
 
 function escalateSendRearmStorm(ctx: ExtensionContext, kind: "continuation" | "loop"): void {
-  // Same loud-terminal shape as escalateStallNow (v0.24.7): a 5-minute
-  // re-arm storm means the session never goes idle for us — wedged queue
-  // or a busy-forever session. Bounded and surfaced, not silent.
-  const mins = Math.round((SEND_REARM_ESCALATE_AT * BACKOFF_IDLE_RETRY_MS) / 60000);
-  appendLedger(ctx.cwd, "send_rearm_escalated", { kind, streak: SEND_REARM_ESCALATE_AT });
+  // Same loud-terminal shape as escalateStallNow (v0.24.7). v0.28.29: this
+  // only fires on a REAL wedge now (15m of failed sends + 5m of zero
+  // session activity) — busy-but-alive sessions never reach it.
+  const mins = Math.round(SEND_REARM_ESCALATE_AFTER_MS / 60000);
+  const silent = Math.round(SEND_REARM_ESCALATE_SILENT_MS / 60000);
+  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 50ms re-arms — the session never went idle for the loop turn. 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 start again.` };
     persistState(ctx);
-    ctx.ui.notify(`Loop stopped: send-retry storm (${mins}m). Restart pi and /loop start.`, "warning");
+    ctx.ui.notify(`Loop stopped: send-retry storm (${mins}m, session silent ${silent}m). Restart pi and /loop start.`, "warning");
     notifyExternal(ctx, "Loop stopped: send-retry storm.");
     return;
   }
@@ -518,11 +548,11 @@ function escalateSendRearmStorm(ctx: ExtensionContext, kind: "continuation" | "l
     updateGoal({
       status: "paused",
       pauseKind: "error",
-      pauseReason: `send-retry storm: ${mins}m of 50ms re-arms — the session never went idle for the continuation`,
-      pauseSuggestedAction: "The session never went idle for the send (wedged queue or permanently busy). Restart pi, then /goal resume.",
+      pauseReason: `send-retry storm: ${mins}m of re-arms with no session activity for ${silent}m — the session never went idle for the continuation`,
+      pauseSuggestedAction: "The session produced no events while the send retried (wedged queue). Restart pi, then /goal resume.",
     }, ctx);
-    ctx.ui.notify(`Goal paused: send-retry storm (${mins}m). Restart pi, then /goal resume.`, "warning");
-    notifyExternal(ctx, "Goal paused: send-retry storm.");
+    ctx.ui.notify(`${goalNoun()} paused: send-retry storm (${mins}m, session silent ${silent}m). Restart pi, then /goal resume.`, "warning");
+    notifyExternal(ctx, `${goalNoun()} paused: send-retry storm.`);
   }
 }
 
@@ -545,8 +575,8 @@ function escalateStallNow(ctx: ExtensionContext, threshold: number): boolean {
       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).");
+    ctx.ui.notify(`${goalNoun()} paused: ${threshold} refires produced no turn. Restart pi, then /goal resume.`, "warning");
+    notifyExternal(ctx, `${goalNoun()} paused: stalled (continuation not landing).`);
     return true;
   }
   return true;
@@ -629,7 +659,7 @@ function heartbeatTick(): void {
     })
   ) {
     lastWedgeAlertAt = Date.now();
-    const msg = `Goal appears wedged: no activity for ${Math.round((Date.now() - lastActivityAt) / 60_000)}m while the session is busy — likely a hung command (test/build/dev server without a timeout). Check the session; Esc kills a stuck tool call.`;
+    const msg = `${goalNoun()} appears wedged: no activity for ${Math.round((Date.now() - lastActivityAt) / 60_000)}m while the session is busy — likely a hung command (test/build/dev server without a timeout). Check the session; Esc kills a stuck tool call.`;
     appendLedger(ctx.cwd, "wedge_alert", { silentMs: Date.now() - lastActivityAt });
     ctx.ui.notify(msg, "warning");
     notifyExternal(ctx, msg);
@@ -736,10 +766,10 @@ function sendContinuation(goalId: string): void {
     return;
   }
   if (!ctx.isIdle() || ctx.hasPendingMessages()) {
-    // v0.28.5 (E3): count + ledger + escalate the re-arm storm.
     accountSendRearm(ctx, "continuation");
     continuationScheduledFor = goalId;
-    continuationTimer = setTimeout(() => sendContinuation(goalId), BACKOFF_IDLE_RETRY_MS);
+    // v0.28.29: backing-off cadence (was flat 50ms — 6,000 spins in 5m).
+    continuationTimer = setTimeout(() => sendContinuation(goalId), sendRearmDelayMs(continuationRearmStreak));
     continuationTimer.unref?.();
     return;
   }
@@ -750,7 +780,7 @@ function sendContinuation(goalId: string): void {
       content: continuationPrompt(state.goal!),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
-    continuationRearmStreak = 0; // v0.28.5 (E3): a landed send clears the storm
+    continuationRearmStreak = 0; continuationRearmSince = 0; // v0.28.5 (E3): a landed send clears the storm
     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) });
@@ -880,6 +910,9 @@ let persistenceDegradedNotified = false;
 
 /** v0.28.11 (U9): objective-first notifies — truncate long objectives. */
 const shortObj = (s: string): string => (s.length > 90 ? `${s.slice(0, 87)}…` : s);
+/** v0.28.30: terminology — a list item is not a goal (user note: "we seem
+ * to call everything goal"). User-facing pause/abort notifies name the policy. */
+const goalNoun = (): string => (state.goal?.policy === "list" ? "List item" : "Goal");
 function notifyPersistenceState(ctx: ExtensionContext): void {
   if (isPersistenceDegraded() && !persistenceDegradedNotified) {
     persistenceDegradedNotified = true;
@@ -1491,7 +1524,7 @@ async function cmdCancel(ctx: ExtensionContext): Promise<void> {
   }
   archiveCurrentGoal(ctx, "aborted", "user cancelled");
   ctx.abort();
-  ctx.ui.notify(`Goal aborted.${isLoopActive() ? " A loop is still active — /loop stop ends it." : ""}`, "info");
+  ctx.ui.notify(`${goalNoun()} aborted.${isLoopActive() ? " A loop is still active — /loop stop ends it." : ""}`, "info");
 }
 
 // ---- v0.28.23: decision picker popup ----
@@ -2011,8 +2044,8 @@ function sendLoopTurn(): void {
   if (!isLoopActive() || !extensionApi) return;
   const ctx = freshCtx();
   if (!ctx || !ctx.isIdle() || ctx.hasPendingMessages()) {
-    if (ctx) accountSendRearm(ctx, "loop"); // v0.28.5 (E3)
-    loopTimer = setTimeout(() => sendLoopTurn(), BACKOFF_IDLE_RETRY_MS);
+    if (ctx) accountSendRearm(ctx, "loop");
+    loopTimer = setTimeout(() => sendLoopTurn(), sendRearmDelayMs(loopRearmStreak)); // v0.28.29: backing-off cadence
     loopTimer.unref?.();
     return;
   }
@@ -2059,7 +2092,7 @@ function sendLoopTurn(): void {
     }, { triggerTurn: true, deliverAs: "followUp" });
     // v0.26.1: the send path is ledgered — the hegemon zombie spun 619
     // refires with zero visibility into whether sends were landing.
-    loopRearmStreak = 0; // v0.28.5 (E3): a landed turn clears the storm
+    loopRearmStreak = 0; loopRearmSince = 0; // v0.28.5 (E3): a landed turn clears the storm
     appendLedger(ctx.cwd, "loop_turn_sent", { iteration: loop.iteration });
   } catch (err) {
     // stale API — next agent_end reschedules (but if none comes, the
@@ -2807,8 +2840,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
             pauseSuggestedAction: "Fix the auditor model (/glla model=provider/id) or restart pi, then /goal resume. Your work was NOT judged.",
           }, ctx);
           appendLedger(ctx.cwd, "goal_paused", { reason: `auditor infra streak ${infraStreak}: ${result.error.slice(0, 120)}` });
-          ctx.ui.notify(`Goal paused: auditor infrastructure failed ${infraStreak}× in a row. Fix the auditor model (/glla model=...), then /goal resume.`, "warning");
-          notifyExternal(ctx, `Goal paused: auditor infrastructure ${infraStreak}× — model likely broken.`);
+          ctx.ui.notify(`${goalNoun()} paused: auditor infrastructure failed ${infraStreak}× in a row. Fix the auditor model (/glla model=...), then /goal resume.`, "warning");
+          notifyExternal(ctx, `${goalNoun()} paused: auditor infrastructure ${infraStreak}× — model likely broken.`);
           return {
             content: [{
               type: "text",
@@ -2915,7 +2948,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           pauseReason: `auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap})`,
           pauseSuggestedAction: "Read the audit history (/goal status), fix the actual gap or /goal tweak the objective, then /goal resume. Raise the cap with /glla auditcap=N.",
         }, ctx);
-        ctx.ui.notify(`Goal paused: auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap}). /goal status for the reports; /goal resume to continue.`, "warning");
+        ctx.ui.notify(`${goalNoun()} paused: auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap}). /goal status for the reports; /goal resume to continue.`, "warning");
           maybeDecisionPopup(ctx);
         appendLedger(ctx.cwd, "goal_paused", { reason: `disapproval cap: ${trailingDisapprovals} consecutive (cap ${auditCap})` });
         notifyExternal(ctx, `Goal paused: ${trailingDisapprovals} consecutive auditor disapprovals`);
@@ -2975,8 +3008,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // action. Before, the action only appeared in /goal status and the
       // widget truncated both at ~60 chars, so decision-pauses ("choose a
       // or b") reached the user as an unreadable fragment.
-      ctx.ui.notify(`Goal paused: ${p.reason}${p.suggestedAction ? `\n\n→ ${p.suggestedAction}` : ""}`, "info");
-      notifyExternal(ctx, `Goal paused: ${(p.suggestedAction ? `${p.reason} → ${p.suggestedAction}` : p.reason).slice(0, 200)}`);
+      ctx.ui.notify(`${goalNoun()} paused: ${p.reason}${p.suggestedAction ? `\n\n→ ${p.suggestedAction}` : ""}`, "info");
+      notifyExternal(ctx, `${goalNoun()} paused: ${(p.suggestedAction ? `${p.reason} → ${p.suggestedAction}` : p.reason).slice(0, 200)}`);
       return { content: [{ type: "text", text: "Goal paused. /goal resume to continue." }], details: {} };
     },
   }));
@@ -4702,8 +4735,8 @@ export default function (pi: ExtensionAPI): void {
     // v0.28.24: a compaction is LEGITIMATE busy time — reset the send-rearm
     // storm streaks (π-web nearly escalated a "send-retry storm" pause during
     // a 3.5-minute compact) and open the post-compaction stall grace.
-    continuationRearmStreak = 0;
-    loopRearmStreak = 0;
+    continuationRearmStreak = 0; continuationRearmSince = 0;
+    loopRearmStreak = 0; loopRearmSince = 0;
     compactionGraceUntil = Date.now() + COMPACTION_GRACE_MS;
     const settle = setTimeout(() => {
       const c = freshCtx();
@@ -5027,7 +5060,7 @@ export default function (pi: ExtensionAPI): void {
             pauseReason: `stalled: ${HEARTBEAT_MAX_NUDGES} consecutive unproductive turns (no tools, short or repetitive)`,
             pauseSuggestedAction: "Inspect the goal — /goal resume to retry, /goal tweak to narrow it, /goal cancel to abort.",
           }, ctx);
-          ctx.ui.notify(`Goal paused: stalled (${HEARTBEAT_MAX_NUDGES} unproductive turns).`, "warning");
+          ctx.ui.notify(`${goalNoun()} paused: stalled (${HEARTBEAT_MAX_NUDGES} unproductive turns).`, "warning");
           maybeDecisionPopup(ctx);
           notifyExternal(ctx, "Goal paused: stalled (no tool calls).");
           return;
@@ -5076,7 +5109,7 @@ export default function (pi: ExtensionAPI): void {
           pauseReason: `token limit exceeded (${used.toLocaleString()} > ${limit.toLocaleString()})`,
           pauseSuggestedAction: "/glla tokenlimit=<n> to raise the cap (or 0 to disable), then /goal resume",
         }, ctx);
-        ctx.ui.notify(`Goal paused: token limit exceeded (${used.toLocaleString()} > ${limit.toLocaleString()}). /glla tokenlimit=<n> to raise, 0 to disable.`, "warning");
+        ctx.ui.notify(`${goalNoun()} paused: token limit exceeded (${used.toLocaleString()} > ${limit.toLocaleString()}). /glla tokenlimit=<n> to raise, 0 to disable.`, "warning");
         notifyExternal(ctx, `Goal paused: token limit exceeded (${used} > ${limit}).`);
         return;
       }

package/package.json

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