pi-condense 2.14.0 → 2.15.1

package/CHANGELOG.md

@@ -7,6 +7,18 @@ 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
+
+- pi-condense treats sessions without a UI (`pi -p`, `--mode json`, an SDK host with no UI context) as single-prompt and skips the final `agent-message` flush: a single-prompt print child has no later call to read the pruned context. Multi-message print runs and headless SDK hosts still rely on budget, delta, and frontier-gap flushes at `turn_end` (`autoBudgetThreshold`, `budgetTurnDelta`, `frontierGapThresholdTokens`); pending work stays recoverable through the reload rearm. (#29)
+
 ## [2.14.0] - 2026-11-08
 
 ### Changed

package/PRUNING.md

@@ -975,7 +975,7 @@ Any other outcome - zero or multiple matches on either boundary, `finalAssistant
 - With K=3: the three most-recently-closed chains stay as-is; the fourth triggers compression of the oldest. Exactly K closed chains are kept raw (the open/live chain is never counted).
 - `/pruner compact` bypasses the window and compresses every eligible chain immediately (retroactive).
 
-**Closing-message threading.** In agent-message mode the flush runs from `message_end`, which pi emits to extensions *before* it persists the message to the session (`agent-session.js` runs `_emitExtensionEvent` ahead of `sessionManager.appendMessage`). So at flush time `getBranch()` is missing the just-closed final assistant, and the newest chain would read as open — over-retaining by one (effective K+1). `index.ts` threads the triggering `event.message` through `FlushOptions.closingMessage` into `withClosingMessage` so the chain closes and the window is exactly K.
+**Closing-message threading.** pi-condense treats `ctx.hasUI === false` sessions (`pi -p`, `--mode json`, an SDK host with no UI context) as single-prompt and skips the final agent-message flush: a single-prompt print child has no later call to read the pruned context. Multi-message print runs and headless SDK hosts still rely on the `turn_end` budget/delta/frontier-gap triggers (`autoBudgetThreshold`, `budgetTurnDelta`, `frontierGapThresholdTokens`) for pruning. In sessions with a UI, the agent-message flush runs from `message_end`, which pi emits to extensions *before* it persists the message to the session (`agent-session.js` runs `_emitExtensionEvent` ahead of `sessionManager.appendMessage`). So at flush time `getBranch()` is missing the just-closed final assistant, and the newest chain would read as open - over-retaining by one (effective K+1). `index.ts` threads the triggering `event.message` through `FlushOptions.closingMessage` into `withClosingMessage` so the chain closes and the window is exactly K.
 
 ### Synthetic message format
 
@@ -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/README.md

@@ -69,7 +69,7 @@ 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.
+pi-condense treats a session without a UI (`pi -p`, `--mode json`, an SDK host with no UI context) as single-prompt and skips the final `agent-message` flush there: for a single-prompt `-p` / `--mode json` child, nothing reads the pruned context afterwards. A multi-message print run or a headless SDK host that wants its final messages pruned still relies on the `turn_end` budget/delta/frontier-gap flushes: set `autoBudgetThreshold` (e.g. `0.8`), `budgetTurnDelta`, or `frontierGapThresholdTokens` to enable them. Pending work stays recoverable through the reload rearm if the session is resumed.
 
 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).
 

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());
   });
@@ -1021,9 +1021,13 @@ export default function (pi: ExtensionAPI) {
   // finished using the raw tool results. flushPending captures the SessionManager
   // before awaiting summarization so print-mode shutdown cannot invalidate the
   // persistence path while the summarizer model is running.
+  //
+  // No-UI sessions are treated as single-prompt to avoid a final prune print children never read.
+  // Multi-prompt print/SDK hosts rely on turn_end budget/delta/frontier-gap triggers instead.
   pi.on("message_end", async (event, ctx) => {
     if (!currentConfig.value.enabled) return;
     if (currentConfig.value.pruneOn !== "agent-message") return;
+    if (ctx.hasUI === false) return;
     if (!isFinalAssistantMessage(event.message)) return;
     await flushPending(ctx, { delivery: "session", closingMessage: event.message, trigger: "message-end" });
   });
@@ -1134,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.14.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
@@ -1777,3 +1796,53 @@ describe("session-wide live turn index (#16)", () => {
     expect((fm[0].data as any).trigger).toBe("frontier-gap");
   });
 });
+
+describe("final agent-message flush in sessions without a UI (#29)", () => {
+  const finalReply = { message: { role: "assistant", content: [{ type: "text", text: "done" }] } };
+
+  it("skips the message-end flush when ctx.hasUI is false", async () => {
+    const branch: any[] = [];
+    const { handlers, ctx, appended } = await boot({ branch, autoBudgetThreshold: null, budgetTurnDelta: null });
+    ctx.hasUI = false;
+    ctx.getContextUsage = () => ({ tokens: 10, contextWindow: 1000000 });
+    await handlers.get("session_start")!({}, ctx);
+    const callsBefore = summarizerCalls;
+
+    await fireTurn(handlers, ctx, branch, "tc-p", "p".repeat(800), 0);
+    await handlers.get("message_end")!(finalReply, ctx);
+
+    expect(summarizerCalls).toBe(callsBefore);
+    expect(appended.some((e) => e.type === "context-prune-flush-metrics")).toBe(false);
+    expect(appended.some((e) => e.type === "context-prune-summary")).toBe(false);
+  });
+
+  it("still flushes mid-prompt on the turn_end budget trigger when ctx.hasUI is false", async () => {
+    const branch: any[] = [];
+    const { handlers, ctx, appended } = await boot({ branch });
+    ctx.hasUI = false;
+    await handlers.get("session_start")!({}, ctx);
+
+    await fireTurn(handlers, ctx, branch, "tc-b", "b".repeat(800), 0);
+
+    const fm = appended.filter((e) => e.type === "context-prune-flush-metrics");
+    expect(fm.length).toBe(1);
+    expect((fm[0].data as any).trigger).toBe("budget");
+    expect((fm[0].data as any).outcome).toBe("summarized");
+  });
+
+  it("flushes on the final assistant message when ctx.hasUI is true", async () => {
+    const branch: any[] = [];
+    const { handlers, ctx, appended } = await boot({ branch, autoBudgetThreshold: null, budgetTurnDelta: null });
+    ctx.hasUI = true;
+    ctx.getContextUsage = () => ({ tokens: 10, contextWindow: 1000000 });
+    await handlers.get("session_start")!({}, ctx);
+
+    await fireTurn(handlers, ctx, branch, "tc-u", "u".repeat(800), 0);
+    await handlers.get("message_end")!(finalReply, ctx);
+
+    const fm = appended.filter((e) => e.type === "context-prune-flush-metrics");
+    expect(fm.length).toBe(1);
+    expect((fm[0].data as any).trigger).toBe("message-end");
+    expect((fm[0].data as any).outcome).toBe("summarized");
+  });
+});