pi-condense 2.9.0 → 2.9.2

package/CHANGELOG.md

@@ -7,6 +7,14 @@ Published to npm as [`pi-condense`](https://www.npmjs.com/package/pi-condense) (
 Pushing a `vX.Y.Z` tag triggers `.github/workflows/release.yml`, which runs the tests and
 publishes via OIDC trusted publishing. See `.agents/skills/release/SKILL.md`.
 
+## [2.9.2] - 2026-08-31
+
+- **Context metrics removed from the footer status line.** The ` · think Nk · gap Nk · chain P%` suffix rendered on nearly every non-idle session and crowded the footer for no actionable signal. The metrics stay on `/pruner status` (`--- context ---`) and in the `context-prune-flush-metrics` session entries; the footer is back to prune state, reclaim, and `diag`. The snapshot cache that existed only to feed the widget is gone - both remaining consumers compute on demand.
+
+## [2.9.1] - 2026-08-18
+
+- **Orphan sweep: any foreign message is now a barrier ([#11](https://github.com/jjuraszek/pi-condense/issues/11)).** `sweepOrphanToolResults` only reset its open-call set on `assistant` messages, while pi-ai flushes synthetic tool results at both `assistant` and `user` boundaries (`convertToLlm` maps `custom`/`branchSummary`/`compactionSummary`/`bashExecution` to `user`). A foreign message spliced between a toolCall and its toolResult (observed: a pi-cohort control notice) let the real result through alongside pi-ai's synthetic - a duplicate `tool_use_id` the provider rejects permanently (Anthropic 400, branch bricked). Now any message that is neither `assistant` nor `toolResult` clears the open set, so the interleaved result is swept and pi-ai's repairable synthetic stands alone; already-broken branches un-brick on the next render. Deliberate conservative over-sweep (unknown roles, `excludeFromContext` bashExecution) - no role allowlist. Test helper `expectNoOrphanToolResults` carries the identical rule. Spec: `doc/specs/2026-08-18-gh-11-orphan-sweep-barrier.md` (partially supersedes the 2026-08-12 spec's section C).
+
 ## [2.9.0] - 2026-08-14
 
 - **Uncovered chains now compress deterministically instead of stranding forever ([#10](https://github.com/jjuraszek/pi-condense/issues/10)).** Chain compression (Phase 3) required per-batch summary coverage; a closed eligible chain whose span produced no summaries (trivial batches, `skipped-oversized`, fully-deduped spans, capture misses) hit a permanent `no-summary` skip - once the prune frontier passed it, nothing could ever reclaim it. The motivating incident left a 639-call, ~935k-char chain (~62% of a 620k window) live in context indefinitely.

package/PRUNING.md

@@ -995,7 +995,7 @@ Phase 1 (per-batch summarization) is unaffected by chain closure and remains the
 
 Neither knob makes a chain close; they just keep Phase 1 flushing on schedule so raw toolResults do not pile up unsummarized for the whole run.
 
-**Observability metrics** (`src/context-metrics.ts`, `computeContextMetrics`) exist precisely to make this shape of session visible instead of silently reporting `calls: 1` the way the triggering incident did. All three are chars/4 token estimates (`Math.round`, same convention as the reclaim footer) and surface on `/pruner status` (a `--- context ---` block), the footer status line (a compact suffix, shown only when the frontier gap is non-zero), and a `context-prune-flush-metrics` session entry written once per flush attempt regardless of outcome:
+**Observability metrics** (`src/context-metrics.ts`, `computeContextMetrics`) exist precisely to make this shape of session visible instead of silently reporting `calls: 1` the way the triggering incident did. All three are chars/4 token estimates (`Math.round`, same convention as the reclaim footer) and surface on `/pruner status` (a `--- context ---` block) and a `context-prune-flush-metrics` session entry written once per flush attempt regardless of outcome:
 
 | Metric | Definition |
 |---|---|
@@ -1096,11 +1096,11 @@ Error purge replaces those arg bodies with compact stubs after the error has coo
 
 ## Orphan Sweep
 
-`pruneMessages` ends with an unconditional structural pass, `sweepOrphanToolResults` (`src/orphan-sweep.ts`): a `toolResult` message whose id was not opened by the immediately preceding assistant turn is removed. It runs after every other phase, over whatever the previous three produced, as a final post-condition rather than a targeted fix for one code path.
+`pruneMessages` ends with an unconditional structural pass, `sweepOrphanToolResults` (`src/orphan-sweep.ts`): a `toolResult` message whose id is not open is removed, where "open" means: opened by the most recent `assistant` message and not interrupted by any barrier since. It runs after every other phase, over whatever the previous three produced, as a final post-condition rather than a targeted fix for one code path.
 
 **Why it exists.** pi-ai's auto-repair (`insertSyntheticToolResults`) only fills in a missing `toolResult` for an orphaned `toolCall` - it has no equivalent repair for the opposite shape, an orphaned `toolResult` with no matching `toolCall`. Providers reject that shape outright (Anthropic: `unexpected tool_use_id found in tool_result blocks`; Kimi K3: a tool message needs a resolvable preceding tool_call). An orphaned `toolResult` can appear from any combination of id reuse, an unresolved chain range, or a bug in an upstream phase; the sweep is the last line of defense regardless of cause, and it is intentionally not keyed to any provider's specific error string - the fix is structural ("does this id have an open call"), not reactive to how one provider happens to phrase rejection.
 
-**Per-turn, not cumulative, open-call tracking.** The sweep does one forward pass over the message array. Each `assistant` message **replaces** the current "open" id set with its own `toolCall` ids; each `toolResult` message either consumes (removes) a matching id from that set or, if its id is not open, is swept. A cumulative seen-set across the whole array would be wrong here: it would let an id used validly by an early turn license a *later* genuine orphan under the same reused id - exactly the collision scenario this exists to catch. Per-turn tracking means only the immediately preceding assistant turn can vouch for a `toolResult`'s id.
+**Per-turn, not cumulative, open-call tracking.** The sweep does one forward pass over the message array. Each `assistant` message **replaces** the current "open" id set with its own `toolCall` ids; each `toolResult` message either consumes (removes) a matching id from that set or, if its id is not open, is swept. Any message that is neither `assistant` nor `toolResult` is a **barrier** that clears the open set. This tracks the post-`convertToLlm` flush points of pi-ai's `insertSyntheticToolResults` - `convertToLlm` maps `custom`, `branchSummary`, `compactionSummary`, and `bashExecution` to `role: "user"`, and pi-ai flushes synthetic tool results at both `assistant` and `user` boundaries - **plus** a deliberate conservative over-sweep: `bashExecution` with `excludeFromContext: true` and unknown roles are dropped by `convertToLlm` and strictly need not be barriers, but a role allowlist would have to track an open interface for zero observed benefit. Not an exact mirror, and not an allowlist. Trade-off: a foreign message spliced mid-cycle now costs one tool output - the interleaved real result is swept and pi-ai injects its repairable `{isError: true, "No result provided"}` synthetic - converting an unrepairable provider shape (duplicate `tool_use_id`, permanent Anthropic 400) into a visible-but-recoverable tool failure. See `doc/specs/2026-08-18-gh-11-orphan-sweep-barrier.md`. A cumulative seen-set across the whole array would be wrong here: it would let an id used validly by an early turn license a *later* genuine orphan under the same reused id - exactly the collision scenario this exists to catch. Per-turn tracking means only the most recent assistant turn, uninterrupted by a barrier, can vouch for a `toolResult`'s id.
 
 **Provider-agnostic and reference-preserving.** The sweep has no knowledge of which provider is in play; it operates purely on message shape. When nothing is swept it returns the **same array reference** it was given, so a clean render is a true no-op and the no-op / prompt-cache-prefix invariant of `doc/specs/2026-08-04-pruner-noop-serialization.md` holds - the sweep never forces a cache bust on a session where nothing is actually orphaned.
 

package/README.md

@@ -69,6 +69,8 @@ pi install npm:pi-condense
 | `agent-message` (default) | When the agent sends a final text-only reply | ~1 cache rewrite per task batch |
 | `on-demand` | Only when you run `/pruner now` | None until you ask |
 
+With the default `agent-message` trigger (and `autoBudgetThreshold`/`budgetTurnDelta` unset), a non-interactive (`pi -p`) session sees its first flush only at the final reply - set `autoBudgetThreshold` (e.g. `0.8`) so flushes also fire mid-run. This is a property of single-prompt sessions, not a defect in the default.
+
 Before any summarizer call, a pre-flush pipeline can drop or redirect a batch at zero LLM cost: protected tools/paths are never touched, content-hash duplicates are aliased to the original, batches too small to be worth summarizing are skipped outright, and oversized single results are spilled straight to a sidecar file. Closed tool-call chains older than a rolling window are additionally range-compressed. Full pipeline and each safeguard: [PRUNING.md § Pre-flush Pipeline & Safeguards](PRUNING.md#pre-flush-pipeline--safeguards), [§ Chain Compression](PRUNING.md#chain-compression).
 
 ### External cost channel
@@ -84,7 +86,7 @@ Every summarizer cost update is emitted on the shared `pi.events` channel `cost:
 | Batch vs chain | A batch is one flush's worth of tool calls; a chain is a longer closed sequence eligible for range compression |
 | Prune frontier | The last attempted prune boundary - advances even on a skip, so nothing is reconsidered twice |
 | Diagnostics (`diag u/m/o/b`) | A self-hiding status-line segment surfacing prune-time degradations: `u` = unresolved chain range, `m` = detection/render id mismatch (informational, does not change what's dropped), `o` = orphan tool-result sweep, `b` = a zero-coverage chain with nothing left to backfill (genuine span mismatch, see below). Each letter's count is omitted when zero; the whole segment disappears when all four are zero. Backing session entries are `context-prune-diagnostic` - see below |
-| Context metrics (`think`/`gap`/`chain`) | Open-cycle thinking tokens, largest-chain share, frontier gap - what the pruner cannot (yet) reclaim, notably in single-chain sessions. See below and [PRUNING.md § Single-chain sessions](PRUNING.md#single-chain-sessions) |
+| Context metrics (`thinking`/`chain share`/`frontier gap`) | Open-cycle thinking tokens, largest-chain share, frontier gap - what the pruner cannot (yet) reclaim, notably in single-chain sessions. Shown on `/pruner status`, never on the footer. See below and [PRUNING.md § Single-chain sessions](PRUNING.md#single-chain-sessions) |
 | Prompt-cache interaction | Why batching (not per-turn pruning) is the default - see [PRUNING.md](PRUNING.md#how-prefix-caching-works) |
 | `cost:external` | The shared cost-reporting channel pi-condense emits on (see above) |
 
@@ -100,10 +102,9 @@ The status-line `diag u<N>/m<N>/o<N>/b<N>` segment above is backed by `context-p
 
 ### Context metrics (`context-prune-flush-metrics`)
 
-Three metrics the pruner cannot yet reclaim - open-cycle thinking tokens, largest-chain share (%), frontier gap tokens - surface in three places, all backed by `computeContextMetrics` (`src/context-metrics.ts`):
+Three metrics the pruner cannot yet reclaim - open-cycle thinking tokens, largest-chain share (%), frontier gap tokens - surface in two places, both backed by `computeContextMetrics` (`src/context-metrics.ts`). They are deliberately kept off the footer status line, which stays limited to prune state, reclaim, and diagnostics:
 
 - `/pruner status` prints a `--- context ---` block: `thinking:`, `chain share:`, `frontier gap:`, plus a `rearmed: yes` line while a reload-rearm probe (below) has recoverable work armed.
-- The footer status line appends `· think Nk · gap Nk · chain P%` - only when the frontier gap is non-zero, so an idle session's footer is unchanged.
 - Each flush attempt (every outcome, including empty/error) writes one `context-prune-flush-metrics` session entry with the pre-flush snapshot - session-log-only, never added to what the model sees, and not reconstructed on reload.
 
 These are most informative for long single-chain sessions where Phase 3 (chain compression) never gets a closed chain to act on - see [PRUNING.md § Single-chain sessions](PRUNING.md#single-chain-sessions) for the limitation and config guidance, and [PRUNING.md § Reload rearm](PRUNING.md#reload-rearm) for how a reload with recoverable pending work re-arms the automatic flush trigger.
@@ -180,6 +181,10 @@ pi-condense is the context-economy layer: it has no code dependency on the other
 
 No committed roadmap beyond what's already tracked in [CHANGELOG.md](CHANGELOG.md); proposals and in-progress work show up there and in repo issues first.
 
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) - issues follow a Context / Problem / Idea / Acceptance Criteria template; PRs run the [pi-gauntlet](https://github.com/jjuraszek/pi-gauntlet) workflow (one-liners exempt from ceremony, never from keeping docs truthful).
+
 ## Support
 
 If this saves you tokens, [buy me a coffee](https://buymeacoffee.com/jjurasszek).

package/index.ts

@@ -93,10 +93,6 @@ export default function (pi: ExtensionAPI) {
   // Cleared on every non-concurrent flushPending invocation.
   let rearmedPending = false;
 
-  // Latest ContextMetricsSnapshot, recomputed at reload probes, batch capture,
-  // and flush entry. Cached (rather than recomputed on every widget refresh)
-  // because computeContextMetrics walks the full branch.
-  let metricsCache: ContextMetricsSnapshot | undefined;
   const computeMetricsSnapshot = (ctx: any): ContextMetricsSnapshot | undefined => {
     try {
       // Includes persisted custom_message entries (e.g. this extension's own
@@ -114,7 +110,7 @@ export default function (pi: ExtensionAPI) {
             ? { role: "custom", customType: e.customType, content: e.content, display: e.display, details: e.details, timestamp: new Date(e.timestamp).getTime() }
             : e.message,
         );
-      metricsCache = computeContextMetrics(
+      return computeContextMetrics(
         branch,
         frontier.get(),
         (k: string) => indexer.isSummarized(k),
@@ -122,8 +118,8 @@ export default function (pi: ExtensionAPI) {
       );
     } catch (err) {
       console.error("pi-condense: context metrics computation failed", err);
+      return undefined;
     }
-    return metricsCache;
   };
 
   type FlushResult =
@@ -566,7 +562,7 @@ export default function (pi: ExtensionAPI) {
 
       if (processedBatches.length === 0) {
         // Nothing was persisted (all calls failed or first call failed)
-        setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts(), metricsCache);
+        setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts());
         outcome = "error";
         return { ok: false, reason: "summarizer-failed" };
       }
@@ -644,7 +640,7 @@ export default function (pi: ExtensionAPI) {
         return { ok: false, reason: isStaleContextError(err) ? "stale-context" : "failed", error: errorMessage(err) };
       }
 
-      setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts(), metricsCache);
+      setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts());
       emitExternalCost(pi, statsAccum);
 
       // Chain compression — compress closed chains beyond the rolling window.
@@ -771,7 +767,7 @@ export default function (pi: ExtensionAPI) {
       // When the abort signal fired, summarizeBatch rethrows rather than
       // swallowing the error.  Don't show a UI error — the user intended this.
       if (options.signal?.aborted) {
-        setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts(), metricsCache);
+        setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts());
         return { ok: false, reason: "aborted" };
       }
       if (isStaleContextError(err)) {
@@ -816,10 +812,8 @@ export default function (pi: ExtensionAPI) {
       }
     }
 
-    computeMetricsSnapshot(ctx);
-
     // Update footer status
-    setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts(), metricsCache);
+    setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts());
 
     ctx.ui.setWidget(
       "pruner-boot",
@@ -856,8 +850,7 @@ export default function (pi: ExtensionAPI) {
       }
     }
 
-    computeMetricsSnapshot(ctx);
-    setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts(), metricsCache);
+    setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts());
   });
 
   // ── turn_end: capture batch, flush immediately or queue ──────────────────
@@ -934,13 +927,6 @@ export default function (pi: ExtensionAPI) {
       }
     }
 
