pi-goal-list-loop-audit 0.34.18 → 0.34.20

package/extensions/goal-loop-core.ts

@@ -1313,15 +1313,42 @@ export interface InfraRetryOutcome<T> {
  * (retried once)". The failed pair is never a verdict on the work. */
 export async function runWithInfraRetry<T extends { error?: string; approved: boolean; disapproved: boolean }>(
   run: () => Promise<T>,
-  opts: { backoffMs?: number; sleep?: (ms: number) => Promise<void>; onRetry?: (error: string) => void } = {},
+  opts: {
+    backoffMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    onRetry?: (error: string) => void;
+    /**
+     * v0.34.20: delayed retry callers can fail closed across a session
+     * replacement. The first attempt may finish after its ExtensionContext
+     * was invalidated; never launch the second attempt unless the caller can
+     * prove that its session/generation is still live.
+     */
+    shouldRetry?: () => boolean;
+  } = {},
 ): Promise<InfraRetryOutcome<T>> {
   const sleep = opts.sleep ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
   const first = await run();
   if (first.approved || first.disapproved || !isRetriableInfraError(first.error)) {
     return { result: first, retriedOnce: false };
   }
+  if (opts.shouldRetry) {
+    try {
+      if (!opts.shouldRetry()) return { result: first, retriedOnce: false };
+    } catch {
+      // A lifecycle probe that cannot establish liveness is a hard stop, not
+      // permission to retry an old session.
+      return { result: first, retriedOnce: false };
+    }
+  }
   opts.onRetry?.(first.error!);
   await sleep(opts.backoffMs ?? 5000);
+  if (opts.shouldRetry) {
+    try {
+      if (!opts.shouldRetry()) return { result: first, retriedOnce: false };
+    } catch {
+      return { result: first, retriedOnce: false };
+    }
+  }
   const second = await run();
   return { result: second, retriedOnce: true };
 }

package/extensions/goal-loop-display.ts

@@ -310,17 +310,24 @@ function heldLoopLines(l: LoopState, now: number, theme?: DisplayTheme, width?:
 function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | undefined, now: number, theme?: DisplayTheme, width?: number, extras?: WidgetExtras): string[] {
   // Head glyph is ● (not ◆): U+25C6 renders as a color-emoji diamond in some
   // terminal fonts and ignores ANSI color; ● takes the paint everywhere.
+  const interrupted = g.status === "active" && !!g.interruptedAt;
   const icon =
-    g.status === "paused"
-      ? paint(theme, pauseIsError(g) ? "error" : "warning", "⏸")
-      : g.status === "auditing"
-        ? paint(theme, "accent", "⟡")
-        : paint(theme, "success", "●");
+    interrupted
+      ? paint(theme, "error", "⚠")
+      : g.status === "paused"
+        ? paint(theme, pauseIsError(g) ? "error" : "warning", "⏸")
+        : g.status === "auditing"
+          ? paint(theme, "accent", "⟡")
+          : paint(theme, "success", "●");
   // v0.24.7: a list item is named as such and points at /list — before,
   // the widget called it "active" and hinted "/goal status", reading as if
   // queue work were a standalone goal.
   const isList = g.policy === "list";
-  const statusWord = g.status === "active" ? paint(theme, "success", "active") : g.status;
+  const statusWord = interrupted
+    ? paint(theme, "error", "interrupted")
+    : g.status === "active"
+      ? paint(theme, "success", "active")
+      : g.status;
   // v0.33.0: slim card — status folds INTO the head line as middot segments
   // (filter(Boolean).join, the universal CLI idiom). Line 2 is the live
   // "last action · next task" line; the footer stays the hint line.
@@ -351,6 +358,12 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   const objBudget = width && width > 0 ? Math.max(16, width - 1 - 2 - 3 - visibleLen(segsText)) : 48;
   const head = `${icon} ${truncate(g.objective.replace(/\s+/g, " "), objBudget)} ${paint(theme, "dim", "·")} ${segsText}`;
   const lines = [head];
+  if (interrupted) {
+    const resumeCmd = isList ? "/list resume" : "/goal resume";
+    lines.push(`├─ ${paint(theme, "error", "host session lost — waiting for fresh session_start")}`);
+    lines.push(`└─ ${paint(theme, "warning", `/reload to rebind · ${resumeCmd} if it does not resume`)}`);
+    return lines;
+  }
   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/length-continue.ts

@@ -35,6 +35,48 @@ export interface LengthContinueTick {
   consecutive: number;
 }
 
+export interface ContextUsageLike {
+  tokens?: number | null;
+  contextWindow?: number;
+  percent?: number | null;
+}
+
+export interface AssistantLengthMessageLike {
+  stopReason?: string;
+  usage?: {
+    output?: number;
+  };
+}
+
+export const LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT = 90;
+export const LENGTH_CONTINUE_CONTEXT_STARVED_MAX_OUTPUT = 8;
+
+/**
+ * v0.34.19: distinguish a REAL overlong assistant response from pi's
+ * context-safety clamp. Near the configured context ceiling,
+ * pi-ai's clampMaxTokensToContext() can reduce max_tokens to 1; MiniMax then
+ * returns stopReason "length" with ~1 output token. That is context
+ * starvation: auto-compaction must own recovery. Sending LENGTH_CONTINUE_TEXT
+ * here queues another 1-token request before pi's post-agent_end compaction
+ * check and delays the actual cure (field: darklord 2026-08-02, 198,116 /
+ * 198,179 total tokens of a 200,000 window, output=1 twice).
+ */
+export function isContextStarvedLengthStop(
+  message: AssistantLengthMessageLike | null | undefined,
+  contextUsage: ContextUsageLike | null | undefined,
+): boolean {
+  if (message?.stopReason !== "length") return false;
+  const output = message.usage?.output;
+  if (typeof output !== "number" || !Number.isFinite(output)) return false;
+  if (output > LENGTH_CONTINUE_CONTEXT_STARVED_MAX_OUTPUT) return false;
+  const percent = typeof contextUsage?.percent === "number"
+    ? contextUsage.percent
+    : typeof contextUsage?.tokens === "number" && typeof contextUsage?.contextWindow === "number" && contextUsage.contextWindow > 0
+      ? (contextUsage.tokens / contextUsage.contextWindow) * 100
+      : null;
+  return percent !== null && Number.isFinite(percent) && percent >= LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT;
+}
+
 export function makeLengthContinueTracker(max: number = LENGTH_CONTINUE_MAX) {
   let consecutive = 0;
   let gaveUp = false;

package/extensions/loops/goal.ts

@@ -92,6 +92,7 @@ import {
 import {
   LENGTH_CONTINUE_MAX,
   LENGTH_CONTINUE_TEXT,
+  isContextStarvedLengthStop,
   resetLengthContinue,
   tickLengthContinue,
 } from "../length-continue.js";
@@ -231,6 +232,11 @@ let extensionApiStale = false;
 // path must still ledger the stale handle, stop stale work, and preserve the
 // interrupt marker so a later fresh lifecycle can restore it.
 let staleTerminalDone = false;
+// v0.34.19: delayed session-owned callbacks capture this generation. A
+// clearTimeout can race a callback already queued by Node; without a
+// generation check, an old compaction/refire callback can run after /reload
+// and schedule work against the fresh session.
+let sessionGeneration = 0;
 
 /** v0.26.7: a stale api is terminal for this process — go loudly with
  * restart guidance instead of retrying sends that can never land.
@@ -309,6 +315,10 @@ function goStaleTerminal(ctx: ExtensionContext, where: string): void {
   } else if (state.goal && state.goal.status === "active") {
     updateGoal({ interruptedAt: nowIso(), interruptedReason: `extension api stale (${where})` }, ctx);
   }
+  // The stale process loses its ticker immediately, so paint the durable
+  // interrupted state synchronously while the old UI handle can still accept
+  // updates. The next session_start paints it again from disk.
+  refreshUI(ctx);
   ctx.ui.notify(`glla: ${guidance}`, "warning");
   notifyExternal(ctx, `glla: extension api stale — waiting for a fresh session_start; restart pi normally only if no replacement arrives. (${where})`);
 }
@@ -622,6 +632,10 @@ function releaseInitialSessionLoadBarrier(): void {
 }
 
 function rememberCtx(ctx: ExtensionContext): void {
+  // Late events from a disposed session must never reclaim lastCtx after the
+  // lifecycle handoff has been declared. Only session_start clears these
+  // gates and may bind a fresh context.
+  if (sessionHandoffPending || staleTerminalDone || zombieStoodDown) return;
   let ownerLive = false;
   if (ownerSession && lastCtx) {
     try { lastCtx.isIdle(); ownerLive = true; } catch { /* owner went stale (session replaced) */ }
@@ -692,6 +706,9 @@ let carryoverResolved = true;
 // set while complete_goal's isolated audit runs, so the heartbeat never
 // refires into an in-flight completion.
 let completionAuditInFlight = false;
+// v0.34.20: an old auditor's finally block must not clear the in-flight
+// marker belonging to a fresh lifecycle generation.
+let completionAuditGeneration: number | null = null;
 // v0.32.0: consecutive stored-claim quota retries (capped at 5, then hold).
 let quotaRetryStreak = 0;
 let heartbeatTimer: NodeJS.Timeout | null = null;
@@ -1065,7 +1082,7 @@ function heartbeatTick(): void {
     appendLedger(ctx.cwd, "stranded_audit_recovered", { goalId: state.goal.id, via: state.goal.pendingCompletion ? "stored-claim" : "resume-active" });
     if (state.goal.pendingCompletion) {
       ctx.ui.notify("Recovering a completion audit whose result never landed — re-running the auditor with the stored claim.", "info");
-      void retryStoredCompletionAudit(ctx, "quota-retry");
+      void retryStoredCompletionAudit("quota-retry");
     } else {
       updateGoal({ status: "active" }, ctx);
       ctx.ui.notify("A completion audit was interrupted (its result never landed). Resuming — re-call complete_goal when the deliverable still stands.", "warning");
@@ -1210,9 +1227,19 @@ function clearContinuationTimer(): void {
 }
 
 function scheduleSessionTimeout(callback: () => void, delayMs: number): NodeJS.Timeout {
+  const generation = sessionGeneration;
   let timer: NodeJS.Timeout;
   timer = setTimeout(() => {
     sessionTimeouts.delete(timer);
+    // clearTimeout is not enough when the callback is already queued. Do not
+    // let an old session's callback re-arm work after stale/shutdown/reload.
+    if (
+      generation !== sessionGeneration ||
+      sessionHandoffPending ||
+      extensionApiStale ||
+      staleTerminalDone ||
+      zombieStoodDown
+    ) return;
     callback();
   }, delayMs);
   sessionTimeouts.add(timer);
@@ -1222,6 +1249,7 @@ function scheduleSessionTimeout(callback: () => void, delayMs: number): NodeJS.T
 
 function clearSessionOwnedTimers(): void {
   sessionHandoffPending = true;
+  sessionGeneration++;
   initialSessionLoadPending = false;
   clearContinuationTimer();
   clearLoopTimer();
@@ -1253,6 +1281,53 @@ function freshCtx(): ExtensionContext | null {
   }
 }
 
+/**
+ * v0.34.20: a timer can already be queued when clearSessionOwnedTimers()
+ * runs, and an async audit can finish after a replacement without a queued
+ * timer at all. Delayed work must prove both facts before touching pi:
+ * generation identity is unchanged and the context probe succeeds. A null
+ * result is a normal fail-closed handoff, not a reason to use the caller's
+ * captured context as a fallback.
+ */
+function freshCtxForGeneration(generation: number): ExtensionContext | null {
+  if (
+    generation !== sessionGeneration ||
+    sessionHandoffPending ||
+    initialSessionLoadPending ||
+    extensionApiStale ||
+    staleTerminalDone ||
+    zombieStoodDown
+  ) return null;
+  return freshCtx();
+}
+
+/**
+ * v0.34.20: the generic quota helper owns only the wall-clock timer and the
+ * immediate notification. This adapter owns the session boundary: callbacks
+ * receive a context proven fresh at fire time and may not close over the
+ * scheduling event's ctx.
+ */
+function scheduleQuotaRetryForSession(
+  ctx: ExtensionContext,
+  retryAfterSec: number,
+  reason: string,
+  fire: (ctx: ExtensionContext) => void | Promise<void>,
+  label?: string,
+): void {
+  const generation = sessionGeneration;
+  scheduleQuotaRetry(ctx, retryAfterSec, reason, () => {
+    const current = freshCtxForGeneration(generation);
+    if (!current) return;
+    try {
+      void Promise.resolve(fire(current)).catch((err) => {
+        if (isStaleApiError(err)) extensionApiStale = true;
+      });
+    } catch (err) {
+      if (isStaleApiError(err)) extensionApiStale = true;
+    }
+  }, label);
+}
+
 // v0.34.15 (hegemon 2026-08-01): pi ACCEPTED the continuation — footer showed
 // "1 queued" — but the turn trigger was dead, so the message sat queued while
 // pi idled. The 0.34.11 watchdog gates on "pi reported NO pending" and the
@@ -1285,7 +1360,7 @@ function armQueueStuckProbe(sentAt: number): void {
 }
 
 function scheduleContinuation(ctx: ExtensionContext, force = false, delayMs?: number): void {
-  if (sessionHandoffPending || initialSessionLoadPending) return;
+  if (sessionHandoffPending || initialSessionLoadPending || extensionApiStale || staleTerminalDone || zombieStoodDown) return;
   abortedStandDown = false; // v0.29.5: any explicit schedule ends the stand-down
   if (!isActionableGoal()) return;
   rememberCtx(ctx);
@@ -1303,7 +1378,7 @@ function scheduleContinuation(ctx: ExtensionContext, force = false, delayMs?: nu
 }
 
 function sendContinuation(goalId: string): void {
-  if (sessionHandoffPending || initialSessionLoadPending) return;
+  if (sessionHandoffPending || initialSessionLoadPending || extensionApiStale || staleTerminalDone || zombieStoodDown) return;
   continuationTimer = null;
   continuationScheduledFor = null;
   if (!isActionableGoal()) return;
@@ -1578,11 +1653,13 @@ function autoArbitrateStackedState(ctx: ExtensionContext): void {
  * against the live queue), present DECIDE findings without queueing them.
  * Confirm-gated like every bulk import (v0.23.7: the user reads what lands
  * in the queue); a decline leaves the findings open for a later re-run.
+ * v0.34.20: this detached operation retains only cwd + generation. Every
+ * context use after the confirmation await must come from the fresh session.
  */
-async function fanOutListAuditFindings(ctx: ExtensionContext): Promise<void> {
+async function fanOutListAuditFindings(cwd: string, generation: number): Promise<void> {
   let md = "";
   try {
-    md = fs.readFileSync(path.join(ctx.cwd, AUDIT_FINDINGS_REL), "utf-8");
+    md = fs.readFileSync(path.join(cwd, AUDIT_FINDINGS_REL), "utf-8");
   } catch {
     /* no findings file — the audit was clean or never wrote */
   }
@@ -1594,6 +1671,8 @@ async function fanOutListAuditFindings(ctx: ExtensionContext): Promise<void> {
   // hundreds of items on a single Confirm.
   const fresh = open.filter((f) => !queuedText.includes(f.text.slice(0, 60))).slice(0, 50);
   const alreadyQueued = open.length - fresh.length;
+  const current = freshCtxForGeneration(generation);
+  if (!current) return;
   // v0.33.3: DECIDE findings are RAISED TO THE USER as real questions
   // (hegemon 2026-07-31: a truncated notify left the user typing "decide
   // what" into the void). The orchestrator can't call ask_user_question —
@@ -1603,41 +1682,48 @@ async function fanOutListAuditFindings(ctx: ExtensionContext): Promise<void> {
   // queued or the fan-out was declined.
   if (decisions.length > 0) {
     const decList = decisions.slice(0, 8).map((d, i) => `${i + 1}. ${d.slice(0, 500)}`).join("\n");
-    if (safeSteerUser(ctx,
+    if (safeSteerUser(current,
       `[DECIDE FINDINGS — user decisions needed] The audit surfaced ${decisions.length} DECIDE finding(s) — direction calls only the user can make (a decision is not a task, so they were NOT queued):\n${decList}\nRaise them to the user NOW with ask_user_question — one question per finding, options from the finding's own two sides plus "Defer" (prose numbered list if ask_user_question is unavailable; Esc = Defer). Then record every answer in ${AUDIT_FINDINGS_REL}: replace the "- [?]" line with "- [x] DECIDED: <what was chosen> (<date>)" (or "- [x] DEFERRED") so it stops re-surfacing, and queue any chosen work with list_add — do NOT start the work inline.`))
-      appendLedger(ctx.cwd, "list_audit_decisions_raised", { decisions: decisions.length });
+      appendLedger(cwd, "list_audit_decisions_raised", { decisions: decisions.length });
   }
   const decideNote =
     decisions.length > 0
       ? ` ${decisions.length} DECIDE finding(s) need YOU — raising them as questions now (not queued — a decision is not a task).`
       : "";
   if (fresh.length === 0) {
-    ctx.ui.notify(
+    const afterDecision = freshCtxForGeneration(generation);
+    if (!afterDecision) return;
+    afterDecision.ui.notify(
       open.length > 0
         ? `Audit collected ${open.length} open finding(s) — all already queued.${decideNote}`
         : `Audit complete — no open findings; the project is clean, nothing to queue.${decideNote}`,
       "info",
     );
-    appendLedger(ctx.cwd, "list_audit_fanout_empty", { open: open.length, decisions: decisions.length });
+    appendLedger(cwd, "list_audit_fanout_empty", { open: open.length, decisions: decisions.length });
     return;
   }
   const preview = fresh.map((f, i) => `  ${i + 1}. ${f.text.slice(0, 110)}`).join("\n");
   let confirmed = true;
-  if (ctx.hasUI) {
+  const beforeConfirm = freshCtxForGeneration(generation);
+  if (!beforeConfirm) return;
+  if (beforeConfirm.hasUI) {
     try {
-      confirmed = await ctx.ui.confirm(`Queue ${fresh.length} audit finding(s) as list items?`, preview);
+      confirmed = await beforeConfirm.ui.confirm(`Queue ${fresh.length} audit finding(s) as list items?`, preview);
     } catch {
       confirmed = false;
     }
   }
+  // A confirm result from an old session is not consent for the replacement.
+  const afterConfirm = freshCtxForGeneration(generation);
+  if (!afterConfirm) return;
   if (!confirmed) {
-    appendLedger(ctx.cwd, "list_audit_fanout_declined", { findings: fresh.length });
-    ctx.ui.notify(`Fan-out declined — the findings stay open in ${AUDIT_FINDINGS_REL}; /list audit re-queues them any time.`, "info");
+    appendLedger(cwd, "list_audit_fanout_declined", { findings: fresh.length });
+    afterConfirm.ui.notify(`Fan-out declined — the findings stay open in ${AUDIT_FINDINGS_REL}; /list audit re-queues them any time.`, "info");
     return;
   }
-  const n = enqueueItems(ctx, fresh.map((f) => listAuditFanoutItemText(f.text)), "list audit fan-out");
-  appendLedger(ctx.cwd, "list_audit_fanout", { queued: n, alreadyQueued, decisions: decisions.length });
-  ctx.ui.notify(
+  const n = enqueueItems(afterConfirm, fresh.map((f) => listAuditFanoutItemText(f.text)), "list audit fan-out");
+  appendLedger(cwd, "list_audit_fanout", { queued: n, alreadyQueued, decisions: decisions.length });
+  afterConfirm.ui.notify(
     `Queued ${n} finding(s) — the list drains them fix by fix, each with its own audited commit.${alreadyQueued > 0 ? ` (${alreadyQueued} already queued.)` : ""}${decideNote}`,
     "info",
   );
@@ -1677,10 +1763,13 @@ function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?:
     const isListAuditCollect = goal.objective.includes(LIST_AUDIT_COLLECT_MARKER);
     // v0.34.7: the float gets a catch — ANY rejection here used to become
     // an uncaughtException and kill pi (darklord 2026-08-01).
-    if (isListAuditCollect)
-      void fanOutListAuditFindings(ctx).catch((err) => {
-        appendLedger(ctx.cwd, "list_audit_fanout_error", { error: String(err).slice(0, 200) });
+    if (isListAuditCollect) {
+      const fanoutCwd = ctx.cwd;
+      const fanoutGeneration = sessionGeneration;
+      void fanOutListAuditFindings(fanoutCwd, fanoutGeneration).catch((err) => {
+        appendLedger(fanoutCwd, "list_audit_fanout_error", { error: String(err).slice(0, 200) });
       });
+    }
     const advanced = activateNextListItem(ctx);
     // v0.26.0: the queue just EMPTIED on a completion → list-complete.
     if (!advanced && !isListAuditCollect) {
@@ -1713,11 +1802,17 @@ function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?:
  * infra) → hand back to the agent: resume active + continuation, verdict
  * durable in auditHistory.
  */
-async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-retry" | "manual" = "quota-retry"): Promise<void> {
+async function retryStoredCompletionAudit(origin: "quota-retry" | "manual" = "quota-retry"): Promise<void> {
   const goal = state.goal;
   if (!goal?.pendingCompletion) return;
+  const goalId = goal.id;
   if (completionAuditInFlight) return;
-  const liveCtx = freshCtx() ?? ctx;
+  const generation = sessionGeneration;
+  // Delayed audit recovery has no safe fallback: if the current generation
+  // cannot be proven live, the fresh session must rehydrate the durable claim.
+  const initialCtx = freshCtxForGeneration(generation);
+  if (!initialCtx) return;
+  let liveCtx: ExtensionContext = initialCtx;
   const claim = goal.pendingCompletion;
   updateGoal({ status: "auditing" }, liveCtx);
   appendLedger(liveCtx.cwd, "goal_resumed", { via: origin === "manual" ? "manual-audit" : "quota-retry-direct-audit" });
@@ -1729,6 +1824,7 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-
   if (modelError) liveCtx.ui.notify(`Auditor model issue: ${modelError}`, "warning");
   latestAuditProgress = { label: "quota-retry", lastEventAt: Date.now() };
   completionAuditInFlight = true;
+  completionAuditGeneration = generation;
   const auditStartMs = Date.now();
   let result: Awaited<ReturnType<typeof runGoalCompletionAuditor>>;
   try {
@@ -1736,23 +1832,36 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-
       () =>
         runGoalCompletionAuditor({
           ctx: liveCtx,
-          goal: state.goal!,
+          goal,
           completionSummary: claim.completionSummary,
           verificationSummary: claim.verificationSummary,
           model: auditorModel,
           thinkingLevel: (settings.auditorThinkingLevel ?? "high") as any, // may be "max" — pi ≥0.83 understands it; the dev-types predate it
           onProgress: (progress) => {
+            const current = freshCtxForGeneration(generation);
+            if (!current) return;
             latestAuditProgress = { currentTool: progress.currentTool, label: progress.label, elapsedMs: progress.elapsedMs, lastEventAt: Date.now() };
-            refreshUI(liveCtx);
+            refreshUI(current);
           },
         }),
-      { onRetry: (err) => appendLedger(liveCtx.cwd, "audit_infra_retry", { goalId: state.goal?.id, error: err.slice(0, 200) }) },
+      {
+        shouldRetry: () => freshCtxForGeneration(generation) !== null,
+        onRetry: (err) => {
+          const current = freshCtxForGeneration(generation);
+          if (current) appendLedger(current.cwd, "audit_infra_retry", { goalId, error: err.slice(0, 200) });
+        },
+      },
     ));
   } finally {
-    completionAuditInFlight = false;
-    latestAuditProgress = null;
+    if (completionAuditGeneration === generation) {
+      completionAuditInFlight = false;
+      completionAuditGeneration = null;
+      latestAuditProgress = null;
+    }
   }
-  if (!state.goal) return; // aborted mid-audit
+  const currentAfterAudit = freshCtxForGeneration(generation);
+  if (!currentAfterAudit || !state.goal || state.goal.id !== goalId) return; // replacement/stale/goal boundary — fresh session rebinds durable state
+  liveCtx = currentAfterAudit;
 
   // Record the run in history (same compact shape as the tool path).
   const auditorRan = result.output.trim().length > 0;
@@ -1809,9 +1918,9 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-
       return;
     }
     liveCtx.ui.notify(`Auditor still quota-limited — next auto-retry in ${retryMin}m (your completion claim is stored; no action needed).`, "warning");
-    scheduleQuotaRetry(liveCtx, quota.retryAfterSec, result.error, () => {
+    scheduleQuotaRetryForSession(liveCtx, quota.retryAfterSec, result.error, (fresh) => {
       if (state.goal && state.goal.status === "paused" && (state.goal.pauseReason ?? "").startsWith("auditor quota:") && state.goal.pendingCompletion) {
-        void retryStoredCompletionAudit(liveCtx, origin);
+        void retryStoredCompletionAudit(origin);
       }
     });
     return;
@@ -2111,7 +2220,7 @@ async function cmdGoal(args: string, ctx: ExtensionContext): Promise<void> {
         },
       }, ctx);
       appendLedger(ctx.cwd, "manual_audit_requested", { goalId: state.goal.id });
-      void retryStoredCompletionAudit(ctx, "manual");
+      void retryStoredCompletionAudit("manual");
       return;
     }
     if (route.name === "tweak") return cmdTweak(route.rest, ctx);
@@ -2263,8 +2372,17 @@ async function cmdResume(ctx: ExtensionContext): Promise<void> {
   // marker's promise ("a fresh session will resume you") is fulfilled by a
   // manual resume exactly as by an automatic one. (staleEntry still re-marks
   // below — a resume inside a stale session is a NEW interrupt.)
+  const storedCompletion = state.goal.pendingCompletion;
   updateGoal({ status: "active", pauseReason: undefined, pauseSuggestedAction: undefined, pauseKind: undefined, pauseOptions: undefined, pauseRecommended: undefined, pauseResumeAt: undefined, interruptedAt: undefined, interruptedReason: undefined, ...(staleEntry ? { interruptedAt: nowIso(), interruptedReason: "resumed in a stale session" } : {}), ...(usage ? { usage } : {}) }, ctx);
   if (staleEntry) return;
+  // A stored completion claim is a direct-audit resume, not an agent turn.
+  // Keeping the claim while merely scheduling a continuation left manual
+  // pause/resume with an ACTIVE goal that no timer would ever consume.
+  if (storedCompletion) {
+    ctx.ui.notify("Resuming the stored completion claim — running the isolated auditor directly (no agent turn needed).", "info");
+    void retryStoredCompletionAudit("manual");
+    return;
+  }
   // v0.22.5: say what was resumed — with a non-empty list this also resumes
   // the queue (the active goal IS the list's head item).
   // v0.22.7: name WHAT was resumed — list items resume through /list.
@@ -2910,7 +3028,7 @@ function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: strin
 }
 
 function scheduleLoopTick(ctx: ExtensionContext): void {
-  if (sessionHandoffPending || initialSessionLoadPending || !isLoopActive()) return;
+  if (sessionHandoffPending || initialSessionLoadPending || extensionApiStale || staleTerminalDone || zombieStoodDown || !isLoopActive()) return;
   rememberCtx(ctx);
   clearLoopTimer();
   let delay = 0;
@@ -2923,7 +3041,7 @@ function scheduleLoopTick(ctx: ExtensionContext): void {
 }
 
 function sendLoopTurn(): void {
-  if (sessionHandoffPending || initialSessionLoadPending) return;
+  if (sessionHandoffPending || initialSessionLoadPending || extensionApiStale || staleTerminalDone || zombieStoodDown) return;
   loopTimer = null;
   if (!isLoopActive() || !extensionApi) return;
   const ctx = freshCtx();
@@ -3043,7 +3161,20 @@ function sendLoopTurn(): void {
 }
 
 /** agent_end hook for loop 3: measure → judge → continue or stop. */
-async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
+async function runLoopTick(initialCtx: ExtensionContext, event?: any): Promise<void> {
+  // v0.34.20: measurement/git work is asynchronous. Rebind the local
+  // context after every await or abandon the tick; never let a replacement
+  // session inherit the agent_end context.
+  const generation = sessionGeneration;
+  const initial = freshCtxForGeneration(generation);
+  if (!initial) return;
+  let ctx: ExtensionContext = initial;
+  const rebind = (): boolean => {
+    const current = freshCtxForGeneration(generation);
+    if (!current) return false;
+    ctx = current;
+    return true;
+  };
   const loop = state.loop!;
   // v0.15.0: token budget is an arbitrary bound; accumulate orchestrator-side.
   if (event?.messages) {
@@ -3051,6 +3182,7 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
   }
   const metricless = !loop.measureCmd;
   const value = metricless ? null : await runMeasure(ctx, loop.measureCmd!);
+  if (!rebind()) return;
   // Hypothesis line (pi-autoresearch's good idea): the agent's stated intent
   // for the turn goes into the ledger, making loop history auditable.
   let hypothesis: string | undefined;
@@ -3075,10 +3207,12 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
   const iterStartHead = loop.iterMetrics?.iterationStartHead;
   const iterStartAt = loop.iterMetrics?.iterationStartAt;
   const currentHeadRes = await runGit(ctx, ["rev-parse", "HEAD"]);
+  if (!rebind()) return;
   const currentHead = currentHeadRes.ok ? currentHeadRes.stdout : undefined;
   let gitCommits = 0;
   if (iterStartHead && currentHead && iterStartHead !== currentHead) {
     const countRes = await runGit(ctx, ["rev-list", "--count", `${iterStartHead}..HEAD`]);
+    if (!rebind()) return;
     const n = Number.parseInt(countRes.stdout, 10);
     if (countRes.ok && Number.isFinite(n) && n > 0) gitCommits = n;
   }
@@ -3187,10 +3321,13 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
   if (loop.branchName && outcome.kind === "continue") {
     if (metricless || outcome.improved) {
       await runGit(ctx, ["add", "-A"]);
+      if (!rebind()) return;
       const committed = await runGit(ctx, ["commit", "-m", metricless ? `pi-glla-loop: iteration ${loop.iteration}` : `pi-glla-loop: iteration ${loop.iteration} (${loop.direction}=${loop.bestValue})`]);
+      if (!rebind()) return;
       appendLedger(ctx.cwd, "loop_git", { action: "commit", iteration: loop.iteration, ok: committed.ok });
     } else {
       const reset = await runGit(ctx, ["reset", "--hard", "HEAD"]);
+      if (!rebind()) return;
       appendLedger(ctx.cwd, "loop_git", { action: "reset", iteration: loop.iteration, ok: reset.ok });
     }
     persistState(ctx);
@@ -3204,6 +3341,7 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     loop.stopReason = `stuck — ${loop.lastStuckReason} (${loop.consecutiveStuck} consecutive interventions)`;
     persistState(ctx);
     await finishLoopGit(ctx, loop);
+    if (!rebind()) return;
     ctx.ui.notify(`Loop stopped: ${loop.stopReason}. ${loop.history.length} iterations recorded.`, "warning");
     appendLedger(ctx.cwd, "loop_stopped", { reason: loop.stopReason, iterations: loop.iteration, best: loop.bestValue });
     notifyExternal(ctx, `Loop stopped: ${loop.stopReason}`);
@@ -3240,6 +3378,7 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
       }
     }
     await finishLoopGit(ctx, loop);
+    if (!rebind()) return;
     ctx.ui.notify(`Loop stopped: ${outcome.reason}. ${loop.history.length} iterations recorded.`, "info");
     appendLedger(ctx.cwd, "loop_stopped", { reason: outcome.reason, iterations: loop.iteration, best: loop.bestValue });
     notifyExternal(ctx, `Loop stopped: ${outcome.reason}`);
@@ -3252,10 +3391,17 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
  * where the work lives and how to merge it. Scratch branch is never deleted. */
 async function finishLoopGit(ctx: ExtensionContext, loop: LoopState): Promise<void> {
   if (!loop.branchName) return;
+  const generation = sessionGeneration;
   // Uncommitted remnants (final stalled iterations were reset already, but be safe).
   await runGit(ctx, ["reset", "--hard", "HEAD"]);
+  const afterReset = freshCtxForGeneration(generation);
+  if (!afterReset) return;
+  ctx = afterReset;
   if (loop.originalBranch) {
     await runGit(ctx, ["checkout", loop.originalBranch]);
+    const afterCheckout = freshCtxForGeneration(generation);
+    if (!afterCheckout) return;
+    ctx = afterCheckout;
   }
   ctx.ui.notify(
     `Loop work is on branch ${loop.branchName} (${loop.iteration} iterations, best ${loop.bestValue ?? "n/a"}).\nMerge with: git merge ${loop.branchName} — or delete with: git branch -D ${loop.branchName}`,
@@ -3507,7 +3653,11 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     clearLoopTimer();
     state.loop = { ...state.loop, active: false, stopReason: state.loop.stopReason ?? `stopped by user (/loop ${sub})` };
     persistState(ctx);
+    const stopGeneration = sessionGeneration;
     await finishLoopGit(ctx, state.loop);
+    const afterFinish = freshCtxForGeneration(stopGeneration);
+    if (!afterFinish) return;
+    ctx = afterFinish;
     appendLedger(ctx.cwd, "loop_stopped", { reason: "user", iterations: state.loop.iteration, best: state.loop.bestValue });
     ctx.ui.notify(
       `Loop stopped after ${state.loop.iteration} iterations. Best: ${state.loop.bestValue ?? "n/a"}.`,
@@ -3528,7 +3678,11 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     const reason = loopFinishStopReason(rest);
     state.loop = { ...state.loop, active: false, stopReason: reason };
     persistState(ctx);
+    const finishGeneration = sessionGeneration;
     await finishLoopGit(ctx, state.loop);
+    const afterFinish = freshCtxForGeneration(finishGeneration);
+    if (!afterFinish) return;
+    ctx = afterFinish;
     appendLedger(ctx.cwd, "loop_stopped", { reason, iterations: state.loop.iteration, best: state.loop.bestValue });
     ctx.ui.notify(
       `Loop finished (${reason}) after ${state.loop.iteration} iterations. Best: ${state.loop.bestValue ?? "n/a"}.`,
@@ -3657,7 +3811,34 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
 // Tools exposed to the agent
 // =================================================================
 
-function registerAgentTools(pi: any, ctx: ExtensionContext): void {
+const STALE_TOOL_CONTEXT_MESSAGE =
+  "This tool call crossed a session replacement before it could run. No stale context was used; wait for a fresh session_start and retry.";
+
+function staleToolResult(): { content: Array<{ type: "text"; text: string }>; details: Record<string, never> } {
+  return { content: [{ type: "text", text: STALE_TOOL_CONTEXT_MESSAGE }], details: {} };
+}
+
+/**
+ * v0.34.20: registerAgentTools runs once per extension instance, but pi
+ * invokes the registered tool with the current event context. Never use the
+ * context captured when the tools were registered after a reload/rebind.
+ * Prefer the invocation context, validate it cheaply, and fall back only to
+ * the current fresh context — never to the registration-time ctx.
+ */
+function currentToolContext(execCtx: unknown): ExtensionContext | null {
+  const candidate = execCtx as ExtensionContext | undefined;
+  if (candidate) {
+    try {
+      candidate.isIdle();
+      return candidate;
+    } catch {
+      // The invocation itself may be a late event; try the current binding.
+    }
+  }
+  return freshCtx();
+}
+
+function registerAgentTools(pi: any): void {
   pi.registerTool(defineTool({
     name: "complete_goal",
     label: "Complete goal",
@@ -3670,6 +3851,10 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
     async execute(_id, params, signal, _onUpdate, execCtx) {
       const foreign0 = foreignToolGuard(execCtx);
       if (foreign0) return { content: [{ type: "text", text: foreign0 }], details: {} };
+      const toolCtx = currentToolContext(execCtx);
+      if (!toolCtx) return staleToolResult();
+      let ctx: ExtensionContext = toolCtx;
+      const auditGeneration = sessionGeneration;
       if (!state.goal || state.goal.status !== "active") {
         return { content: [{ type: "text", text: "No active goal." }], details: {} };
       }
@@ -3685,7 +3870,22 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         appendLedger(ctx.cwd, "goal_tweaked", { via: "complete_goal.newObjective", from: oldObjective.slice(0, 200), to: cleanObj.slice(0, 200) });
         ctx.ui.notify(`Objective updated (complete_goal newObjective): ${cleanObj.slice(0, 80)}`, "info");
       }
-      updateGoal({ status: "auditing", pendingTasks: undefined }, ctx);
+      // v0.34.20: persist the completion claim BEFORE the isolated auditor
+      // starts. If session replacement lands during the audit, a fresh
+      // session can recover the exact claim instead of leaving an untracked
+      // goal stuck in `auditing`.
+      updateGoal({
+        status: "auditing",
+        pendingTasks: undefined,
+        pendingCompletion: {
+          completionSummary: p.completionSummary,
+          verificationSummary: p.verificationSummary,
+          at: nowIso(),
+        },
+      }, ctx);
+      const auditGoal = state.goal;
+      if (!auditGoal) return staleToolResult();
+      const auditGoalId = auditGoal.id;
       const settings = loadSettings(ctx.cwd);
       const { model: auditorModel, error: modelError, via } = resolveAuditorModel(ctx, settings.auditorModel, settings.auditorModelFallback, settings.auditorSameSessionSwap !== false);
       if (modelError) {
@@ -3698,20 +3898,22 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const runAudit = () =>
         runGoalCompletionAuditor({
           ctx,
-          goal: state.goal!,
+          goal: auditGoal,
           completionSummary: p.completionSummary,
           verificationSummary: p.verificationSummary,
           model: auditorModel,
           thinkingLevel: (settings.auditorThinkingLevel ?? "high") as any, // may be "max" — pi ≥0.83 understands it; the dev-types predate it
           signal: signal ?? undefined,
           onProgress: (progress) => {
+            const current = freshCtxForGeneration(auditGeneration);
+            if (!current) return;
             latestAuditProgress = {
               currentTool: progress.currentTool,
               label: progress.label,
               elapsedMs: progress.elapsedMs,
               lastEventAt: Date.now(),
             };
-            refreshUI(ctx);
+            refreshUI(current);
           },
         });
       // v0.25.4 (post-audit fix): a retriable infra failure (stream error,
@@ -3720,19 +3922,33 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // (retried once)". Neither attempt is a verdict on the work.
       const auditStartMs = Date.now();
       completionAuditInFlight = true;
+      completionAuditGeneration = auditGeneration;
       let result: Awaited<ReturnType<typeof runAudit>>;
       let retriedOnce = false;
       try {
         ({ result, retriedOnce } = await runWithInfraRetry(runAudit, {
+          shouldRetry: () => freshCtxForGeneration(auditGeneration) !== null,
           onRetry: (err) => {
+            const current = freshCtxForGeneration(auditGeneration);
+            if (!current) return;
             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) });
+            refreshUI(current);
+            appendLedger(current.cwd, "audit_infra_retry", { goalId: auditGoalId, error: err.slice(0, 200) });
           },
         }));
       } finally {
-        completionAuditInFlight = false;
+        if (completionAuditGeneration === auditGeneration) {
+          completionAuditInFlight = false;
+          completionAuditGeneration = null;
+          latestAuditProgress = null;
+        }
       }
+      const auditContextAfterRun = freshCtxForGeneration(auditGeneration);
+      if (!auditContextAfterRun || !state.goal || state.goal.id !== auditGoalId) {
+        if (completionAuditGeneration === auditGeneration) latestAuditProgress = null;
+        return staleToolResult();
+      }
+      ctx = auditContextAfterRun;
       const auditDurationMs = Date.now() - auditStartMs;
       latestAuditProgress = null;
       // Audit history: record REAL verdicts only — a non-empty report is the
@@ -3801,7 +4017,10 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // Escape hatch: the user aborted the audit (Esc). Offer the explicit
       // choice — complete WITHOUT audit, or keep working. (pi-goal-x parity.)
       if (result.error === "Auditor aborted.") {
-        updateGoal({ status: "active", auditHistory: history, pauseReason: "audit aborted by user (Esc)" }, ctx);
+        updateGoal({ status: "active", auditHistory: history, pendingCompletion: undefined, pauseReason: "audit aborted by user (Esc)" }, ctx);
+        const abortConfirmCtx = freshCtxForGeneration(auditGeneration);
+        if (!abortConfirmCtx) return staleToolResult();
+        ctx = abortConfirmCtx;
         let completeAnyway = false;
         try {
           completeAnyway = await ctx.ui.confirm(
@@ -3811,8 +4030,11 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         } catch {
           completeAnyway = false;
         }
+        const afterAbortConfirmCtx = freshCtxForGeneration(auditGeneration);
+        if (!afterAbortConfirmCtx) return staleToolResult();
+        ctx = afterAbortConfirmCtx;
         if (completeAnyway) {
-          updateGoal({ auditHistory: history }, ctx);
+          updateGoal({ auditHistory: history, pendingCompletion: undefined }, ctx);
           archiveCurrentGoal(ctx, "complete", "completed without audit (user choice after Esc)");
           return { content: [{ type: "text", text: "Goal marked complete without audit (user choice)." }], details: {} };
         }
@@ -3824,7 +4046,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       }
 
       if (result.approved) {
-        updateGoal({ auditHistory: history }, ctx);
+        updateGoal({ auditHistory: history, pendingCompletion: undefined }, ctx);
         const objective = state.goal.objective;
         archiveCurrentGoal(ctx, "complete", `auditor ${result.model} approved`);
         notifyExternal(ctx, `Goal complete (auditor approved): ${objective.slice(0, 120)}`);
@@ -3846,6 +4068,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           updateGoal({
             status: "active",
             auditHistory: history,
+            pendingCompletion: undefined,
             pauseReason: `auditor verdict: IMPOSSIBLE (partial) — ${reason}`,
             pauseSuggestedAction: "Narrow the objective past the impossible part (complete_goal newObjective or /goal tweak) and continue",
           }, ctx);
@@ -3863,6 +4086,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         updateGoal({
           status: "paused",
           auditHistory: history,
+          pendingCompletion: undefined,
           pauseKind: "decision",
           pauseOptions: ["Tweak the objective — /goal tweak <new text>", "Cancel the goal (/goal cancel)"],
           pauseRecommended: 1,
@@ -3908,7 +4132,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
             pauseSuggestedAction: `Quota auto-retry in ${retryMin}m — or /goal resume to retry now`,
           }, ctx);
           appendLedger(ctx.cwd, "goal_paused", { reason: `auditor quota: retry in ${quota.retryAfterSec}s (${quota.fromUpstream ? "upstream hint" : "default"})` });
-          scheduleQuotaRetry(ctx, quota.retryAfterSec, result.error, () => {
+          scheduleQuotaRetryForSession(ctx, quota.retryAfterSec, result.error, (fresh) => {
             // Re-check: only auto-resume if STILL paused for the quota
             // reason (a user /goal pause during the window is not stomped).
             if (state.goal && state.goal.status === "paused" && (state.goal.pauseReason ?? "").startsWith("auditor quota:")) {
@@ -3916,15 +4140,15 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
               // agent is not needed to re-submit an unchanged claim, and
               // re-engaging it produced hallucinated-closure loops.
               if (state.goal.pendingCompletion) {
-                void retryStoredCompletionAudit(ctx);
+                void retryStoredCompletionAudit();
                 return;
               }
-              updateGoal({ status: "active" }, ctx);
-              appendLedger(ctx.cwd, "goal_resumed", { via: "quota-retry" });
-              if (resolveEffectiveAggressiveSettings(loadSettings(ctx.cwd)).aggressiveMode) {
-                ctx.ui.notify("Auto-resume fired (event: auditor quota window elapsed). Continue working.", "info");
+              updateGoal({ status: "active" }, fresh);
+              appendLedger(fresh.cwd, "goal_resumed", { via: "quota-retry" });
+              if (resolveEffectiveAggressiveSettings(loadSettings(fresh.cwd)).aggressiveMode) {
+                fresh.ui.notify("Auto-resume fired (event: auditor quota window elapsed). Continue working.", "info");
               }
-              scheduleContinuation(ctx, true);
+              scheduleContinuation(fresh, true);
             }
           });
           return {
@@ -3944,6 +4168,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           updateGoal({
             status: "paused",
             auditHistory: history,
+            pendingCompletion: undefined,
             auditInfraStreak: infraStreak,
             pauseKind: "error",
             pauseReason: `auditor infrastructure failed ${infraStreak}× in a row — the auditor model is likely broken OR a verification command is hanging (ssh/sudo/long test runs stall the stream) (last: ${result.error.slice(0, 120)})`,
@@ -3963,6 +4188,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         updateGoal({
           status: "active",
           auditHistory: history,
+          pendingCompletion: undefined,
           auditInfraStreak: infraStreak,
           pauseReason: `auditor infrastructure${retriedOnce ? " (retried once)" : ""}: ${result.error}`,
           pauseSuggestedAction: "Fix the auditor model (/glla model=provider/id) and call complete_goal again — your work was NOT judged",
@@ -3987,6 +4213,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         updateGoal({
           status: "active",
           auditHistory: history,
+          pendingCompletion: undefined,
           pauseReason: `regression shield: auditor approved, but evidence never referenced ${missing.length} contract item(s)`,
           pauseSuggestedAction: "call complete_goal again — the next auditor run is told exactly which items to quote evidence for",
         }, ctx);
@@ -4032,6 +4259,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           updateGoal({
             status: "active",
             auditHistory: history,
+            pendingCompletion: undefined,
             pendingTasks,
             pauseReason: `auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap}) — aggressiveMode: continuing with TODOs`,
           }, ctx);
@@ -4052,6 +4280,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         updateGoal({
           status: "paused",
           auditHistory: history,
+          pendingCompletion: undefined,
           pauseKind: "decision",
           pauseOptions: ["Fix the disapproval gap, then continue (/goal resume)", "Tweak the objective — /goal tweak <new text>", "Cancel the goal (/goal cancel)"],
           pauseRecommended: 1,
@@ -4073,6 +4302,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       updateGoal({
         status: "active",
         auditHistory: history,
+        pendingCompletion: undefined,
         pauseReason: "auditor disapproved",
         pauseSuggestedAction: "Inspect auditor feedback and fix the actual gap before calling complete_goal again",
       }, ctx);
@@ -4102,6 +4332,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
     async execute(_id, params, _signal, _onUpdate, execCtx) {
       const foreign1 = foreignToolGuard(execCtx);
       if (foreign1) return { content: [{ type: "text", text: foreign1 }], details: {} };
+      const ctx = currentToolContext(execCtx);
+      if (!ctx) return staleToolResult();
       const p = params as { reason: string; suggestedAction?: string; kind?: "decision" | "error" | "wait" | "blocked"; options?: string[]; recommended?: number; resumeAt?: string };
       if (!state.goal) return { content: [{ type: "text", text: "No active goal." }], details: {} };
       updateGoal({
@@ -4133,6 +4365,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
     async execute(_id, params, _signal, _onUpdate, execCtx) {
       const foreign7 = foreignToolGuard(execCtx);
       if (foreign7) return { content: [{ type: "text", text: foreign7 }], details: {} };
+      const ctx = currentToolContext(execCtx);
+      if (!ctx) return staleToolResult();
       const p = params as { id: string };
       if (!state.goal || !state.goal.taskList) {
         return { content: [{ type: "text", text: "No task list in this goal." }], details: {} };
@@ -4163,6 +4397,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
     async execute(_id, params, _signal, _onUpdate, execCtx) {
       const foreign8 = foreignToolGuard(execCtx);
       if (foreign8) return { content: [{ type: "text", text: foreign8 }], details: {} };
+      const ctx = currentToolContext(execCtx);
+      if (!ctx) return staleToolResult();
       const p = params as { id: string; status: "pending" | "in_progress" | "complete" };
       if (!state.goal || !state.goal.taskList) {
         return { content: [{ type: "text", text: "No task list in this goal." }], details: {} };
@@ -4195,13 +4431,14 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const foreign2 = foreignToolGuard(execCtx);
       if (foreign2) return { content: [{ type: "text", text: foreign2 }], details: {} };
       const p = params as { objective: string; verificationContract?: string; items?: string[] };
+      const liveCtx = currentToolContext(execCtx);
+      if (!liveCtx) return staleToolResult();
       if (draftingTarget !== "goal" && draftingTarget !== "list") {
         return {
           content: [{ type: "text", text: "Not in goal drafting mode. The user starts drafting with /goal or /list add (no args), or activates directly with /goal <objective>." }],
           details: {},
         };
       }
-      const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       // v0.28.14: one-active-thing EARLY guard — refuse the whole interview
       // when a loop is live (the post-confirm backstop below stays: state
       // can change mid-interview).
@@ -4383,6 +4620,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const foreign3 = foreignToolGuard(execCtx);
       if (foreign3) return { content: [{ type: "text", text: foreign3 }], details: {} };
       const p = params as { target: string; measureCmd?: string; direction?: "min" | "max"; window?: number; max?: number; time?: number; tokens?: number; branch?: boolean };
+      const liveCtx = currentToolContext(execCtx);
+      if (!liveCtx) return staleToolResult();
       if (draftingTarget !== "loop") {
         return {
           content: [{ type: "text", text: "You cannot start or draft a loop — only the user can, from the slash bar (the Confirm is the product). Do NOT write draft files or wait for the user to say 'start' in chat; that dead-ends. Instead hand the user the exact command: /loop start \"<target>\" (bare = infinite metricless; add measure=\"<cmd>\" direction=min|max for a metric loop), or /loop respec to reconcile against the root spec, or /loop with no args to draft interactively." }],
@@ -4408,7 +4647,6 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       if (!metricless && p.direction !== "min" && p.direction !== "max") {
         return { content: [{ type: "text", text: 'direction=min|max is required for a measured loop (omit measureCmd or pass "none" for a metricless spec loop).' }], details: {} };
       }
-      const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       // v0.28.14: one-active-thing — refuse to even test-run a loop measure
       // while a goal/list-item is active (the /loop start COMMAND guards
       // this; the tool path used to skip it and stack a loop over a goal).
@@ -4506,7 +4744,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const foreign4 = foreignToolGuard(execCtx);
       if (foreign4) return { content: [{ type: "text", text: foreign4 }], details: {} };
       const p = params as { target?: string; measureCmd?: string; specText?: string; specAppend?: string; rationale: string };
-      const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
+      const liveCtx = currentToolContext(execCtx);
+      if (!liveCtx) return staleToolResult();
       const loop = state.loop;
       if (!loop?.active) {
         return { content: [{ type: "text", text: "No active loop to refine. propose_loop_refine is only valid while a loop is running." }], details: {} };
@@ -4602,6 +4841,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const foreign5 = foreignToolGuard(execCtx);
       if (foreign5) return { content: [{ type: "text", text: foreign5 }], details: {} };
       const p = params as { items: string[] };
+      const liveCtx = currentToolContext(execCtx);
+      if (!liveCtx) return staleToolResult();
       if (listMutationBlocked(draftingTarget)) {
         return { content: [{ type: "text", text: LIST_DRAFTING_BLOCK_MESSAGE }], details: {} };
       }
@@ -4609,7 +4850,6 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         return { content: [{ type: "text", text: "No items given." }], details: {} };
       }
       const clean = p.items.map((t) => t.trim()).filter((t) => t.length > 0);
-      const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       const wasIdle = !state.goal || state.goal.status === "complete" || state.goal.status === "aborted";
       const n = enqueueItems(liveCtx, clean, "agent list_add");
       return {
@@ -4635,6 +4875,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const foreign6 = foreignToolGuard(execCtx);
       if (foreign6) return { content: [{ type: "text", text: foreign6 }], details: {} };
       const p = params as { n: number };
+      const liveCtx = currentToolContext(execCtx);
+      if (!liveCtx) return staleToolResult();
       if (listMutationBlocked(draftingTarget)) {
         return { content: [{ type: "text", text: LIST_DRAFTING_BLOCK_MESSAGE }], details: {} };
       }
@@ -4642,7 +4884,6 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       if (!Number.isInteger(n) || n < 1) {
         return { content: [{ type: "text", text: "n must be a positive integer (1-based position)." }], details: {} };
       }
-      const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       // v0.28.14: one-active-thing — a list item must not jump a live loop.
       if (isLoopActive()) {
         return { content: [{ type: "text", text: "A loop is active — one active thing at a time. The user must /loop stop it before a list item can activate." }], details: {} };
@@ -4704,11 +4945,12 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         return { content: [{ type: "text", text: "A task list already exists. Use update_task_status / complete_task to work it." }], details: {} };
       }
       const p = params as { tasks: TaskProposal[] };
+      const liveCtx = currentToolContext(execCtx);
+      if (!liveCtx) return staleToolResult();
       const invalid = validateTaskProposal(p.tasks);
       if (invalid) {
         return { content: [{ type: "text", text: invalid }], details: {} };
       }
-      const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       const preview = p.tasks.map((t, i) => {
         const subs = (t.subtasks ?? []).map((s, j) => `   ${i + 1}.${j + 1} ${s}`).join("\n");
         return `${i + 1}. ${t.title}` + (subs ? `\n${subs}` : "");
@@ -5508,7 +5750,11 @@ async function cmdGllaWipe(ctx: ExtensionContext): Promise<void> {
   if (loop) {
     clearLoopTimer();
     state.loop = undefined;
+    const wipeGeneration = sessionGeneration;
     await finishLoopGit(ctx, loop);
+    const afterFinish = freshCtxForGeneration(wipeGeneration);
+    if (!afterFinish) return;
+    ctx = afterFinish;
     appendLedger(ctx.cwd, "loop_stopped", { reason: "user wipe (/glla wipe)", iterations: loop.iteration, best: loop.bestValue });
   }
   persistState(ctx);
@@ -6182,7 +6428,9 @@ export default function (pi: ExtensionAPI): void {
   // Tool registration is lazy: done on the first session event, when a
   // context exists. Tools show even without an active goal (and return
   // "no active goal" if called).
-  let registeredCtx: ExtensionContext | null = null;
+  // Tool definitions are re-registered at lifecycle boundaries; the current
+  // invocation context is resolved inside each execute handler.
+  let toolsRegistered = false;
 
   // v0.24.5 tool-visibility self-heal: surface the notify exactly once
   // per session so the user learns about an external allowlist once and
@@ -6234,6 +6482,9 @@ export default function (pi: ExtensionAPI): void {
   // 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;
+    // A late compact event can arrive after pi has already invalidated this
+    // extension. It must not reclaim the old ctx or schedule settle refires.
+    if (sessionHandoffPending || extensionApiStale || staleTerminalDone || zombieStoodDown) return;
     rememberCtx(ctx);
     if (!isSupervising()) return;
     appendLedger(ctx.cwd, "session_compact", {});
@@ -6298,7 +6549,8 @@ export default function (pi: ExtensionAPI): void {
 
   // v0.15.1: ask_user_question answers arrive as tool results, not chat
   // messages — count answered (non-cancelled) questionnaires as replies too.
-  pi.on("tool_result", async (event: any) => {
+  pi.on("tool_result", async (event: any, eventCtx: ExtensionContext) => {
+    if (sessionHandoffPending || extensionApiStale || staleTerminalDone || zombieStoodDown) return;
     noteToolResult(event); // v0.33.0: slim widget "last action" feed
     // v0.24.0: roll loop tool-result fingerprints (same-tool-same-result
     // detection) — recorded for ANY tool result while a loop is active.
@@ -6335,11 +6587,14 @@ export default function (pi: ExtensionAPI): void {
     // HIT QUOTA ERRORS section carries the full guidance.
     if (isSubagentQuotaResult(String(event?.toolName ?? ""), Boolean(event?.isError ?? event?.error), event?.output ?? event?.result ?? event?.details ?? "")) {
       const errText = typeof (event?.output ?? event?.result) === "string" ? (event?.output ?? event?.result) : JSON.stringify(event?.output ?? event?.result ?? event?.details ?? "");
-      appendLedger(registeredCtx?.cwd ?? process.cwd(), "subagent_quota_error", { error: String(errText).slice(0, 200) });
-      registeredCtx?.ui.notify(
-        "Subagent hit a quota error (403/limit). Repair: re-spawn with an explicit model= on your quota pool, or do the work inline — see the continuation prompt's WHEN SUBAGENTS HIT QUOTA ERRORS. Explore's upstream haiku pin is the usual cause (pi-subagents#175); glla's inherit-parent strategy removes it for NEW sessions.",
-        "warning",
-      );
+      const current = currentToolContext(eventCtx);
+      if (current) {
+        appendLedger(current.cwd, "subagent_quota_error", { error: String(errText).slice(0, 200) });
+        current.ui.notify(
+          "Subagent hit a quota error (403/limit). Repair: re-spawn with an explicit model= on your quota pool, or do the work inline — see the continuation prompt's WHEN SUBAGENTS HIT QUOTA ERRORS. Explore's upstream haiku pin is the usual cause (pi-subagents#175); glla's inherit-parent strategy removes it for NEW sessions.",
+          "warning",
+        );
+      }
     }
     if (draftingTarget === null) return;
     if (askUserQuestionAnswered(String(event?.toolName ?? ""), event?.details)) {
@@ -6360,7 +6615,7 @@ export default function (pi: ExtensionAPI): void {
     writeSessionHandoff(ctx, shutdownReason);
     sessionReplacementUntil = Date.now() + SESSION_REBIND_GRACE_MS;
     clearSessionOwnedTimers();
-    registeredCtx = null;
+    toolsRegistered = false;
     toolHealNotified = false;
   });
 
@@ -6371,6 +6626,21 @@ export default function (pi: ExtensionAPI): void {
     if (isForeignCtx(ctx)) return;
     extensionApi = pi;
     sessionHandoffPending = false;
+    // Reset terminal ownership before rememberCtx: this is the only event
+    // allowed to bind a context after a stale/shutdown handoff.
+    staleTerminalDone = false; // v0.33.1: a rebound session can go terminal again
+    zombieStoodDown = false;
+    sessionGeneration++;
+    // An auditor belonging to the disposed generation cannot block the fresh
+    // session's recovery gate; its finally block is generation-guarded too.
+    completionAuditInFlight = false;
+    completionAuditGeneration = null;
+    latestAuditProgress = null;
+    // Ephemeral watchdog counters belong to the old session, not the
+    // persisted goal. Reset them so a stale boundary cannot make the next
+    // fresh session inherit a false stall count.
+    heartbeatNudges = 0;
+    consecutiveStalls = 0;
     const startReason = typeof event?.reason === "string" ? event.reason : "unknown";
     initialSessionLoadPending = isBlankInitialStartup(ctx, startReason);
     rememberCtx(ctx);
@@ -6384,8 +6654,6 @@ export default function (pi: ExtensionAPI): void {
     // confirm the new handle actually works.
     writeOwnerFile(ctx.cwd);
     sessionReplacementUntil = 0;
-    zombieStoodDown = false;
-    staleTerminalDone = false; // v0.33.1: a rebound session must be able to go terminal AGAIN (was: one-shot for the process lifetime)
     postCompactResumeOwed = false; // v0.33.1: a compact from a previous session must not resync THIS one
     postCompactResyncPending = false;
     appendLedger(ctx.cwd, "session_rebound", { reason: startReason });
@@ -6409,9 +6677,9 @@ export default function (pi: ExtensionAPI): void {
       heldLoop: state.loop && (state.loop.active || state.loop.stopReason === HELD_ON_RESTORE) ? state.loop.target.slice(0, 60) : undefined,
     };
     carryoverResolved = !(carryoverSnapshot.pausedGoal || carryoverSnapshot.listCount > 0 || carryoverSnapshot.heldLoop);
-    if (!registeredCtx) {
-      registerAgentTools(pi, ctx);
-      registeredCtx = ctx;
+    if (!toolsRegistered) {
+      registerAgentTools(pi);
+      toolsRegistered = true;
     }
     ensureAgentToolsActive(pi, ctx);
     warnOnCommandCollision(ctx);
@@ -6605,6 +6873,10 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("agent_end", async (event: any, ctx: ExtensionContext) => {
+    // A late agent_end from the disposed session is not a fresh turn. Do not
+    // account it, run length continuation, or schedule another send after a
+    // stale terminal/handoff.
+    if (sessionHandoffPending || extensionApiStale || staleTerminalDone || zombieStoodDown) return;
     rememberCtx(ctx);
     // v0.23.8: a subagent finishing must not drive the main session's
     // continuation loop.
@@ -6625,7 +6897,30 @@ export default function (pi: ExtensionAPI): void {
     const rawPriorA = assistants.length >= 2 ? assistants[assistants.length - 2] : null;
     const extractText = (m: any): string => (m && Array.isArray(m.content)) ? m.content.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n") : "";
     const lastA = rawLastA ? { stopReason: rawLastA.stopReason, text: extractText(rawLastA), priorText: extractText(rawPriorA) } : null;
-    const lc = tickLengthContinue(lastA?.stopReason === "length");
+    // v0.34.19: pi-ai clamps max_tokens to the remaining context before the
+    // provider call. At ~99% context that clamp can be 1 token, which the
+    // provider reports as stopReason "length" — but this is NOT an overlong
+    // assistant response. Extension agent_end runs BEFORE pi's own
+    // auto-compaction check (agent-session.js _handlePostAgentRun), so sending
+    // LENGTH_CONTINUE_TEXT here queues another 1-token request and delays the
+    // real cure. Defer to pi compaction; session_compact's resume debt owns
+    // the next continuation. Older pi/test doubles without getContextUsage()
+    // fail open to the legacy true-length path.
+    const contextUsage = (() => {
+      try { return typeof ctx.getContextUsage === "function" ? ctx.getContextUsage() : undefined; } catch { return undefined; }
+    })();
+    const contextStarvedLength = isContextStarvedLengthStop(rawLastA, contextUsage);
+    const lc = tickLengthContinue(lastA?.stopReason === "length" && !contextStarvedLength);
+    if (contextStarvedLength) {
+      appendLedger(ctx.cwd, "length_continue_deferred_context_full", {
+        outputTokens: rawLastA?.usage?.output,
+        contextTokens: contextUsage?.tokens ?? null,
+        contextWindow: contextUsage?.contextWindow ?? null,
+        contextPercent: contextUsage?.percent ?? null,
+      });
+      ctx.ui.notify("glla: output-token stop was context starvation (tiny output at a nearly full context) — yielding to pi auto-compaction instead of re-sending.", "info");
+      return;
+    }
     if (lc.giveUpNow) {
       ctx.ui.notify(`glla: response hit the output-token cap ${LENGTH_CONTINUE_MAX}× in a row — stepping aside. Ask the model to split the work into smaller pieces.`, "warning");
       notifyExternal(ctx, "Response truncated 3× in a row — giving up auto-continue.");
@@ -6640,9 +6935,9 @@ export default function (pi: ExtensionAPI): void {
       t.turns++;
       state.goal.telemetry = t;
     }
-    if (!registeredCtx) {
-      registerAgentTools(pi, ctx);
-      registeredCtx = ctx;
+    if (!toolsRegistered) {
+      registerAgentTools(pi);
+      toolsRegistered = true;
     }
     ensureAgentToolsActive(pi, ctx);
     // v0.27.3: nudge accounting — substantive analytical turns (long, novel
@@ -6830,16 +7125,16 @@ export default function (pi: ExtensionAPI): void {
           notifyExternal(ctx, `${goalNoun()} parked: provider erroring across 6 error-brake cycles — hourly top-of-hour probes scheduled.`);
           appendLedger(ctx.cwd, "error_brake_capped", { streak: brakeStreak, reason });
           const probeMs = msUntilNextHourBoundary(Date.now());
-          scheduleQuotaRetry(ctx, probeMs / 1000, reason, () => {
+          scheduleQuotaRetryForSession(ctx, probeMs / 1000, reason, (fresh) => {
             // Re-check: only probe if STILL parked by the error-brake cap —
             // a user pause/resume/cancel meanwhile is never stomped.
             if (state.goal && state.goal.status === "paused" && state.goal.pauseKind === "error"
               && (state.goal.pauseReason ?? "").includes("error-brakes in a row")) {
-              appendLedger(ctx.cwd, "hourly_rate_probe", { goalId: state.goal.id, streak: state.goal.errorBrakeStreak ?? 0 });
-              updateGoal({ status: "active" }, ctx);
-              appendLedger(ctx.cwd, "goal_resumed", { via: "hourly-rate-probe" });
-              ctx.ui.notify("Hourly probe: resuming (rate-limit windows typically expire at the top of the hour).", "info");
-              scheduleContinuation(ctx, true);
+              appendLedger(fresh.cwd, "hourly_rate_probe", { goalId: state.goal.id, streak: state.goal.errorBrakeStreak ?? 0 });
+              updateGoal({ status: "active" }, fresh);
+              appendLedger(fresh.cwd, "goal_resumed", { via: "hourly-rate-probe" });
+              fresh.ui.notify("Hourly probe: resuming (rate-limit windows typically expire at the top of the hour).", "info");
+              scheduleContinuation(fresh, true);
             }
           }, "Hourly rate-limit probe");
           return;
@@ -6861,14 +7156,14 @@ export default function (pi: ExtensionAPI): void {
         ctx.ui.notify(`Goal paused: ${reason}.${quotaWall ? " Quota/rate-limit wall — resuming won't help until the window resets; switch /model to continue now." : ""}`, "warning");
         notifyExternal(ctx, `Goal paused: ${reason}.`);
         appendLedger(ctx.cwd, "goal_paused", { reason });
-        scheduleQuotaRetry(ctx, cooldownMs / 1000, reason, () => {
+        scheduleQuotaRetryForSession(ctx, cooldownMs / 1000, reason, (fresh) => {
           // Re-check: only auto-resume if STILL paused for the error brake
           // (a user /goal pause during the window is not stomped).
           if (state.goal && state.goal.status === "paused" && (state.goal.pauseReason ?? "").startsWith("5 consecutive errors")) {
-            updateGoal({ status: "active" }, ctx);
-            appendLedger(ctx.cwd, "goal_resumed", { via: "error-brake-retry" });
-            ctx.ui.notify("Auto-resumed after the 5-error brake (cooldown elapsed).", "info");
-            scheduleContinuation(ctx, true);
+            updateGoal({ status: "active" }, fresh);
+            appendLedger(fresh.cwd, "goal_resumed", { via: "error-brake-retry" });
+            fresh.ui.notify("Auto-resumed after the 5-error brake (cooldown elapsed).", "info");
+            scheduleContinuation(fresh, true);
           }
         }, "5 consecutive errors — auto-retry");
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.34.18",
+  "version": "0.34.20",
   "description": "Mission control for autonomous pi: interview-drafted goals, an audited task queue, and forever-loops (metric, spec, project-audit) that run for hours. An isolated extension-less auditor re-verifies every completion with raw evidence; confirmed drafts, decision pauses and consent gates keep you in charge.",
   "license": "MIT",
   "author": "dracon",