pi-condense 2.15.0 → 2.15.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ 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.15.1] - 2026-11-10
+
+### Fixed
+
+- `/pruner on` runs the reload rearm probe when it flips pruning from off to on, so tool results produced while pruning was disabled, or recovered by a reload that happened while it was disabled, reach the next `turn_end` gate. Before, only `session_start` and `session_tree` probed, and enabling later left that work unflushed until a fresh batch arrived. (#29)
+
 ## [2.15.0] - 2026-11-09
 
 ### Changed

package/PRUNING.md

@@ -1074,9 +1074,9 @@ See `doc/specs/2026-08-12-single-chain-observability-trigger-repair.md` for the
 
 ### Reload rearm
 
-A reload (`session_start` or `session_tree`) rescans the branch for completed-but-unflushed tool-call batches past the frontier (the same rescan `flushPending` itself uses, no queue reconstruction). If that rescan finds recoverable work, a transient in-memory flag arms: the next `turn_end` evaluates the budget/delta trigger even on a turn that contributes no new tool results itself, instead of silently requiring a fresh batch to reach the gate. No flush runs at reload time - arming only changes what an *existing* trigger sees on the next turn.
+A reload (`session_start` or `session_tree`), and `/pruner on` when it flips pruning from off to on, rescans the branch for completed-but-unflushed tool-call batches past the frontier (the same rescan `flushPending` itself uses, no queue reconstruction). If that rescan finds recoverable work, a transient in-memory flag arms: the next `turn_end` evaluates the budget/delta trigger even on a turn that contributes no new tool results itself, instead of silently requiring a fresh batch to reach the gate. No flush runs at reload time - arming only changes what an *existing* trigger sees on the next turn.
 
-The flag clears the moment any flush attempt runs (any outcome) and is re-evaluated on the next reload. A reload followed by total idleness - no further turns at all - gets visibility only: the footer, `/pruner status`, and the `agent_end` pending notice (`prune: recovered pending (reload)`) all reflect the recoverable work, but nothing flushes automatically. This is by design - no immediate flush at boot (print-mode sessions may die under it; a boot-time compact was not requested by the user).
+The flag clears the moment any flush attempt runs (any outcome) and is re-evaluated on the next reload or enable. `turn_end` captures nothing while pruning is disabled, so the `/pruner on` probe is what puts tool results from a disabled stretch back in front of the gate; a `/pruner on` while already enabled does not probe. A reload followed by total idleness - no further turns at all - gets visibility only: the footer, `/pruner status`, and the `agent_end` pending notice (`prune: recovered pending (reload)`) all reflect the recoverable work, but nothing flushes automatically. This is by design - no immediate flush at boot (print-mode sessions may die under it; a boot-time compact was not requested by the user).
 
 ---
 

package/index.ts

@@ -180,9 +180,9 @@ export default function (pi: ExtensionAPI) {
   // ── Helper: capture + trim + group pending batches (no LLM work) ──────────
   // Exposed to commands.ts via registerCommands so /pruner now can preview the
   // queue before opening the multi-row progress overlay.
-  // `rethrow` is for the reload rearm probe only (session_start/session_tree):
-  // it needs to observe a rescan failure so it can console.error and leave
-  // rearmedPending false, per spec. Every other caller (turn_end capture path,
+  // `rethrow` is for probeRearm only: it needs to observe a rescan failure so
+  // it can console.error and leave rearmedPending false, per spec. Every
+  // other caller (turn_end capture path,
   // flushPending, /pruner commands) keeps the existing swallow-and-fall-back
   // behavior so a transient getBranch failure there never blocks the turn.
   const capturePendingBatches = (ctx: any, opts?: { rethrow?: boolean }): CapturedBatch[] => {
@@ -200,6 +200,20 @@ export default function (pi: ExtensionAPI) {
     return groupBatchesByMode(batches, currentConfig.value.batchingMode);
   };
 
+  // Arms the one-shot rearm flag when the persisted branch holds un-pruned
+  // tool results the in-memory queue does not know about: after a reload, a
+  // branch switch, or a stretch with pruning disabled (turn_end captures
+  // nothing while disabled). A disabled pruner never arms.
+  const probeRearm = (ctx: any): void => {
+    rearmedPending = false;
+    if (!currentConfig.value.enabled) return;
+    try {
+      rearmedPending = capturePendingBatches(ctx, { rethrow: true }).length > 0;
+    } catch (err) {
+      console.error("pi-condense: reload rearm probe failed", err);
+    }
+  };
+
   // Summarizes + indexes all pending batches.
   // When options.onProgress is provided batches are processed sequentially
   // (one LLM call each) so the caller can update per-row UI. Otherwise all
@@ -817,14 +831,7 @@ export default function (pi: ExtensionAPI) {
     // Clear any batches queued before the session reload
     pendingBatches.length = 0;
     previousFraction = null;
-    rearmedPending = false;
-    if (currentConfig.value.enabled) {
-      try {
-        rearmedPending = capturePendingBatches(ctx, { rethrow: true }).length > 0;
-      } catch (err) {
-        console.error("pi-condense: reload rearm probe failed", err);
-      }
-    }
+    probeRearm(ctx);
 
     // Update footer status
     setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts());
@@ -859,14 +866,7 @@ export default function (pi: ExtensionAPI) {
     // Pending batches belong to the old branch — discard them
     pendingBatches.length = 0;
     previousFraction = null;
-    rearmedPending = false;
-    if (currentConfig.value.enabled) {
-      try {
-        rearmedPending = capturePendingBatches(ctx, { rethrow: true }).length > 0;
-      } catch (err) {
-        console.error("pi-condense: reload rearm probe failed", err);
-      }
-    }
+    probeRearm(ctx);
 
     setPruneStatusWidget(ctx, currentConfig.value, statsAccum.getLiveReclaim(), diagnostics.counts());
   });
@@ -1138,5 +1138,6 @@ export default function (pi: ExtensionAPI) {
     () => diagnostics.counts(),
     (ctx: any) => computeMetricsSnapshot(ctx) ?? EMPTY_METRICS_SNAPSHOT,
     () => rearmedPending,
+    probeRearm,
   );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.15.0",
+  "version": "2.15.1",
   "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/commands.test.ts

@@ -73,6 +73,7 @@ function setupPrunerCommand(overrides: {
     undefined,
     overrides.getContextMetrics,
     overrides.getRearmed,
+    undefined,
     overrides.save,
   );
 

package/src/commands.ts

@@ -477,6 +477,7 @@ export function registerCommands(
   getDiagnosticCounts?: () => Record<DiagnosticKind, number>,
   getContextMetrics?: (ctx: ExtensionCommandContext) => ContextMetricsSnapshot,
   getRearmed?: () => boolean,
+  probeRearm?: (ctx: ExtensionCommandContext) => void,
   save: (config: ContextPruneConfig) => Promise<void> = saveConfig,
 ): void {
   // Register the /pruner command
@@ -856,8 +857,12 @@ export function registerCommands(
 
         // ── /pruner on ──
         case "on": {
+          const wasEnabled = currentConfig.value.enabled;
           currentConfig.value = { ...currentConfig.value, enabled: true };
           void persistConfig((m, t) => ctx.ui.notify(m, t), currentConfig.value, save);
+          // Tool results produced while disabled were never queued; the probe
+          // puts them back in front of the next gate check.
+          if (!wasEnabled) probeRearm?.(ctx);
           ctx.ui.notify("Context pruning enabled.");
           setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;

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

@@ -214,12 +214,13 @@ function bootExtension(
     budgetTurnDelta?: number | null;
     frontierGapThresholdTokens?: number | null;
     showPruneStatusLine?: boolean;
+    enabled?: boolean;
   } = {},
 ) {
   const agentDir = mkdtempSync(join(tmpdir(), "pi-condense-rearm-"));
   process.env.PI_CODING_AGENT_DIR = agentDir;
   const contextPruneSettings: any = {
-    enabled: true,
+    enabled: options.enabled ?? true,
     pruneOn: "agent-message",
     batchingMode: "agent-message",
     autoBudgetThreshold: options.autoBudgetThreshold === undefined ? 0.5 : options.autoBudgetThreshold,
@@ -557,6 +558,24 @@ describe("reload rearm (issue #6)", () => {
     expect(statusCalls).toContain("\u2502 prune: recovered pending (reload)");
   });
 
+it("/pruner on rearms the gate so work recovered from a disabled stretch flushes", async () => {
+  const { handlers, commands, ctx, appended } = await boot({ enabled: false });
+  await handlers.get("session_start")!({}, ctx);
+  const callsBefore = summarizerCalls;
+
+  const budgetTurn = { toolResults: [], message: { role: "assistant", content: [{ type: "text", text: "hi" }] }, turnIndex: 2 };
+  await handlers.get("turn_end")!(budgetTurn, ctx);
+  expect(summarizerCalls).toBe(callsBefore);
+
+  await commands.get("pruner")!("on", ctx);
+  await handlers.get("turn_end")!(budgetTurn, ctx);
+
+  expect(summarizerCalls).toBe(callsBefore + 1);
+  const fm = appended.filter((e) => e.type === "context-prune-flush-metrics");
+  expect(fm.length).toBe(1);
+  expect((fm[0].data as any).trigger).toBe("rearmed");
+});
+
   it("reports a rescan failure to console.error and leaves rearmedPending false, without failing session_start (G4)", async () => {
     // Spec (Component 2, Rescan failure): "if the reload rearm probe throws,
     // console.error ... and leave rearmedPending = false - reload must never