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

package/extensions/goal-loop-core.ts

@@ -917,6 +917,8 @@ export function isAutoCommitPaused(cwd: string): boolean {
 /** Suppress the heartbeat when work shipped very recently — a session
  * that just committed is transitioning, not stalled. Pure; the tick
  * gathers the timestamps. */
+/** @deprecated v0.26.6: no longer called by the heartbeat (self-sustaining
+ * under ledger writes / auto-commit daemons). Kept for API compatibility. */
 export function shouldSuppressHeartbeatForRecentShip(args: {
   nowMs: number;
   lastShippedAtMs: number | null;
@@ -929,7 +931,20 @@ export function shouldSuppressHeartbeatForRecentShip(args: {
 
 /** Best-effort "when did work last ship" for a repo: newest of the HEAD
  * commit time and the .pi-glla state file mtime. Null when unknown. */
+/** v0.26.7: pi's exact stale-runtime error signature — thrown by every
+ * runtime-bound method after pi invalidates the extension on session
+ * replacement (newSession/fork/switchSession/reload; compaction reaches
+ * the same teardown in pi 0.82.x). See dist/core/extensions/loader.js
+ * createExtensionRuntime().invalidate. */
+export function isStaleApiError(err: unknown): boolean {
+  return err instanceof Error && err.message.includes("stale after session replacement");
+}
+
 export function lastShippedAtMs(cwd: string): number | null {
+  // v0.26.6: the .pi-glla/active.jsonl MTIME term was REMOVED — the
+  // heartbeat's own ledger writes refreshed it every 15s, which made the
+  // 0.25.0 ship-suppression self-sustaining (darklord: 9.1h / 2,184
+  // suppressed ticks). Only a real git commit counts as a ship now.
   let best: number | null = null;
   try {
     const out = execSync("git log -1 --format=%ct", { cwd, stdio: ["ignore", "pipe", "ignore"] })
@@ -940,12 +955,6 @@ export function lastShippedAtMs(cwd: string): number | null {
   } catch {
     /* not a git repo or no commits */
   }
-  try {
-    const mtime = fs.statSync(path.join(cwd, ".pi-glla", "active.jsonl")).mtimeMs;
-    if (best === null || mtime > best) best = mtime;
-  } catch {
-    /* no state file yet */
-  }
   return best;
 }
 

package/extensions/loops/goal.ts

@@ -38,7 +38,6 @@ import {
   classifyImpossibleReason,
   extractPendingTasks,
   isFullAuditObjective,
-  lastShippedAtMs,
   resolveEffectiveAggressiveSettings,
   appendAuditLog,
   computeListDepth,
@@ -52,7 +51,7 @@ import {
   crossRecommendMode,
   formatListDepth,
   shouldEscalateStall,
-  shouldSuppressHeartbeatForRecentShip,
+  isStaleApiError,
   mergeSettings,
   parseListImport,
 
@@ -179,6 +178,30 @@ const HELD_ON_RESTORE = "held: restored in a fresh session";
 // The ExtensionAPI captured in the factory. sendMessage lives on the API,
 // not on ExtensionContext, so continuation sends need it at module scope.
 let extensionApi: ExtensionAPI | null = null;
+// v0.26.7: pi invalidates the extension runtime on session replacement
+// (newSession/fork/switchSession/reload — and the compaction path reaches
+// it via teardownCurrent in pi 0.82.x). Once stale, every sendMessage
+// throws FOREVER in this process — retrying for hours is the hegemon
+// failure shape. Detect the stale signature once and go terminally loud.
+let extensionApiStale = false;
+
+/** v0.26.7: a stale api is terminal for this process — pause/stop loudly
+ * with restart guidance instead of retrying sends that can never land. */
+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), then /goal resume / /loop start.";
+  if (isLoopActive()) {
+    clearLoopTimer();
+    state.loop = { ...state.loop!, active: false, stopReason: `extension api stale: ${guidance}` };
+    persistState(ctx);
+  } else if (state.goal && state.goal.status === "active") {
+    updateGoal({ status: "paused", pauseReason: "extension api stale (pi session replacement)", pauseSuggestedAction: guidance }, ctx);
+  }
+  ctx.ui.notify(`glla: ${guidance}`, "warning");
+  notifyExternal(ctx, `glla: extension api stale — restart pi. (${where})`);
+}
 
 // The most recent ExtensionContext seen from any event or command handler.
 // pi replaces sessions (newSession/fork/reload) and stale ctx throws on use,
@@ -240,6 +263,10 @@ let heartbeatNudges = 0;
 // refire's own noteActivity, which is what made the hegemon zombie spin
 // self-sustaining (619 refires / 23.5h / zero turns).
 let consecutiveStalls = 0;
+// v0.26.6: precise replacement for the removed ship-recency suppression —
+// set while complete_goal's isolated audit runs, so the heartbeat never
+// refires into an in-flight completion.
+let completionAuditInFlight = false;
 let heartbeatTimer: NodeJS.Timeout | null = null;
 
 function noteActivity(real = false): void {
@@ -381,18 +408,16 @@ function heartbeatTick(): void {
     notifyExternal(ctx, msg);
   }
   if (!fire) return;
-  // v0.25.0 (contract item 27): a session that SHIPPED in the last 5
-  // minutes (commit or ledger write) is transitioning, not stalled —
-  // suppress the refire so rapid iteration isn't interrupted.
-  if (
-    shouldSuppressHeartbeatForRecentShip({
-      nowMs: Date.now(),
-      lastShippedAtMs: lastShippedAtMs(ctx.cwd),
-    })
-  ) {
-    appendLedger(ctx.cwd, "heartbeat_suppressed", { reason: "recent ship (<5m)" });
-    return;
-  }
+  // v0.26.6: the 0.25.0 "recent ship (<5m)" suppression was REMOVED. It fed
+  // lastShippedAtMs, which read the state-file MTIME — and the heartbeat's
+  // own suppressed-tick ledger writes refreshed that mtime every 15s,
+  // making the suppression self-sustaining forever (field-observed in
+  // darklord: 2,184 suppressed ticks over 9.1h after a post-compaction
+  // send failure; the completed list item never closed). Under an
+  // auto-committing daemon the git-head term self-sustains too. The legit
+  // windows are already covered precisely — busy mid-turn, pending
+  // messages, scheduled timers — plus the audit-in-flight flag below.
+  if (completionAuditInFlight) return;
   noteActivity();
   consecutiveStalls++;
   appendLedger(ctx.cwd, "heartbeat_refire", { nudgesSoFar: heartbeatNudges, consecutiveStalls });
@@ -486,7 +511,7 @@ function sendContinuation(goalId: string): void {
     continuationTimer.unref?.();
     return;
   }
-  if (!extensionApi) return;
+  if (!extensionApi || extensionApiStale) return;
   try {
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
@@ -496,7 +521,9 @@ function sendContinuation(goalId: string): void {
     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.
+    // v0.26.7: stale runtime = terminal (sends can never land); anything
+    // else is transient — next agent_end/session_start reschedules.
+    if (isStaleApiError(err)) goStaleTerminal(ctx, "sendContinuation");
   }
 }
 
@@ -1268,7 +1295,7 @@ function isLoopActive(): boolean {
 
 /** Run the user's measure command. Orchestrator-side, never agent-side. */
 async function runMeasure(ctx: ExtensionContext, cmd: string): Promise<number | null> {
-  if (!extensionApi) return null;
+  if (!extensionApi || extensionApiStale) return null;
   try {
     const result = await extensionApi.exec("bash", ["-c", cmd], { cwd: ctx.cwd, timeout: MEASURE_TIMEOUT_MS });
     const stdout = (result as any)?.stdout ?? "";
@@ -1392,6 +1419,8 @@ function sendLoopTurn(): void {
     // 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) });
+    // v0.26.7: stale runtime is terminal, not transient — go loud now.
+    if (isStaleApiError(err)) goStaleTerminal(ctx, "sendLoopTurn");
   }
 }
 
@@ -1894,13 +1923,20 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // retry with backoff before we report "auditor infrastructure error
       // (retried once)". Neither attempt is a verdict on the work.
       const auditStartMs = Date.now();
-      const { result, retriedOnce } = await runWithInfraRetry(runAudit, {
-        onRetry: (err) => {
-          latestAuditProgress = { label: `infra error (${err.slice(0, 40)}) — retrying once`, lastEventAt: Date.now() };
-          refreshUI(ctx);
-          appendLedger(ctx.cwd, "audit_infra_retry", { goalId: state.goal?.id, error: err.slice(0, 200) });
-        },
-      });
+      completionAuditInFlight = true;
+      let result: Awaited<ReturnType<typeof runAudit>>;
+      let retriedOnce = false;
+      try {
+        ({ result, retriedOnce } = await runWithInfraRetry(runAudit, {
+          onRetry: (err) => {
+            latestAuditProgress = { label: `infra error (${err.slice(0, 40)}) — retrying once`, lastEventAt: Date.now() };
+            refreshUI(ctx);
+            appendLedger(ctx.cwd, "audit_infra_retry", { goalId: state.goal?.id, error: err.slice(0, 200) });
+          },
+        }));
+      } finally {
+        completionAuditInFlight = false;
+      }
       const auditDurationMs = Date.now() - auditStartMs;
       latestAuditProgress = null;
       // Audit history: record REAL verdicts only — a non-empty report is the
@@ -3373,6 +3409,7 @@ function warnOnCommandCollision(ctx: ExtensionContext): void {
 
 export default function (pi: ExtensionAPI): void {
   extensionApi = pi;
+  extensionApiStale = false; // a fresh factory run means a fresh runtime (reload path)
   startHeartbeat();
   startUITicker();
   // Four top-level commands, that's all (v0.8.0 consolidation):

package/package.json

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