-    // Recompute regardless of whether trim produced a batch: a turn whose
-    // toolResults are all protected/spilled/summarized/trimmed-empty still
-    // changes the branch (thinking, open-segment size), so the cache must not
-    // go stale on it. Placed before the pushedBatch/rearmedPending early
-    // return below — a cache write is not gate evaluation.
-    if (hasToolResults) computeMetricsSnapshot(ctx);
-
     // Mirrors main's `if (!batch) return;`: no freshly pushed batch this turn
     // means no gate evaluation, regardless of leftover pendingBatches from an
     // earlier turn — UNLESS a reload probe armed rearmedPending, in which case
@@ -1026,7 +1012,7 @@ export default function (pi: ExtensionAPI) {
       changed = true;
       statsAccum.setLiveReclaim(result.beforeChars, result.afterChars);
     }
-    setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts(), metricsCache);
+    setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts());
 
     if (!changed) return undefined;
     return { messages };
@@ -1082,7 +1068,6 @@ export default function (pi: ExtensionAPI) {
     compactChains,
     () => diagnostics.counts(),
     (ctx: any) => computeMetricsSnapshot(ctx) ?? EMPTY_METRICS_SNAPSHOT,
-    () => metricsCache,
     () => rearmedPending,
   );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Pi coding-agent extension that summarizes completed tool-call batches, replaces raw outputs with short stubs, compresses closed tool-call chains, and recovers any original on demand via context_tree_query.",
   "author": "Jacek Juraszek",
   "license": "MIT",

