pi-condense 2.11.3 → 2.11.5

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.11.5] - 2026-10-08
+
+### Changed
+
+- `minBatchChars` defaults to 2000 (was 1000): batches under 2,000 raw chars compress to only about 44% of their size when summarized, so they now stay verbatim and skip the summarizer call. Set `contextPrune.minBatchChars` explicitly to keep the old threshold.
+
+## [2.11.4] - 2026-10-08
+
+### Fixed
+
+- The summarizer now sees the first 4,000 and last 4,000 characters of each tool result instead of only the first 2,000, so an error at the end of a test run or the newest rows of a `git log` reach the summary instead of being reported as missing; the prompt tells the model an elided middle is omitted, not empty.
+
 ## [2.11.3] - 2026-10-04
 
 ### Fixed

package/PRUNING.md

@@ -19,6 +19,7 @@
    - [Stub-replace instead of delete](#stub-replace-instead-of-delete)
    - [Protected tools](#protected-tools)
    - [Eager single-result spill](#eager-single-result-spill)
+   - [Summarizer input window](#summarizer-input-window)
    - [Trivial-batch skip (minBatchChars)](#trivial-batch-skip-minbatchchars)
    - [Content-hash dedup](#content-hash-dedup)
    - [Oversized summary skip](#oversized-summary-skip)
@@ -599,7 +600,7 @@ captured batches (from turn_end or session scan)
   │     identical (toolName, normalize(resultText)) → alias of original;
   │     no LLM call; persist as context-prune-dedup-alias
   │
-  ├─ 5. Trivial-batch skip            (config: minBatchChars, default 1000)
+  ├─ 5. Trivial-batch skip            (config: minBatchChars, default 2000)
   │     batches whose remaining raw chars < threshold → skip; no LLM call;
   │     leave originals in context; advance frontier
   │
@@ -668,13 +669,19 @@ Full output: <sidecar path>. Use context_tree_query(<shortRef>) to retrieve.]
 
 **Hybrid storage:** bodies below `spillThreshold` stay inline in the `context-prune-index` session entry (portable, as before); only oversized bodies are spilled. Moving the session `.jsonl` without its `-blobs/` directory loses only the giant-blob recovery path; the stub and head preview remain in the index entry.
 
+### Summarizer input window
+
+Each tool result reaches the summarizer LLM through a fixed head + tail window: results up to 8,000 chars are sent whole; longer ones are sent as their first 4,000 chars, a ` ...[N chars elided]... ` marker, and their last 4,000 chars. The prompt tells the model the elided region was removed, never that it was empty. Results at or above `spillThreshold` are spilled before any summarizer call and never windowed, unless the sidecar write fails; the result then flushes inline and is windowed like any other.
+
+Why a window and not the whole result: summarizer input is paid on every flush, and budget-triggered sessions flush every turn, so an uncapped 64k-char result would cost about 16k tokens per summary and raise the chance of a `length`-stopped, unusable summary. Why head + tail and not head only: the facts a summary most often needs - the error at the end of a test run, the newest rows of a log - sit at the tail. The constants are internal, not settings; the fixed total is the per-result cost ceiling. The indexer keeps the full result; `context_tree_query` is unaffected.
+
 ### Trivial-batch skip (minBatchChars)
 
-`minBatchChars: number` (default `1000`) is a pre-flush guard against "summary would be roughly the same size as the input" cases. If the total raw `resultText` across a batch is below the threshold, the batch is skipped: no summarizer LLM call, no `context-prune-index` entry, no `context-prune-summary` injection. The frontier still advances, so the same tool calls are not reconsidered next flush.
+`minBatchChars: number` (default `2000`) is a pre-flush guard against "summary would be roughly the same size as the input" cases. If the total raw `resultText` across a batch is below the threshold, the batch is skipped: no summarizer LLM call, no `context-prune-index` entry, no `context-prune-summary` injection. The frontier still advances, so the same tool calls are not reconsidered next flush.
 
 Why it exists: a short LLM summary like "Tool X did Y" is itself ~50–150 chars per call. For a 200-byte file read or an `ls` of a short directory, the summary is the same size or larger than the input — the post-call `skipped-oversized` mechanism would catch it anyway, but only after the LLM round-trip and the cost. `minBatchChars` short-circuits the obvious cases at zero LLM cost.
 
-Set `minBatchChars: 0` to disable. The default `1000` skips obvious trivial batches (`git status`, small file reads, short directory listings) without affecting realistic tool outputs. Edit with `/pruner min-batch-chars <n>` or via the settings overlay.
+Set `minBatchChars: 0` to disable. The default `2000` skips obvious trivial batches (`git status`, small file reads, short directory listings) without affecting realistic tool outputs; batches under 2,000 chars compress to only about 44% of their size when summarized (the per-call bullet scaffolding dominates), against about 7% for a typical session, so summarizing them costs an LLM call for little context saved. Edit with `/pruner min-batch-chars <n>` or via the settings overlay.
 
 ### Content-hash dedup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.11.3",
+  "version": "2.11.5",
   "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/batch-capture.test.ts

@@ -58,6 +58,74 @@ describe("serializeBatchForSummarizer", () => {
     expect(result).toContain("[[2:read]] Tool:");
     expect(result).toContain("[[3:write]] Tool:");
   });
+
+  const MARKER = /^ \.\.\.\[(\d+) chars elided\]\.\.\. $/;
+
+  function resultBody(serialized: string): string {
+    const prefix = "Result (OK): ";
+    return serialized.slice(serialized.indexOf(prefix) + prefix.length);
+  }
+
+  test("a result of 8,000 chars serializes whole with no marker", () => {
+    const raw = "a".repeat(8000);
+    const body = resultBody(serializeBatchForSummarizer(batch([toolCall({ resultText: raw })])));
+    expect(body).toBe(raw);
+    expect(body).not.toContain("chars elided");
+  });
+
+  test("a result of 8,001 chars becomes head 4,000 + marker + tail 4,000", () => {
+    const raw = "h".repeat(4000) + "m" + "t".repeat(4000);
+    const body = resultBody(serializeBatchForSummarizer(batch([toolCall({ resultText: raw })])));
+    expect(body).toBe("h".repeat(4000) + " ...[1 chars elided]... " + "t".repeat(4000));
+    expect(body.length).toBe(8024);
+  });
+
+  test("a result of 20,000 chars keeps raw.slice(0, 4000) and raw.slice(16000) around a 12000 marker", () => {
+    const raw = Array.from({ length: 20000 }, (_, i) => String.fromCharCode(97 + (i % 26))).join("");
+    const body = resultBody(serializeBatchForSummarizer(batch([toolCall({ resultText: raw })])));
+    expect(body.startsWith(raw.slice(0, 4000))).toBe(true);
+    expect(body.endsWith(raw.slice(16000))).toBe(true);
+    expect(body).toContain(" ...[12000 chars elided]... ");
+  });
+
+  test("a sentinel in the last 100 chars of a 5,175-char result survives; one at char 10,000 of 20,000 does not", () => {
+    const tailRaw = "x".repeat(5075) + "ERROR_AT_TAIL" + "x".repeat(5175 - 5075 - "ERROR_AT_TAIL".length);
+    expect(tailRaw.length).toBe(5175);
+    expect(serializeBatchForSummarizer(batch([toolCall({ resultText: tailRaw })]))).toContain("ERROR_AT_TAIL");
+
+    const midRaw = "x".repeat(10000) + "MID_SENTINEL" + "x".repeat(20000 - 10000 - "MID_SENTINEL".length);
+    expect(midRaw.length).toBe(20000);
+    expect(serializeBatchForSummarizer(batch([toolCall({ resultText: midRaw })]))).not.toContain("MID_SENTINEL");
+  });
+
+  test("result body equals raw up to 8,000 and head + marker + tail above, for boundary lengths", () => {
+    for (const length of [0, 1, 7999, 8000, 8001, 65535, 1008000]) {
+      const raw = Array.from({ length }, (_, i) => String.fromCharCode(97 + (i % 26))).join("");
+      const body = resultBody(serializeBatchForSummarizer(batch([toolCall({ resultText: raw })])));
+      if (length <= 8000) {
+        expect(body).toBe(raw);
+      } else {
+        const marker = ` ...[${length - 8000} chars elided]... `;
+        expect(marker).toMatch(MARKER);
+        expect(body).toBe(raw.slice(0, 4000) + marker + raw.slice(-4000));
+        expect(body.length - raw.length).toBeLessThanOrEqual(marker.length);
+        expect(body.length).toBe(8000 + 23 + String(length - 8000).length);
+      }
+    }
+  });
+
+  test("labels and Tool: lines are unchanged for windowed results", () => {
+    const b = batch([
+      toolCall({ toolCallId: "a", toolName: "read", resultText: "r".repeat(9000) }),
+      toolCall({ toolCallId: "b", toolName: "bash", resultText: "s".repeat(9000) }),
+    ]);
+
+    const result = serializeBatchForSummarizer(b);
+
+    expect(result).toContain("[[1:read]] Tool: read(");
+    expect(result).toContain("[[2:bash]] Tool: bash(");
+    expect(result.match(/chars elided/g)?.length).toBe(2);
+  });
 });
 
 describe("occurrence capture", () => {
@@ -316,10 +384,10 @@ describe("image markers", () => {
     expect(imageMarkerDigests("no markers here")).toEqual([]);
   });
 
-  test("a result with >2,000 text chars plus an image keeps the marker in the summarizer input", () => {
+  test("a result with >8,000 text chars plus an image keeps the marker in the summarizer input", () => {
     const message = { role: "assistant", content: [{ type: "toolCall", id: "r1", name: "read", input: { path: "a.png" } }], timestamp: 1 };
     const results = [
-      { role: "toolResult", toolCallId: "r1", toolName: "read", content: [{ type: "text", text: "x".repeat(5000) }, img("AAAA")], isError: false, timestamp: 2 },
+      { role: "toolResult", toolCallId: "r1", toolName: "read", content: [{ type: "text", text: "x".repeat(9000) }, img("AAAA")], isError: false, timestamp: 2 },
     ];
     const out = serializeBatchForSummarizer(captureBatch(message, results, 0, 9999));
     expect(out).toContain(`[image returned: image/png sha256:${imageDigest("AAAA")}]`);

package/src/batch-capture.ts

@@ -57,8 +57,8 @@ export function imageMarkerDigests(text: string): string[] {
 
 /**
  * Joins a ToolResultMessage's content into one string: one marker line per
- * image block, then the text blocks. Markers lead because the summarizer
- * input keeps only the first 2,000 result chars.
+ * image block, then the text blocks. Markers lead so they survive the
+ * summarizer's head + tail window.
  */
 export function extractToolResultText(msg: any): string {
   const content: any[] = Array.isArray(msg?.content) ? msg.content : [];
@@ -218,6 +218,10 @@ export function captureUnindexedBatchesFromSession(
   return batches;
 }
 
+// Fixed, not a setting: the 8,000-char total is the per-result ceiling on summarizer input.
+const HEAD_CHARS = 4000;
+const TAIL_CHARS = 4000;
+
 /** Serializes a single CapturedBatch into readable text for the summarizer LLM. */
 export function serializeBatchForSummarizer(batch: CapturedBatch): string {
   const parts: string[] = [];
@@ -231,10 +235,9 @@ export function serializeBatchForSummarizer(batch: CapturedBatch): string {
     const argsJson = JSON.stringify(tc.args, null, 2);
 
     let resultText = tc.resultText;
-    const MAX_CHARS = 2000;
-    if (resultText.length > MAX_CHARS) {
-      const remaining = resultText.length - MAX_CHARS;
-      resultText = resultText.slice(0, MAX_CHARS) + ` ...[${remaining} chars truncated]`;
+    if (resultText.length > HEAD_CHARS + TAIL_CHARS) {
+      const elided = resultText.length - HEAD_CHARS - TAIL_CHARS;
+      resultText = `${resultText.slice(0, HEAD_CHARS)} ...[${elided} chars elided]... ${resultText.slice(-TAIL_CHARS)}`;
     }
 
     return `[[${index + 1}:${tc.toolName}]] Tool: ${tc.toolName}(${argsJson})\nResult (${status}): ${resultText}`;

package/src/commands.ts

@@ -591,7 +591,7 @@ export function registerCommands(
               values: MIN_BATCH_CHARS_PRESETS.map((p) => p.value),
               currentValue: MIN_BATCH_CHARS_PRESETS.some((p) => p.value === String(config.minBatchChars))
                 ? String(config.minBatchChars)
-                : MIN_BATCH_CHARS_PRESETS[2].value, // fall back to "1000" if a custom value isn't in the preset cycle
+                : MIN_BATCH_CHARS_PRESETS[3].value, // fall back to "2000" if a custom value isn't in the preset cycle
               description: minBatchCharsDescription(config),
             },
             {

package/src/summarizer.test.ts

@@ -58,4 +58,27 @@ describe("summarizer prompt", () => {
     await summarizeBatch(batch, DEFAULT_CONFIG, ctx);
     expect(JSON.stringify(seenInput)).toContain("means the tool returned an image you cannot see");
   });
+
+  it("tells the model that an elided middle is omitted, not empty", async () => {
+    const model = { id: "m", provider: "p", name: "M" };
+    const ctx = {
+      model,
+      modelRegistry: {
+        find: () => model,
+        getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
+        getProviderAuth: async () => undefined,
+      },
+      ui: { notify() {} },
+    } as any;
+    const batch = {
+      turnIndex: 0,
+      timestamp: 0,
+      assistantText: "",
+      toolCalls: [{ toolCallId: "a", toolName: "bash", args: {}, resultText: "x".repeat(9000), isError: false }],
+    } as any;
+    await summarizeBatch(batch, DEFAULT_CONFIG, ctx);
+    const sent = JSON.stringify(seenInput);
+    expect(sent).toContain("chars elided");
+    expect(sent).toContain("never report the elided region as empty or absent");
+  });
 });

package/src/summarizer.ts

@@ -22,6 +22,8 @@ Keep each tool call to 1-3 bullet points. Skip calls that succeeded with nothing
 
 A result line of the form [image returned: <type> sha256:<hash>] means the tool returned an image you cannot see: state that an image was returned, and never describe or guess its content.
 
+A result containing " ...[N chars elided]... " had its middle removed before you saw it: summarize the head and tail you can see, and never report the elided region as empty or absent.
+
 Begin the first bullet of each tool call with that tool's [[N:toolname]] label, copied verbatim (both the number and the name) from its line in the input, as the plain, first thing on the line - no bold, backticks, or list numbering around it. Do not renumber, rename, or invent labels; if you skip a tool, skip its label too.`;
 
 const RANGE_SYSTEM_PROMPT = `You are fusing several per-step summaries of one CLOSED sub-task from an AI coding assistant's history into a SINGLE cohesive summary.

package/src/types.ts

@@ -194,8 +194,8 @@ export const ROLLING_WINDOW_PRESETS: { value: string; label: string }[] = [
 export const MIN_BATCH_CHARS_PRESETS: { value: string; label: string }[] = [
   { value: "0", label: "0 (disabled)" },
   { value: "500", label: "500" },
-  { value: "1000", label: "1000 (default)" },
-  { value: "2000", label: "2000" },
+  { value: "1000", label: "1000" },
+  { value: "2000", label: "2000 (default)" },
   { value: "5000", label: "5000" },
 ];
 
@@ -567,7 +567,7 @@ export const DEFAULT_CONFIG: ContextPruneConfig = {
   pruneOn: "agent-message",
   batchingMode: "turn",
   quietOversizedSkips: false,
-  minBatchChars: 1000,
+  minBatchChars: 2000,
   recoveryGraceTurns: 3,
   summarizerIdleTimeoutMs: 20000,
   summarizerMaxTimeoutMs: 180000,