pi-goal-list-loop-audit 0.32.0 → 0.33.0

package/extensions/goal-loop-display.ts

@@ -48,6 +48,31 @@ export function truncate(s: string, max: number): string {
   return s.length <= max ? s : s.slice(0, Math.max(0, max - 1)) + "…";
 }
 
+/** 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 +159,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 +248,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 +259,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 +267,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 +287,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 +296,37 @@ 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))}`;
+  const headBase = `${icon} ${truncate(g.objective.replace(/\s+/g, " "), budgetFor(width, 3, 48))}`;
   // 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.
+  const head = `${headBase} ${paint(theme, "dim", "·")} ${headSegs.join(` ${paint(theme, "dim", "·")} `)}`;
+  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 +397,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 +415,30 @@ 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"}`)}`);
+    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 lines = [`${icon} ${truncate(l.target, budgetFor(width, 3, 44))} ${paint(theme, "dim", "·")} ${segs.join(` ${paint(theme, "dim", "·")} `)}${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/loops/goal.ts

@@ -630,6 +630,34 @@ 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;
+  const base = name === "bash" ? v : v.split("/").pop() || v;
+  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!);
+  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 +666,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
   }
@@ -668,6 +696,16 @@ let loopRearmStreak = 0;
 // whose turn trigger was still dead — pausing a resumable goal 4 minutes
 // after the compact instead of giving pi room to recover.
 let compactionGraceUntil = 0;
+// v0.32.1 (pi-goal-x's lesson — "recover from compacts smarter"): a compact
+// leaves a RESUME DEBT, not just two fixed-offset settle probes that can both
+// lose (field: hellhunter 4-min dangle 2026-07-31; polis stall same day).
+// postCompactResumeOwed discharges only when a real turn starts (agent_start);
+// every heartbeat tick past grace retries it. postCompactResyncPending arms a
+// deterministic [POST-COMPACTION RESYNC] block on the next continuation/loop
+// message (pi-goal-x's #5) so the compacted agent re-anchors on artifact
+// state instead of lost chat history.
+let postCompactResumeOwed = false;
+let postCompactResyncPending = false;
 const COMPACTION_GRACE_MS = 3 * 60_000;
 // v0.28.25: provider-error retry cadence. Field-observed in dracon-utilities
 // (kimi, 19-session fleet on one provider account): a "concurrent request
@@ -827,6 +865,24 @@ function heartbeatTick(): void {
     if (!absorbStaleIfSuperseded(ctx)) goStaleTerminal(ctx, "heartbeat probe");
     return;
   }
+  // 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).
+  if (postCompactResumeOwed && isSupervising() && !abortedStandDown) {
+    try {
+      if (ctx.isIdle() && !ctx.hasPendingMessages() && continuationTimer === null && loopTimer === null) {
+        if (isLoopActive()) {
+          appendLedger(ctx.cwd, "compaction_resume_owed_refire", { kind: "loop" });
+          scheduleLoopTick(ctx);
+        } else if (isActionableGoal()) {
+          appendLedger(ctx.cwd, "compaction_resume_owed_refire", { kind: "goal" });
+          scheduleContinuation(ctx, true);
+        } else {
+          postCompactResumeOwed = false; // nothing to resume — discharge
+        }
+      }
+    } catch { /* next tick */ }
+  }
   // v0.29.16: zombie-run watchdog. pi reports BUSY (a run is "active") but
   // zero stream events for 20 min = the provider stream hung silently —
   // queued continuations can't land, and every other watchdog stays quiet
@@ -1048,11 +1104,13 @@ function sendContinuation(goalId: string): void {
   }
   if (!extensionApi || extensionApiStale) return;
   try {
+    const resync = postCompactResyncPending ? buildPostCompactResync() : "";
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
-      content: continuationPrompt(state.goal!),
+      content: resync + continuationPrompt(state.goal!),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
+    if (resync) postCompactResyncPending = false; // consumed only by a landed send
     continuationRearmStreak = 0; continuationRearmSince = 0; // v0.28.5 (E3): a landed send clears the storm
     appendLedger(ctx.cwd, "goal_continuation_sent", { goalId });
   } catch (err) {
@@ -1105,6 +1163,25 @@ function sendLengthContinue(ctx: ExtensionContext, consecutive: number): void {
   }
 }
 
