pi-goal-list-loop-audit 0.32.1 → 0.33.1

package/extensions/goal-loop-auditor.ts

@@ -338,6 +338,7 @@ export async function runGoalCompletionAuditor(args: {
     } finally {
       clearInterval(stallTimer);
       unsub();
+      args.signal?.removeEventListener("abort", abort); // v0.33.1: don't retain the session via the signal
       // v0.32.0: dispose the auditor session — each complete_goal leaked one
       // session's subscriptions/stream resources for the parent's lifetime.
       (session as any).dispose?.();

package/extensions/goal-loop-display.ts

@@ -48,6 +48,37 @@ export function truncate(s: string, max: number): string {
   return s.length <= max ? s : s.slice(0, Math.max(0, max - 1)) + "…";
 }
 
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+/** v0.33.1: painted strings measure by their VISIBLE width. */
+function visibleLen(s: string): number {
+  return s.replace(ANSI_RE, "").length;
+}
+
+/** v0.33.0: 5-cell meter with a rounding guard (command-code's rule — never
+ * shows empty or full unless the value truly is 0 or 1). */
+export function meter(frac: number, cells = 5): string {
+  if (!Number.isFinite(frac) || frac <= 0) return "▱".repeat(cells);
+  if (frac >= 1) return "▰".repeat(cells);
+  let filled = Math.round(frac * cells);
+  if (filled === 0) filled = 1;
+  if (filled === cells) filled = cells - 1;
+  return "▰".repeat(filled) + "▱".repeat(cells - filled);
+}
+
+/** v0.33.0: one finished tool call, for the slim card's "last action" line. */
+export interface RecentActionDisplay {
+  name: string;
+  arg?: string;
+  ms: number;
+  ok: boolean;
+}
+
+/** v0.33.0: widget extras — the refire streak plus the recent-action feed. */
+export interface WidgetExtras {
+  stalls?: number;
+  recent?: RecentActionDisplay[];
+}
+
 /**
  * Word-wrap to `width`, capped at `maxLines` (v0.27.1). A pause is the one
  * state where the FULL text matters — the reason often carries a decision
@@ -134,7 +165,7 @@ export interface AuditDisplayProgress {
  * One-line status for ctx.ui.setStatus("pi-glla", …).
  * Returns undefined when nothing is being supervised (clears the segment).
  */
-export function buildStatusText(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, extras?: { stalls?: number }): string | undefined {
+export function buildStatusText(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, extras?: WidgetExtras): string | undefined {
   if (state.loop?.active) {
     const l = state.loop;
     // v0.26.1: surface the refire streak — a spinning supervisor is the
@@ -223,7 +254,7 @@ function countTotal(g: Goal): number {
  * Widget lines for ctx.ui.setWidget("pi-glla", lines).
  * Returns undefined when nothing is worth showing.
  */
-export function buildWidgetLines(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, width?: number, extras?: { stalls?: number }): string[] | undefined {
+export function buildWidgetLines(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, width?: number, extras?: WidgetExtras): string[] | undefined {
   const inner = buildWidgetLinesInner(state, audit, now, theme, width, extras);
   // v0.28.6 (E1): a persistence failure outranks everything — first line,
   // on every render, until a write lands again.
@@ -234,7 +265,7 @@ export function buildWidgetLines(state: State, audit?: AuditDisplayProgress | nu
   return inner;
 }
 
-function buildWidgetLinesInner(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, width?: number, extras?: { stalls?: number }): string[] | undefined {
+function buildWidgetLinesInner(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, width?: number, extras?: WidgetExtras): string[] | undefined {
   if (state.loop?.active) return loopLines(state.loop, now, theme, width, extras);
   const g = state.goal;
   const held = heldLoop(state);
@@ -242,7 +273,7 @@ function buildWidgetLinesInner(state: State, audit?: AuditDisplayProgress | null
     // v0.28.17: no visible goal — the held loop gets its own card.
     return held ? heldLoopLines(held, now, theme, width) : undefined;
   }
-  const lines = goalLines(g, state, audit, now, theme, width);
+  const lines = goalLines(g, state, audit, now, theme, width, extras);
   // v0.28.17: a held loop rides the goal card as a trailing line.
   if (held) {
     lines.push(`${paint(theme, "warning", "⏸")} ${truncate(held.target, budgetFor(width, 3, 64))}`);
@@ -262,7 +293,7 @@ function heldLoopLines(l: LoopState, now: number, theme?: DisplayTheme, width?:
 
 // Branch lines sit flush-left (pi-tasks convention): pi's widget renderer
 // adds its own one-space gutter, so any indent here doubles up.
-function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | undefined, now: number, theme?: DisplayTheme, width?: number): string[] {
+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 icon =
@@ -271,22 +302,41 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
       : g.status === "auditing"
         ? paint(theme, "accent", "⟡")
         : paint(theme, "success", "●");
-  const head = `${icon} ${truncate(g.objective.replace(/\s+/g, " "), budgetFor(width, 3, 64))}`;
   // 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;
-  // 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 · ";
+  // 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.
+  // v0.28.30: the type stays visible — v0.33.0 names it via the "list item"
+  // header segment (list policy) and the distinct card icons (● goal,
+  // ∞/↓/↑ loop, ⟡ auditing, ⏸ paused) + the type-named footer verbs.
   // 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, `├─ ${typeWord}${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))}${tokens}`];
+  const headSegs: string[] = [];
+  if (isList) headSegs.push("list item");
+  headSegs.push(statusWord);
+  headSegs.push(fmtElapsed(now - Date.parse(g.createdAt)));
+  const taskTotal = countTotal(g);
+  if (taskTotal > 0) headSegs.push(`${countDone(g)}/${taskTotal} ${paint(theme, "dim", meter(countDone(g) / taskTotal))}`);
+  const tokUsed0 = g.usage?.tokensUsed ?? 0;
+  if (tokenLimit > 0) headSegs.push(paint(theme, "dim", `${fmtTokens(tokUsed0)}/${fmtTokens(tokenLimit)} ${meter(tokUsed0 / tokenLimit)}`));
+  else if (tokUsed0 > 0) headSegs.push(paint(theme, "dim", `${fmtTokens(tokUsed0)} tok`));
+  // v0.28.30: the type stays visible — v0.33.0 names it via the "list item"
+  // header segment (list policy) and the distinct card icons (● goal,
+  // ∞/↓/↑ loop, ⟡ auditing, ⏸ paused) + the type-named footer verbs.
+  // 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.
+  // v0.33.1: the head must FIT the terminal — the segments are fixed, so
+  // the objective absorbs whatever room is left (was: objective budgeted
+  // alone, segments appended unbudgeted → 140-col heads at width 100).
+  const segsText = headSegs.join(` ${paint(theme, "dim", "·")} `);
+  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 (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
@@ -357,8 +407,16 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
     }
     return lines;
   }
+  // v0.33.0: "last action · next task" — Claude's done-row format meets the
+  // pending queue. Segments join with a dim middot; missing ones drop out.
+  const act = extras?.recent?.[extras.recent.length - 1];
+  const mid: string[] = [];
+  if (act) {
+    mid.push(`${paint(theme, act.ok ? "success" : "error", act.ok ? "✓" : "✗")} ${act.name}${act.arg ? ` ${paint(theme, "dim", truncate(act.arg, 24))}` : ""}${act.ms > 0 ? ` ${paint(theme, "dim", `(${fmtElapsed(act.ms)})`)}` : ""}`);
+  }
   const next = nextPending(g);
-  if (next) lines.push(`├─ next: ${truncate(next, budgetFor(width, 9, 56))}`);
+  if (next) mid.push(`next: ${truncate(next, budgetFor(width, 9, 40))}`);
+  if (mid.length > 0) lines.push(`├─ ${mid.join(` ${paint(theme, "dim", "·")} `)}`);
   const queue = state.list?.length ?? 0;
   const footer = isList
     ? `${queue > 0 ? `${queue} queued · ` : ""}/list · /glla`
@@ -367,34 +425,33 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   return lines;
 }
 
-function loopLines(l: LoopState, now: number, theme?: DisplayTheme, width?: number, extras?: { stalls?: number }): string[] {
-  // v0.26.1: the refire streak, shown only while nonzero.
-  const stallNote = (extras?.stalls ?? 0) > 0 ? ` · ${paint(theme, "warning", `stalls:${extras!.stalls}`)}` : "";
-  // v0.23.0: metricless spec loop — no arrow/best/stall, no plateau.
-  if (!l.measureCmd) {
-    const lines = [
-      `${paint(theme, "accent", "●")} ${truncate(l.target, budgetFor(width, 3, 64))}`,
-      `├─ loop ∞ iter ${l.iteration}${l.maxIterations > 0 ? `/${l.maxIterations}` : ""} · ${fmtElapsed(now - Date.parse(l.startedAt))}${stallNote}`,
-      `└─ ${paint(theme, "dim", "metricless — work the spec (no plateau)")}`,
-    ];
-    if (l.branchName) lines.push(`⎇ ${paint(theme, "muted", truncate(l.branchName, budgetFor(width, 3, 50)))}`);
-    return lines;
+function loopLines(l: LoopState, now: number, theme?: DisplayTheme, width?: number, extras?: WidgetExtras): string[] {
+  // v0.33.0: slim loop card — header icon names the kind (∞ metricless,
+  // ↓/↑ metric), all state folds into middot segments; line 2 is the live
+  // "last action" line; footer is hints. The old per-line "loop ∞ iter" /
+  // "best/last/stall" rows collapse into the header.
+  const stallNote = (extras?.stalls ?? 0) > 0 ? ` ${paint(theme, "dim", "·")} ${paint(theme, "warning", `stalls:${extras!.stalls}`)}` : "";
+  const icon = !l.measureCmd ? paint(theme, "accent", "∞") : paint(theme, "accent", l.direction === "min" ? "↓" : "↑");
+  const segs: string[] = [];
+  segs.push(`iter ${l.iteration}${l.maxIterations > 0 ? `/${l.maxIterations} ${paint(theme, "dim", meter(l.iteration / l.maxIterations))}` : ""}`);
+  segs.push(fmtElapsed(now - Date.parse(l.startedAt)));
+  if (l.measureCmd) {
+    segs.push(`best ${paint(theme, "success", `${l.bestValue ?? "n/a"}`)}`);
+    segs.push(`last ${l.lastValue ?? "n/a"}`); // v0.33.1: a plateauing loop's current reading stays visible
+    const stallText = `stall ${l.stallCount}/${l.plateauWindow}`;
+    segs.push(l.stallCount >= l.plateauWindow - 1 ? paint(theme, "warning", stallText) : stallText);
   }
-  const arrow = paint(theme, "accent", l.direction === "min" ? "↓" : "↑");
-  const best = paint(theme, "success", `${l.bestValue ?? "n/a"}`);
-  const stallText = `stall ${l.stallCount}/${l.plateauWindow}`;
-  const stall = l.stallCount >= l.plateauWindow - 1 ? paint(theme, "warning", stallText) : stallText;
-  const lines = [
-    `${paint(theme, "accent", "●")} ${truncate(l.target, budgetFor(width, 3, 64))}`,
-    `├─ loop ${arrow} iter ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"} · ${fmtElapsed(now - Date.parse(l.startedAt))}`,
-    `├─ best ${best} · last ${l.lastValue ?? "n/a"} · ${stall}`,
-    // v0.29.15: the audit loop's measure is orchestrator-owned shell — the
-    // raw grep reads like leaked internals ("that weird line"). Name what
-    // it measures instead; user-authored measures still show raw.
-    `└─ ${paint(theme, "dim", l.kind === "audit"
-      ? "metric: closed findings ('- [x]' count)"
-      : truncate(l.measureCmd, budgetFor(width, 3, 56)))}`,
-  ];
+  const segsText = segs.join(` ${paint(theme, "dim", "·")} `);
+  const targetBudget = width && width > 0 ? Math.max(16, width - 1 - 2 - 3 - visibleLen(segsText) - visibleLen(stallNote)) : 44;
+  const lines = [`${icon} ${truncate(l.target, targetBudget)} ${paint(theme, "dim", "·")} ${segsText}${stallNote}`];
+  const act = extras?.recent?.[extras.recent.length - 1];
+  if (act) {
+    lines.push(`├─ ${paint(theme, act.ok ? "success" : "error", act.ok ? "✓" : "✗")} ${act.name}${act.arg ? ` ${paint(theme, "dim", truncate(act.arg, 24))}` : ""}${act.ms > 0 ? ` ${paint(theme, "dim", `(${fmtElapsed(act.ms)})`)}` : ""}`);
+  }
+  const footer = !l.measureCmd
+    ? "metricless (no plateau) · /loop stop · /loop polish"
+    : `${l.kind === "audit" ? "metric: closed findings" : truncate(l.measureCmd, budgetFor(width, 3, 30))} · /loop stop`;
+  lines.push(`└─ ${paint(theme, "dim", footer)}`);
   if (l.branchName) lines.push(`⎇ ${paint(theme, "muted", truncate(l.branchName, budgetFor(width, 3, 50)))}`);
   return lines;
 }

package/extensions/goal-settings.ts

@@ -211,6 +211,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "stallSimilarityThreshold",
   "postaudit",
   "toolOverrides",
+  "reviewer", // v0.33.1: legacy alias — menu saves can write it; provenance must know it exists
 ];
 
 /** Where each effective setting comes from (for the /glla display). */

package/extensions/loops/goal.ts

@@ -630,6 +630,38 @@ function isSupervising(): boolean {
 let latestAuditProgress: AuditDisplayProgress | null = null;
 let uiTicker: NodeJS.Timeout | null = null;
 
+// v0.33.0: slim widget "last action" feed — a tiny ring of finished tool
+// calls {name, arg, ms, ok} captured from the tool_call/tool_result stream.
+// Display-only, never persisted; cleared implicitly as new actions land.
+const recentActions: import("../goal-loop-display.js").RecentActionDisplay[] = [];
+const inFlightToolCalls = new Map<string, { name: string; arg?: string; at: number }>();
+function summarizeToolArg(name: string, input: any): string | undefined {
+  if (!input || typeof input !== "object") return undefined;
+  const v = input.file_path ?? input.path ?? input.command ?? input.pattern ?? input.query ?? input.url ?? input.title;
+  if (typeof v !== "string" || v.length === 0) return undefined;
+  // v0.33.1: strip control chars BEFORE truncating — a raw \n breaks the
+  // widget card into un-prefixed lines (footer spoof), a raw ESC corrupts
+  // the TUI. The objective path was already whitespace-collapsed; this
+  // path was the gap.
+  const base = (name === "bash" ? v : v.split("/").pop() || v).replace(/[\x00-\x1f\x7f-\x9f]/g, " ").replace(/\s+/g, " ").trim();
+  return base.length <= 24 ? base : base.slice(0, 23) + "…";
+}
+function noteToolCall(event: any): void {
+  const name = String(event?.toolName ?? "?");
+  const id = String(event?.toolCallId ?? event?.id ?? `anon-${Date.now()}`);
+  if (inFlightToolCalls.size >= 20) inFlightToolCalls.delete(inFlightToolCalls.keys().next().value!); // v0.33.1: evict BEFORE the 21st
+  inFlightToolCalls.set(id, { name, arg: summarizeToolArg(name, event?.input ?? event?.args), at: Date.now() });
+}
+function noteToolResult(event: any): void {
+  const id = String(event?.toolCallId ?? event?.id ?? "");
+  const f = id ? inFlightToolCalls.get(id) : undefined;
+  if (id) inFlightToolCalls.delete(id);
+  const ok = !Boolean(event?.isError ?? event?.error);
+  const name = f?.name ?? String(event?.toolName ?? "?");
+  recentActions.push({ name, arg: f?.arg ?? summarizeToolArg(name, event?.input ?? event?.args), ms: f ? Date.now() - f.at : 0, ok });
+  if (recentActions.length > 3) recentActions.shift();
+}
+
 function refreshUI(ctx: ExtensionContext): void {
   if (!ctx.hasUI) return;
   try {
@@ -638,7 +670,7 @@ function refreshUI(ctx: ExtensionContext): void {
     // uses the room instead of cutting at fixed ~60-char floors.
     const width = process.stdout.columns || 80;
     ctx.ui.setStatus("pi-glla", buildStatusText(state, latestAuditProgress, Date.now(), theme, { stalls: consecutiveStalls }));
-    ctx.ui.setWidget("pi-glla", buildWidgetLines(state, latestAuditProgress, Date.now(), theme, width, { stalls: consecutiveStalls }));
+    ctx.ui.setWidget("pi-glla", buildWidgetLines(state, latestAuditProgress, Date.now(), theme, width, { stalls: consecutiveStalls, recent: recentActions }));
   } catch {
     // stale ctx — next event refreshes
   }
@@ -837,6 +869,14 @@ function heartbeatTick(): void {
     if (!absorbStaleIfSuperseded(ctx)) goStaleTerminal(ctx, "heartbeat probe");
     return;
   }
+  // v0.33.1: nothing supervised → the compact debt/resync belong to a dead
+  // goal/loop. Discharge here so a later goal can't inherit a bogus RESYNC
+  // block or a spurious forced refire (the old in-guard `else` was
+  // unreachable — isSupervising() ≡ isLoopActive() || isActionableGoal()).
+  if (!isSupervising() && (postCompactResumeOwed || postCompactResyncPending)) {
+    postCompactResumeOwed = false;
+    postCompactResyncPending = false;
+  }
   // v0.32.1: post-compaction resume debt — retry on every heartbeat tick
   // past grace until a turn actually starts. Fixed-offset settles alone
   // can both lose (pi busy at 2s AND at grace+2s = a dangling chain).
@@ -1076,7 +1116,10 @@ function sendContinuation(goalId: string): void {
   }
   if (!extensionApi || extensionApiStale) return;
   try {
-    const resync = postCompactResyncPending ? buildPostCompactResync() : "";
+    let resync = "";
+    // v0.33.1: a builder throw (corrupt restored state) must not masquerade
+    // as a transport failure — send without the block instead.
+    if (postCompactResyncPending) { try { resync = buildPostCompactResync(); } catch { resync = ""; } }
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
       content: resync + continuationPrompt(state.goal!),
@@ -1251,6 +1294,14 @@ function notifyPersistenceState(ctx: ExtensionContext): void {
 }
 
 function setGoal(goal: Goal, ctx: ExtensionContext, via = "user"): void {
+  // v0.33.1: per-goal module state resets at activation — a new goal must
+  // not inherit the previous goal's compact debt/resync, quota streak,
+  // token-message dedupe set, or widget action feed.
+  postCompactResumeOwed = false;
+  postCompactResyncPending = false;
+  quotaRetryStreak = 0;
+  countedTokenMessages.clear();
+  recentActions.length = 0;
   // v0.28.14: never silently orphan a live goal — a paused/active goal
   // being replaced is archived honestly first (the old behavior left it in
   // goals/ but untracked: "older goals lying around leading to confusion").
@@ -1369,6 +1420,8 @@ async function fanOutListAuditFindings(ctx: ExtensionContext): Promise<void> {
 }
 
 function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?: string): void {
+  postCompactResumeOwed = false; // v0.33.1: the dead goal's compact debt/resync dies with it
+  postCompactResyncPending = false;
   if (!state.goal) return;
   const goal = state.goal;
   ensureDirs(ctx.cwd);
@@ -2610,7 +2663,13 @@ function sendLoopTurn(): void {
   if (!isLoopActive() || !extensionApi) return;
   const ctx = freshCtx();
   if (!ctx || !ctx.isIdle() || ctx.hasPendingMessages()) {
-    if (ctx) accountSendRearm(ctx, "loop");
+    if (!ctx) {
+      // v0.33.1: mirror sendContinuation — probe the handle (terminal exit)
+      // and advance the streak so the cadence backs off instead of spinning
+      // a flat 50ms below every watchdog.
+      if (probeExtensionApiStale()) return;
+      loopRearmStreak++;
+    } else accountSendRearm(ctx, "loop");
     loopTimer = setTimeout(() => sendLoopTurn(), sendRearmDelayMs(loopRearmStreak)); // v0.28.29: backing-off cadence
     loopTimer.unref?.();
     return;
@@ -2666,7 +2725,8 @@ function sendLoopTurn(): void {
   // instruction (metricless loops; metric loops already vary via values).
   const variantNote = metricless ? continueVariant(loop.iteration) : "";
   try {
-    const loopResync = postCompactResyncPending ? buildPostCompactResync() : "";
+    let loopResync = "";
+    if (postCompactResyncPending) { try { loopResync = buildPostCompactResync(); } catch { loopResync = ""; } } // v0.33.1
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
       content: loopResync + loopPrompt(loop, regressionNote, strategyNote, boundsNote, interventionNote, variantNote),
@@ -5817,6 +5877,7 @@ 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) => {
+    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.
     if (isLoopActive()) {
@@ -5891,6 +5952,9 @@ export default function (pi: ExtensionAPI): void {
     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;
     const startReason = typeof event?.reason === "string" ? event.reason : "unknown";
     appendLedger(ctx.cwd, "session_rebound", { reason: startReason });
     if (extensionApiStale) {
@@ -6390,10 +6454,11 @@ export default function (pi: ExtensionAPI): void {
     scheduleContinuation(ctx, false);
   });
 
-  pi.on("tool_call", () => {
+  pi.on("tool_call", (event: any) => {
     toolCallsThisTurn++;
     noteActivity(true);
     lastStreamActivityAt = Date.now();
+    noteToolCall(event); // v0.33.0
     // v0.24.0: count loop-iteration tool calls (narration-only detection).
     if (isLoopActive()) {
       state.loop!.toolsThisTurn = (state.loop!.toolsThisTurn ?? 0) + 1;

package/package.json

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