package/src/chain-range-prune.test.ts

@@ -796,6 +796,13 @@ describe("applyChainCompressions - positional", () => {
         msgs[3] = { ...msgs[3], content: [{ type: "thinking", thinking: "hmm" }, { type: "text", text: "done 1" }] } as any;
         return applyChainCompressions(msgs, entries as any, summaryFor, true);
       }],
+      ["a context-prune-summary after a completed cycle", () => {
+        const msgs = incident();
+        msgs.splice(8, 0, { role: "custom", customType: CUSTOM_TYPE_SUMMARY, content: "batch summary", timestamp: 2250 } as any);
+        const out = applyChainCompressions(msgs, entries as any, summaryFor, false);
+        expect(out.some((m: any) => m.customType === CUSTOM_TYPE_SUMMARY)).toBe(true);
+        return out;
+      }],
       ["skips an entry whose start falls strictly inside another entry's range", () => {
         const wide = { blockId: "b8", startUserTimestamp: 1000, droppedToolCallIds: [], finalAssistantTimestamp: 2200, toolRefs: [], compressedAt: 9002 };
         const nestedInner = { blockId: "b9", startUserTimestamp: 2000, droppedToolCallIds: [], finalAssistantTimestamp: 2200, toolRefs: [], compressedAt: 9003 };

package/src/commands.test.ts

@@ -11,10 +11,9 @@ function captureStatus(
   config: ContextPruneConfig,
   value?: Parameters<typeof setPruneStatusWidget>[2],
   diagnostics?: Parameters<typeof setPruneStatusWidget>[3],
-  metrics?: Parameters<typeof setPruneStatusWidget>[4],
 ): string | undefined {
   let captured: string | undefined;
-  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value, diagnostics, metrics);
+  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value, diagnostics);
   return captured;
 }
 