+/** v0.32.1: deterministic post-compaction re-anchor (pi-goal-x's #5) —
+ * prepended to the first continuation/loop message after a compact. */
+function buildPostCompactResync(): string {
+  const lines: string[] = [
+    "[POST-COMPACTION RESYNC] The transcript was just compacted. Trust the artifacts on disk and .pi-glla/ state — NOT your memory of the prior chat. Re-read files before editing them.",
+  ];
+  if (state.goal) {
+    lines.push(`Goal ${state.goal.id} — status ${state.goal.status}`);
+    lines.push(`Objective: ${state.goal.objective.slice(0, 200)}`);
+    const next = findNextPendingTask(state.goal.taskList?.tasks ?? []);
+    if (next) lines.push(`Next pending task: \`${next.id}\` — ${next.title}`);
+    const lastAudit = state.goal.auditHistory?.[state.goal.auditHistory.length - 1];
+    if (lastAudit) lines.push(`Last audit: ${lastAudit.approved ? "APPROVED" : lastAudit.impossible ? "IMPOSSIBLE" : "disapproved"} (${lastAudit.at})`);
+  } else if (state.loop?.active) {
+    lines.push(`Loop: ${state.loop.target.slice(0, 160)} — iteration ${state.loop.iteration}`);
+  }
+  return lines.join("\n") + "\n\n";
+}
+
 function continuationPrompt(goal: Goal): string {
   // Read the .md file as the template, then substitute {{tokens}}.
   // For v0.1.0 we inline-substitute so we don't need fs at runtime.
@@ -2617,11 +2694,13 @@ function sendLoopTurn(): void {
   // instruction (metricless loops; metric loops already vary via values).
   const variantNote = metricless ? continueVariant(loop.iteration) : "";
   try {
+    const loopResync = postCompactResyncPending ? buildPostCompactResync() : "";
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
-      content: loopPrompt(loop, regressionNote, strategyNote, boundsNote, interventionNote, variantNote),
+      content: loopResync + loopPrompt(loop, regressionNote, strategyNote, boundsNote, interventionNote, variantNote),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
+    if (loopResync) postCompactResyncPending = false; // consumed only by a landed send
     // v0.26.1: the send path is ledgered — the hegemon zombie spun 619
     // refires with zero visibility into whether sends were landing.
     loopRearmStreak = 0; loopRearmSince = 0; // v0.28.5 (E3): a landed turn clears the storm
@@ -5708,6 +5787,11 @@ export default function (pi: ExtensionAPI): void {
     continuationRearmStreak = 0; continuationRearmSince = 0;
     loopRearmStreak = 0; loopRearmSince = 0;
     compactionGraceUntil = Date.now() + COMPACTION_GRACE_MS;
+    // v0.32.1: arm the resume debt + the resync block (the settle probes
+    // below stay as the fast path; the heartbeat now retries the debt on
+    // EVERY post-grace tick until agent_start discharges it).
+    postCompactResumeOwed = true;
+    postCompactResyncPending = true;
     const settle = setTimeout(() => {
       const c = freshCtx();
       if (!c) return;
@@ -5761,6 +5845,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()) {
@@ -6334,10 +6419,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;
@@ -6351,6 +6437,9 @@ export default function (pi: ExtensionAPI): void {
   });
   pi.on("agent_start", () => {
     lastStreamActivityAt = Date.now();
+    // v0.32.1: a real turn started — the post-compaction resume debt is
+    // discharged (the heartbeat stops retrying it).
+    postCompactResumeOwed = false;
   });
   pi.on("turn_start", () => {
     lastStreamActivityAt = Date.now();

package/package.json

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