@@ -59,7 +58,6 @@ function setupPrunerCommand(overrides: {
     async () => ({ compressedEntries: [], skipped: 0 }),
     undefined,
     overrides.getContextMetrics,
-    undefined,
     overrides.getRearmed,
   );
 
@@ -213,28 +211,3 @@ describe("diagnostic counters on the status line", () => {
   });
 });
 
-describe("context metrics suffix on the status line", () => {
-  const metrics: ContextMetricsSnapshot = {
-    openCycleThinkingTokens: 12000,
-    largestChainSharePct: 62,
-    frontierGapTokens: 195000,
-  };
-
-  it("appends a compact think/gap/chain segment when frontierGapTokens > 0", () => {
-    const text = pruneStatusText(cfg(true), undefined, undefined, metrics);
-    expect(text).toContain("\u00b7 think 12.0k \u00b7 gap 195.0k \u00b7 chain 62%");
-  });
-
-  it("omits the suffix when frontierGapTokens is 0", () => {
-    const withZeroGap = { ...metrics, frontierGapTokens: 0 };
-    expect(pruneStatusText(cfg(true), undefined, undefined, withZeroGap)).toBe(
-      pruneStatusText(cfg(true)),
-    );
-  });
-
-  it("composes after the diag suffix when both are present", () => {
-    const mixedDiag = { "unresolved-range": 2, "range-id-mismatch": 0, "orphan-sweep": 1 } as const;
-    const text = pruneStatusText(cfg(true), undefined, mixedDiag, metrics);
-    expect(text).toBe("prune: ON \u00b7 diag u2/o1 \u00b7 think 12.0k \u00b7 gap 195.0k \u00b7 chain 62%");
-  });
-});

package/src/commands.ts

@@ -64,7 +64,6 @@ export function pruneStatusText(
   config: ContextPruneConfig,
   reclaim?: LiveReclaim,
   diagnostics?: Record<DiagnosticKind, number>,
-  metrics?: ContextMetricsSnapshot,
 ): string {
   if (!config.enabled) return "prune: OFF";
   const diag = diagnostics
@@ -76,14 +75,11 @@ export function pruneStatusText(
       ].filter(Boolean)
     : [];
   const suffix = diag.length > 0 ? ` \u00b7 diag ${diag.join("/")}` : "";
-  const metricsSuffix = metrics && metrics.frontierGapTokens > 0
-    ? ` \u00b7 think ${formatCompactCount(metrics.openCycleThinkingTokens)} \u00b7 gap ${formatCompactCount(metrics.frontierGapTokens)} \u00b7 chain ${metrics.largestChainSharePct}%`
-    : "";
-  if (!reclaim || reclaim.beforeChars <= 0) return `prune: ON${suffix}${metricsSuffix}`;
+  if (!reclaim || reclaim.beforeChars <= 0) return `prune: ON${suffix}`;
   const beforeTok = Math.round(reclaim.beforeChars / 4);
   const afterTok = Math.round(reclaim.afterChars / 4);
   const reduction = Math.max(0, Math.round((1 - afterTok / beforeTok) * 100));
-  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)${suffix}${metricsSuffix}`;
+  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)${suffix}`;
 }
 
 export function setPruneStatusWidget(
@@ -91,13 +87,12 @@ export function setPruneStatusWidget(
   config: ContextPruneConfig,
   value?: LiveReclaim | string,
   diagnostics?: Record<DiagnosticKind, number>,
-  metrics?: ContextMetricsSnapshot,
 ): void {
   if (!config.showPruneStatusLine) {
     ctx.ui.setStatus(STATUS_WIDGET_ID, undefined);
     return;
   }
-  const text = typeof value === "string" ? value : pruneStatusText(config, value, diagnostics, metrics);
+  const text = typeof value === "string" ? value : pruneStatusText(config, value, diagnostics);
   // Leading-only separator: the footer joins extension status segments with a
   // single space, so a trailing divider collides with the next segment's leading
   // one and renders doubled. One leading bar yields single dividers between
@@ -481,7 +476,6 @@ export function registerCommands(
   compactChains: (ctx: ExtensionCommandContext) => Promise<{ compressedEntries: ChainCompressionEntry[]; skipped: number }>,
   getDiagnosticCounts?: () => Record<DiagnosticKind, number>,
   getContextMetrics?: (ctx: ExtensionCommandContext) => ContextMetricsSnapshot,
-  getCachedMetrics?: () => ContextMetricsSnapshot | undefined,
   getRearmed?: () => boolean,
 ): void {
   // Register the /pruner command
@@ -829,7 +823,7 @@ export function registerCommands(
             }
             currentConfig.value = newConfig;
             saveConfig(newConfig);
-            setPruneStatusWidget(ctx, newConfig, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+            setPruneStatusWidget(ctx, newConfig, getLiveReclaim(), getDiagnosticCounts?.());
             settingsList?.invalidate();
           };
 
@@ -864,7 +858,7 @@ export function registerCommands(
           currentConfig.value = { ...currentConfig.value, enabled: true };
           saveConfig(currentConfig.value);
           ctx.ui.notify("Context pruning enabled.");
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -873,7 +867,7 @@ export function registerCommands(
           currentConfig.value = { ...currentConfig.value, enabled: false };
           saveConfig(currentConfig.value);
           ctx.ui.notify("Context pruning disabled.");
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -996,7 +990,7 @@ export function registerCommands(
             currentConfig.value = { ...currentConfig.value, pruneOn: modeArg as ContextPruneConfig["pruneOn"] };
           }
           saveConfig(currentConfig.value);
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -1098,7 +1092,7 @@ export function registerCommands(
 
           // Remove the widget and restore the normal footer status.
           clearWidget();
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
 
           if (!result.ok) {
             const suffix = "error" in result && result.error ? ` (${result.error})` : "";

package/src/orphan-sweep.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { sweepOrphanToolResults } from "./orphan-sweep.js";
+import { expectNoOrphanToolResults } from "./test-support.js";
 
 const asst = (ts: number, ids: string[]) => ({
   role: "assistant",
@@ -60,8 +61,47 @@ describe("sweepOrphanToolResults", () => {
     expect(sweepOrphanToolResults(msgs).messages).toBe(msgs);
   });
 
-  test("non-assistant messages between a call and its result do not close the open set", () => {
-    const msgs = [asst(1, ["a"]), { role: "custom", customType: "x", timestamp: 2 }, res(3, "a")];
-    expect(sweepOrphanToolResults(msgs).messages).toBe(msgs);
+  // AC1: any non-assistant/non-toolResult role is a barrier - including an
+  // unknown role, so a role-allowlist implementation cannot pass.
+  const barrierRoles: Array<[string, any]> = [
+    ["custom", { role: "custom", customType: "x", timestamp: 2 }],
+    ["user", user(2)],
+    ["branchSummary", { role: "branchSummary", timestamp: 2 }],
+    ["compactionSummary", { role: "compactionSummary", timestamp: 2 }],
+    ["bashExecution", { role: "bashExecution", timestamp: 2 }],
+    ["unknown future role", { role: "future-role", timestamp: 2 }],
+  ];
+  for (const [name, barrier] of barrierRoles) {
+    test(`a ${name} message between a call and its result is a barrier: the result is swept`, () => {
+      const msgs = [asst(1, ["a"]), barrier, res(3, "a")];
+      const out = sweepOrphanToolResults(msgs);
+      expect(out.sweptIds).toEqual(["a"]);
+      expect(out.messages).toHaveLength(2);
+      expect(out.messages.some((m: any) => m.role === "toolResult")).toBe(false);
+    });
+  }
+
+  // AC2: barrier clears only what is still open; results consumed before it stay.
+  test("multi-call turn: barrier sweeps only the not-yet-consumed result", () => {
+    const msgs = [asst(1, ["a", "b"]), res(2, "a"), { role: "custom", customType: "x", timestamp: 3 }, res(4, "b")];
+    const out = sweepOrphanToolResults(msgs);
+    expect(out.sweptIds).toEqual(["b"]);
+    expect(out.messages).toHaveLength(3);
+  });
+
+  // AC3: a barrier after a completed cycle is untouched - same array reference.
+  test("trailing barrier after a completed cycle is a no-op (same array reference)", () => {
+    const msgs = [asst(1, ["a"]), res(2, "a"), { role: "custom", customType: "x", timestamp: 3 }];
+    const out = sweepOrphanToolResults(msgs);
+    expect(out.messages).toBe(msgs);
+    expect(out.sweptIds).toEqual([]);
+  });
+
+  // AC5: the test helper enforces the same barrier rule (it copies the sweep's
+  // orphan definition; delegation would make sweep tests tautological).
+  test("expectNoOrphanToolResults throws on a mid-cycle barrier orphan and passes on a clean trailing barrier", () => {
+    const bad = [asst(1, ["a"]), { role: "custom", customType: "x", timestamp: 2 }, res(3, "a")];
+    expect(() => expectNoOrphanToolResults(bad)).toThrow();
+    expectNoOrphanToolResults([asst(1, ["a"]), res(2, "a"), { role: "custom", customType: "x", timestamp: 3 }]);
   });
 });

package/src/orphan-sweep.ts

@@ -2,7 +2,9 @@
  * pi-ai repairs orphan tool calls only; providers reject orphan tool results.
  *
  * Open-call tracking is PER TURN: an assistant message replaces the open set
- * with its own toolCall ids. A cumulative seen-set would let an id used
+ * with its own toolCall ids, and any message that is neither assistant nor
+ * toolResult is a barrier that clears it (matching where pi-ai flushes
+ * synthetic tool results). A cumulative seen-set would let an id used
  * validly in an early turn license a later genuine orphan - exactly the
  * id-collision case this exists for.
  *
@@ -32,7 +34,15 @@ export function sweepOrphanToolResults(messages: any[]): { messages: any[]; swep
         orphanIndices.add(i);
         sweptIds.push(msg.toolCallId);
       }
+      continue;
     }
+    // Barrier: any other role converts to a user-boundary at the provider
+    // (convertToLlm maps custom/branchSummary/compactionSummary/bashExecution
+    // to role "user"; pi-ai flushes synthetic tool results there), so a
+    // still-open call can no longer be legally answered after it. Unknown
+    // roles and excludeFromContext bashExecutions are a deliberate
+    // conservative over-sweep - no allowlist.
+    open = new Set();
   }
 
   if (orphanIndices.size === 0) return { messages, sweptIds: [] };

package/src/pruner.ts

@@ -47,10 +47,11 @@ export function sizeMessages(messages: any[]): number {
  * Only runs when `chainCompression.enabled` and chain entries exist.
  *
  * Phase 4 — orphan sweep: structural post-condition run unconditionally over
- * the final array. Removes any toolResult whose matching toolCall id was not
- * opened by the immediately preceding assistant turn (per-turn open set, not
- * cumulative — see src/orphan-sweep.ts). Reference-preserving when nothing is
- * swept, so a clean render still returns the identical input array.
+ * the final array. Removes any toolResult whose matching toolCall id is not
+ * open: opened by the most recent assistant turn and uninterrupted by a
+ * barrier (any non-assistant/non-toolResult message) — see
+ * src/orphan-sweep.ts. Reference-preserving when nothing is swept, so a
+ * clean render still returns the identical input array.
  *
  * Return shape:
  *   - `pruned: true`  — at least one change happened; the returned

package/src/reload-rearm.integration.test.ts

@@ -173,6 +173,8 @@ function bootExtension(
   const piAppended: AppendedEntry[] = options.separatePiAppended ? [] : appended;
   const sessionAppended: AppendedEntry[] = appended;
   const handlers = new Map<string, (event: any, ctx: any) => any>();
+  const commands = new Map<string, (args: string, ctx: any) => Promise<void>>();
+  const notifications: string[] = [];
 
   const pushPi = (type: string, data?: unknown) => {
     piAppended.push({ type, data });
@@ -187,7 +189,9 @@ function bootExtension(
     },
     appendEntry: options.piAppendEntry ? options.piAppendEntry(pushPi) : pushPi,
     sendMessage() {},
-    registerCommand() {},
+    registerCommand(name: string, spec: { handler: (args: string, ctx: any) => Promise<void> }) {
+      commands.set(name, spec.handler);
+    },
     registerTool() {},
     registerMessageRenderer() {},
     events: { emit() {} },
@@ -221,12 +225,14 @@ function bootExtension(
     ui: {
       setStatus() {},
       setWidget() {},
-      notify() {},
+      notify(message: string) {
+        notifications.push(message);
+      },
       select: async () => undefined,
     },
   };
 
-  return { handlers, ctx, pi, piAppended, sessionAppended, appended, branch };
+  return { handlers, commands, notifications, ctx, pi, piAppended, sessionAppended, appended, branch };
 }
 
 async function boot(options?: Parameters<typeof bootExtension>[0]) {
@@ -526,75 +532,6 @@ describe("reload rearm (issue #6)", () => {
     expect(piAppended.some((e) => e.type === "context-prune-flush-metrics")).toBe(false);
   });
 
-  it("recomputes the cached metrics snapshot on a turn_end whose toolResults produce no pushed batch (G3)", async () => {
-    // Component 4 (spec): the snapshot cache recomputes at every enabled
-    // turn_end carrying toolResults, unconditional on whether trim yields a
-    // batch to push. Observed via the footer widget suffix (commands.ts's
-    // pruneStatusText), which is rendered from the cache, not recomputed
-    // itself — the honest seam here since the harness's pi.registerCommand
-    // is a no-op stub and the registerCommands getCachedMetrics callback is
-    // therefore unreachable from a test.
-    const { handlers, ctx, branch } = await boot({ protectedTools: ["secret_tool"] });
-
-    // Neutralize the budget/delta gate so this test only observes the
-    // recompute, not a side-effect flush (harness default usage is 0.6,
-    // above the fixture's 0.5 autoBudgetThreshold).
-    ctx.getContextUsage = () => ({ tokens: 10, contextWindow: 1000000 });
-
-    await handlers.get("session_start")!({}, ctx);
-
-    const statusCalls: unknown[] = [];
-    ctx.ui.setStatus = (_id: string, text?: string) => statusCalls.push(text);
-
-    // Force a render of the current (session_start-computed) cache.
-    const rawBefore = ctx.sessionManager.getBranch().filter((e: any) => e.type === "message").map((e: any) => e.message);
-    await handlers.get("context")!({ messages: rawBefore }, ctx);
-    const textBefore = statusCalls[statusCalls.length - 1];
-
-    // Grow the branch as Pi would before firing turn_end: a new assistant
-    // turn with a large thinking block and a protected tool call, plus its
-    // toolResult. Protected content is excluded from frontierGapTokens by
-    // design, but NOT from openCycleThinkingTokens or largestChainSharePct —
-    // so this turn still moves the cache if recomputed.
-    const newAssistant = {
-      type: "message",
-      message: {
-        role: "assistant",
-        content: [
-          { type: "thinking", text: "t".repeat(4000) },
-          { type: "toolCall", id: "tc2", name: "secret_tool", arguments: {} },
-        ],
-      },
-    };
-    const newToolResult = {
-      type: "message",
-      message: {
-        role: "toolResult",
-        toolCallId: "tc2",
-        toolName: "secret_tool",
-        content: [{ type: "text", text: "s".repeat(400) }],
-        timestamp: Date.now(),
-      },
-    };
-    branch.push(newAssistant, newToolResult);
-
-    // This turn's toolResults are entirely protected, so trimBatchToPendingRange
-    // returns null and no batch is pushed — the case this fix targets.
-    await handlers.get("turn_end")!(
-      { message: newAssistant.message, toolResults: [newToolResult.message], turnIndex: 3 },
-      ctx,
-    );
-
-    const rawAfter = ctx.sessionManager.getBranch().filter((e: any) => e.type === "message").map((e: any) => e.message);
-    await handlers.get("context")!({ messages: rawAfter }, ctx);
-    const textAfter = statusCalls[statusCalls.length - 1];
-
-    // Pre-fix, the cache is stale (computed once at session_start, on the
-    // pre-growth branch) — the widget text does not move. Post-fix, the
-    // turn_end recompute picks up the larger open segment/thinking.
-    expect(textAfter).not.toBe(textBefore);
-  });
-
   it("includes a persisted summary custom_message entry in the largest-chain-share denominator (G1)", async () => {
     // Component 1 (spec): denominator = per-message chars over the entire
     // branch projection, INCLUDING retained custom_message summary entries.
@@ -620,17 +557,13 @@ describe("reload rearm (issue #6)", () => {
     };
     const branch = [...closedChain, summaryEntry, closer];
 
-    const { handlers, ctx } = await boot({ branch });
+    const { handlers, commands, notifications, ctx } = await boot({ branch });
     ctx.getContextUsage = () => ({ tokens: 10, contextWindow: 1000000 });
 
-    const statusCalls: unknown[] = [];
-    ctx.ui.setStatus = (_id: string, text?: string) => statusCalls.push(text);
-
     await handlers.get("session_start")!({}, ctx);
 
-    const rawMessages = ctx.sessionManager.getBranch().filter((e: any) => e.type === "message").map((e: any) => e.message);
-    await handlers.get("context")!({ messages: rawMessages }, ctx);
-    const text = statusCalls[statusCalls.length - 1] as string;
+    await commands.get("pruner")!("status", ctx);
+    const text = notifications[notifications.length - 1] as string;
 
     const chainChars = closedChain.map((e: any) => JSON.stringify(e.message).length).reduce((a, b) => a + b, 0);
     const totalWithSummary = [...closedChain.map((e: any) => e.message), summaryEntry, closer.message]
@@ -641,7 +574,7 @@ describe("reload rearm (issue #6)", () => {
       (100 * chainChars) / closedChain.map((e: any) => JSON.stringify(e.message).length).reduce((a, b) => a + b, 0),
     );
 
-    expect(text).toContain(`chain ${expectedPct}%`);
+    expect(text).toContain(`chain share:  ${expectedPct}%`);
     expect(expectedPct).toBeLessThan(inflatedPct);
   });
 });

package/src/test-support.ts

@@ -12,6 +12,8 @@ export function expectNoOrphanToolResults(messages: any[]): void {
     } else if (m.role === "toolResult") {
       expect(open.has(m.toolCallId)).toBe(true);
       open.delete(m.toolCallId);
+    } else {
+      open = new Set();
     }
   }
 }