pi-condense 2.11.2 → 2.11.4

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.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
+
+- Error purge keeps a failed tool call's argument keys, types, and array lengths and shrinks only strings over 200 characters, so grammar-constrained tools such as `codemode` no longer fail every later request with `Grammar tool call "codemode" requires argument "code" to be a string` after a purge. (#19)
+
 ## [2.11.2] - 2026-09-29
 
 ### 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)
@@ -668,6 +669,12 @@ 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.
@@ -1096,23 +1103,26 @@ Short refs (`tN`) always resolve 1:1 - one ref, one record - and are the primary
 
 Failed tool calls often embed large argument bodies in the assistant message — a `write` call with a 30 KB file body, an `edit` call with a multiline diff. The error result is small (e.g. `"Error: file not found"`), but the original `arguments` stay in the assistant turn indefinitely.
 
-Error purge replaces those arg bodies with compact stubs after the error has cooled down:
+Error purge shrinks the large string values inside those argument bodies after the error has cooled down. Every key, JSON type, and array length survives; only strings longer than 200 characters (`PURGE_STRING_MIN_CHARS` in `src/error-purge.ts`, not configurable) become a placeholder carrying the original length:
 
 ```
-{ "_purged": "<purged-errored-args size=\"N\"/>" }
+{ "path": "src/foo.ts", "content": "<purged-errored-args size=\"30000\"/>" }
 ```
 
+Providers validate replayed tool calls against the declared schema - pi-ai's grammar-constrained tools (`codemode`) require the input property to be a string - so the shape must stay intact. The 200-character floor keeps `path`, a short `command`, or a small `newText` readable; it is a constant because nobody has a reason to tune a readability guard.
+
 **What triggers a purge:**
 
 - The matching `ToolResultMessage` has `isError: true`.
 - The error occurred at least `purgeErrors.cooldownTurns` assistant turns ago (default 2). The cooldown gives the model 1–2 turns to retry before context is mutated.
-- The JSON-stringified argument body is at least `purgeErrors.minArgChars` characters long (default 500). Small args are not worth the substitution.
+- The JSON-stringified argument body is at least `purgeErrors.minArgChars` characters long (default 500). Small args are not worth the substitution. A body that qualifies but holds no string over 200 characters is returned unchanged.
 
 **What error purge does NOT touch:**
 
 - The `ToolResultMessage` content — the error message stays visible so the model can see what went wrong.
 - Non-errored `toolCall` argument bodies.
 - Argument bodies below `minArgChars`.
+- Keys, non-string values, array lengths, and strings of 200 characters or fewer inside a purged body.
 - Anything when `purgeErrors.enabled` is `false`.
 
 **Transform position:** Error purge runs in Phase 2, after stub-replace and before chain range prune.
@@ -1127,7 +1137,7 @@ Error purge replaces those arg bodies with compact stubs after the error has coo
 |---|---|---|
 | `purgeErrors.enabled` | `true` | Master toggle |
 | `purgeErrors.cooldownTurns` | `2` | Turns to wait after error before purging |
-| `purgeErrors.minArgChars` | `500` | Minimum argument body size to purge |
+| `purgeErrors.minArgChars` | `500` | Minimum JSON body size for a failed call to be scanned; only strings over 200 chars inside it are replaced |
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.11.2",
+  "version": "2.11.4",
   "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

@@ -675,7 +675,7 @@ export function registerCommands(
               label: "Error purge",
               values: ["true", "false"],
               currentValue: String(config.purgeErrors.enabled),
-              description: `Replace failed toolCall argument bodies with compact stubs after a cooldown. Reclaims context from large write/edit args that will never succeed. Currently ${config.purgeErrors.enabled ? "ON" : "OFF"}.`,
+              description: `Shrink long strings inside failed toolCall arguments after a cooldown, keeping argument shape. Reclaims context from large write/edit args that will never succeed. Currently ${config.purgeErrors.enabled ? "ON" : "OFF"}.`,
             },
             {
               id: "purgeErrorsCooldown",

package/src/error-purge.test.ts

@@ -8,6 +8,9 @@ const defaultConfig: ErrorPurgeConfig = {
   minArgChars: 10,
 };
 
+const LONG = "x".repeat(300);
+const PLACEHOLDER_RE = /^<purged-errored-args size="\d+"\/>$/;
+
 function makeAssistant(toolCallId: string, argsObj: Record<string, any>, turnN?: number) {
   return {
     role: "assistant",
@@ -47,7 +50,7 @@ describe("purgeErroredArgs", () => {
   it("does not purge while still within cooldown", () => {
     // Error at turn 1, current = turn 2, age = 1 < cooldownTurns 2
     const messages = [
-      makeAssistant("tc1", { content: "a very long argument body here" }),
+      makeAssistant("tc1", { content: LONG }),
       makeToolResult("tc1", true),
       makeAssistant("tc2", { cmd: "ls" }),
       makeToolResult("tc2", false),
@@ -55,11 +58,11 @@ describe("purgeErroredArgs", () => {
     const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2 });
     expect(result).toBe(messages);
     const asstMsg = result[0] as any;
-    expect(asstMsg.content[0].arguments).toEqual({ content: "a very long argument body here" });
+    expect(asstMsg.content[0].arguments).toEqual({ content: LONG });
   });
 
   it("purges args after cooldown when args meet minArgChars", () => {
-    const largeArgs = { content: "a very long argument body here" };
+    const largeArgs = { content: LONG };
     const messages = [
       makeAssistant("tc1", largeArgs),
       makeToolResult("tc1", true),
@@ -71,9 +74,8 @@ describe("purgeErroredArgs", () => {
     const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 10 });
     expect(result).not.toBe(messages);
     const purgedAsst = result[0] as any;
-    const originalArgLen = JSON.stringify(largeArgs).length;
     expect(purgedAsst.content[0].arguments).toEqual({
-      _purged: `<purged-errored-args size="${originalArgLen}"/>`,
+      content: `<purged-errored-args size="${LONG.length}"/>`,
     });
     // toolResult stays unchanged
     expect((result[1] as any).content[0].text).toBe("Error: file not found");
@@ -81,7 +83,7 @@ describe("purgeErroredArgs", () => {
 
   it("does not purge when args are below minArgChars", () => {
     const messages = [
-      makeAssistant("tc1", { x: "hi" }), // JSON is only ~10 chars
+      makeAssistant("tc1", { x: LONG }),
       makeToolResult("tc1", true),
       makeAssistant("tc2", { cmd: "ls" }),
       makeToolResult("tc2", false),
@@ -94,7 +96,7 @@ describe("purgeErroredArgs", () => {
 
   it("does not purge when isError is false", () => {
     const messages = [
-      makeAssistant("tc1", { content: "a very long argument body here" }),
+      makeAssistant("tc1", { content: LONG }),
       makeToolResult("tc1", false), // NOT an error
       makeAssistant("tc2", { cmd: "ls" }),
       makeToolResult("tc2", false),
@@ -106,7 +108,7 @@ describe("purgeErroredArgs", () => {
   });
 
   it("only purges errored toolCalls in a multi-toolCall assistant message", () => {
-    const largeArgs = { content: "a very long argument body here that is big" };
+    const largeArgs = { content: LONG };
     const okArgs = { cmd: "ls" };
     const messages = [
       // One assistant with two toolCalls: tc-err is errored, tc-ok is not
@@ -129,16 +131,15 @@ describe("purgeErroredArgs", () => {
     expect(result).not.toBe(messages);
     const asst = result[0] as any;
     // errored one is purged
-    const originalArgLen = JSON.stringify(largeArgs).length;
     expect(asst.content[0].arguments).toEqual({
-      _purged: `<purged-errored-args size="${originalArgLen}"/>`,
+      content: `<purged-errored-args size="${LONG.length}"/>`,
     });
     // non-errored one is untouched
     expect(asst.content[1].arguments).toEqual(okArgs);
   });
 
   it("does not mutate the input messages array or any message object", () => {
-    const largeArgs = { content: "a very long argument body here" };
+    const largeArgs = { content: LONG };
     const messages = [
       makeAssistant("tc1", largeArgs),
       makeToolResult("tc1", true),
@@ -156,8 +157,8 @@ describe("purgeErroredArgs", () => {
   });
 
   it("exactly-at-cooldown boundary: age === cooldownTurns is purged", () => {
-    // Error at turn 1, 2 more assistant turns → age = 2 = cooldownTurns (should purge)
-    const largeArgs = { content: "argument body that is long enough to purge" };
+    // Error at turn 1, 2 more assistant turns -> age = 2 = cooldownTurns (should purge)
+    const largeArgs = { content: LONG };
     const messages = [
       makeAssistant("tc1", largeArgs),
       makeToolResult("tc1", true),
@@ -168,12 +169,12 @@ describe("purgeErroredArgs", () => {
     ];
     const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 5 });
     expect(result).not.toBe(messages);
-    expect((result[0] as any).content[0].arguments._purged).toBeDefined();
+    expect((result[0] as any).content[0].arguments.content).toMatch(PLACEHOLDER_RE);
   });
 
   it("one-below-cooldown boundary: age === cooldownTurns - 1 is NOT purged", () => {
-    // Error at turn 1, 1 more assistant turn → age = 1 < cooldownTurns 2
-    const largeArgs = { content: "argument body that is long enough to purge" };
+    // Error at turn 1, 1 more assistant turn -> age = 1 < cooldownTurns 2
+    const largeArgs = { content: LONG };
     const messages = [
       makeAssistant("tc1", largeArgs),
       makeToolResult("tc1", true),
@@ -183,4 +184,90 @@ describe("purgeErroredArgs", () => {
     const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 5 });
     expect(result).toBe(messages);
   });
+
+  function purgedAfterCooldown(args: Record<string, any>, name: string, minArgChars: number) {
+    const messages = [
+      { ...makeAssistant("tc1", args), content: [{ type: "toolCall", id: "tc1", name, arguments: args }] },
+      { ...makeToolResult("tc1", true), toolName: name },
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+      makeAssistant("tc3", { cmd: "pwd" }),
+      makeToolResult("tc3", false),
+    ];
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars });
+    return { messages, result, args: (result[0] as any).content[0].arguments };
+  }
+
+  it("keeps a grammar tool's input property a string (codemode, #19)", () => {
+    const { messages, result, args } = purgedAfterCooldown({ code: "x".repeat(1000) }, "codemode", 500);
+    expect(result).not.toBe(messages);
+    expect(typeof args.code).toBe("string");
+    expect(Object.keys(args)).toEqual(["code"]);
+    expect(args.code).toBe('<purged-errored-args size="1000"/>');
+    expect(JSON.stringify(args).length).toBeLessThan(500);
+  });
+
+  it("write-shaped call keeps path verbatim and shrinks content", () => {
+    const { args } = purgedAfterCooldown({ path: "src/foo.ts", content: "x".repeat(30000) }, "write", 500);
+    expect(args.path).toBe("src/foo.ts");
+    expect(args.content).toBe('<purged-errored-args size="30000"/>');
+    expect(JSON.stringify(args).length).toBeLessThan(100);
+  });
+
+  it("edit-shaped call keeps the edits array length and shrinks only long values", () => {
+    const original = {
+      path: "src/foo.ts",
+      edits: [
+        { oldText: "a".repeat(15000), newText: "x" },
+        { oldText: "y", newText: "b".repeat(15000) },
+      ],
+    };
+    const { args } = purgedAfterCooldown(original, "edit", 500);
+    expect(args.path).toBe("src/foo.ts");
+    expect(Array.isArray(args.edits)).toBe(true);
+    expect(args.edits).toHaveLength(2);
+    expect(args.edits[0]).toEqual({ oldText: '<purged-errored-args size="15000"/>', newText: "x" });
+    expect(args.edits[1]).toEqual({ oldText: "y", newText: '<purged-errored-args size="15000"/>' });
+    expect(JSON.stringify(args).length).toBeLessThan(500);
+  });
+
+  it("non-string scalars and short strings pass through by type", () => {
+    const { args } = purgedAfterCooldown({ line: 42, force: true, z: null, s: "short", big: "x".repeat(201) }, "bash", 10);
+    expect(args.line).toBe(42);
+    expect(args.force).toBe(true);
+    expect(args.z).toBeNull();
+    expect(args.s).toBe("short");
+    expect(args.big).toBe('<purged-errored-args size="201"/>');
+  });
+
+  it("a string of exactly 200 chars stays verbatim", () => {
+    const { messages, result } = purgedAfterCooldown({ s: "x".repeat(200) }, "bash", 10);
+    expect(result).toBe(messages);
+  });
+
+  it("eligible body made only of short strings is returned by identity", () => {
+    const original: Record<string, string> = {};
+    for (let i = 0; i < 600; i++) original[`k${i}`] = "v";
+    const { messages, result } = purgedAfterCooldown(original, "bash", 500);
+    expect(result).toBe(messages);
+  });
+
+  it("a second pass over purged output returns the same reference", () => {
+    const { result } = purgedAfterCooldown({ path: "src/foo.ts", content: "x".repeat(1000) }, "write", 10);
+    expect(purgeErroredArgs(result, { ...defaultConfig, cooldownTurns: 2, minArgChars: 10 })).toBe(result);
+  });
+
+  it("preserves own JSON keys even when a key is __proto__", () => {
+    const original = JSON.parse(`{"__proto__":"${LONG}","content":"${LONG}"}`);
+    const { args } = purgedAfterCooldown(original, "write", 10);
+    expect(Object.keys(args)).toEqual(Object.keys(original));
+    expect(args.__proto__).toBe('<purged-errored-args size="300"/>');
+  });
+
+  it("never mutates the original nested arguments", () => {
+    const original = { path: "src/foo.ts", edits: [{ oldText: "a".repeat(300), newText: "x" }] };
+    const snapshot = structuredClone(original);
+    purgedAfterCooldown(original, "edit", 10);
+    expect(original).toEqual(snapshot);
+  });
 });

package/src/error-purge.transport.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "bun:test";
+import { getGrammarToolInput } from "@earendil-works/pi-ai/api/constrained-sampling";
+import { stream } from "@earendil-works/pi-ai/api/openai-completions";
+import type { Model, Tool } from "@earendil-works/pi-ai";
+import { purgeErroredArgs } from "./error-purge.js";
+
+// Chat Completions and Responses share getGrammarToolInput; one transport covers the throw.
+const model: Model<"openai-completions"> = {
+  id: "grammar-test",
+  name: "grammar-test",
+  api: "openai-completions",
+  provider: "openai",
+  baseUrl: "http://127.0.0.1:9",
+  reasoning: false,
+  input: ["text"],
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  contextWindow: 128000,
+  maxTokens: 4096,
+  compat: { supportsOpenAIGrammarTools: true },
+};
+
+const codemode: Tool = {
+  name: "codemode",
+  description: "run code",
+  parameters: {
+    type: "object",
+    properties: { code: { type: "string" } },
+    required: ["code"],
+  } as any,
+  constrainedSampling: { type: "grammar", variants: { openai_lark: 'start: /[\\s\\S]*/' } },
+};
+
+const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+const meta = { api: "openai-completions", provider: "openai", model: "grammar-test", usage };
+
+function history(codeArgs: Record<string, unknown>) {
+  return [
+    { role: "user", content: "run it", timestamp: 1 },
+    { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "codemode", arguments: codeArgs }], ...meta, stopReason: "toolUse", timestamp: 2 },
+    { role: "toolResult", toolCallId: "tc1", toolName: "codemode", content: [{ type: "text", text: "Error: boom" }], isError: true, timestamp: 3 },
+    { role: "assistant", content: [{ type: "text", text: "retrying" }], ...meta, stopReason: "stop", timestamp: 4 },
+    { role: "user", content: "again", timestamp: 5 },
+    { role: "assistant", content: [{ type: "text", text: "ok" }], ...meta, stopReason: "stop", timestamp: 6 },
+    { role: "user", content: "go", timestamp: 7 },
+  ] as any[];
+}
+
+async function request(messages: any[]) {
+  let calls = 0;
+  const fetchStub = (async () => {
+    calls++;
+    throw new Error("connection refused by stub");
+  }) as unknown as typeof fetch;
+  const result = await stream(model, { messages, tools: [codemode] }, { apiKey: "test", fetch: fetchStub, maxRetries: 0 }).result();
+  return { result, calls };
+}
+
+describe("error purge x pi-ai grammar tools (#19)", () => {
+  const config = { enabled: true, cooldownTurns: 2, minArgChars: 500 };
+
+  it("purged codemode args pass getGrammarToolInput (reporter repro)", () => {
+    const purged = purgeErroredArgs(history({ code: "x".repeat(1000) }), config);
+    const args = purged[1].content[0].arguments;
+    expect(typeof args.code).toBe("string");
+    expect(Object.keys(args)).toEqual(["code"]);
+    expect(JSON.stringify(args).length).toBeLessThan(500);
+    expect(() => getGrammarToolInput("codemode", args, "code")).not.toThrow();
+  });
+
+  it("request building succeeds on purged history; failure is the connection, not the grammar", async () => {
+    const purged = purgeErroredArgs(history({ code: "x".repeat(1000) }), config);
+    expect(purged[1].content[0].arguments.code).toMatch(/^<purged-errored-args size=/);
+    const { result, calls } = await request(purged);
+    expect(result.stopReason).toBe("error");
+    // The OpenAI SDK wraps fetch rejections in APIConnectionError and drops the cause message.
+    expect(result.errorMessage).toMatch(/Connection error/);
+    expect(result.errorMessage).not.toMatch(/Grammar tool call/);
+    expect(calls).toBe(1);
+  });
+
+  it("negative control: the old { _purged } shape throws the grammar error before any request", async () => {
+    const legacy = history({ code: "x".repeat(1000) });
+    legacy[1].content[0].arguments = { _purged: '<purged-errored-args size="1012"/>' };
+    const { result, calls } = await request(legacy);
+    expect(result.stopReason).toBe("error");
+    expect(result.errorMessage).toMatch(/Grammar tool call "codemode" requires argument "code" to be a string/);
+    expect(calls).toBe(0);
+  });
+});

package/src/error-purge.ts

@@ -1,8 +1,42 @@
 import type { ErrorPurgeConfig } from "./types.js";
 
+// Keep short paths and commands readable while reclaiming large failed-call bodies.
+const PURGE_STRING_MIN_CHARS = 200;
+
+function shrinkStrings(value: unknown): [unknown, boolean] {
+  if (typeof value === "string") {
+    if (value.length > PURGE_STRING_MIN_CHARS) return [`<purged-errored-args size="${value.length}"/>`, true];
+    return [value, false];
+  }
+  if (Array.isArray(value)) {
+    let out: unknown[] | undefined;
+    for (let i = 0; i < value.length; i++) {
+      const [next, changed] = shrinkStrings(value[i]);
+      if (!changed) continue;
+      out ??= value.slice();
+      out[i] = next;
+    }
+    return out ? [out, true] : [value, false];
+  }
+  if (value !== null && typeof value === "object") {
+    const object = value as Record<string, unknown>;
+    let out: Record<string, unknown> | undefined;
+    for (const key of Object.keys(object)) {
+      const [next, changed] = shrinkStrings(object[key]);
+      if (!changed) continue;
+      // Spread creates own data properties, including JSON's possible __proto__ key.
+      out ??= { ...object };
+      out[key] = next;
+    }
+    return out ? [out, true] : [value, false];
+  }
+  return [value, false];
+}
+
 /**
- * Replaces the `arguments` body of failed toolCall blocks with a compact stub
- * once the error is old enough to be beyond the cooldown window.
+ * Shrinks long strings in failed toolCall arguments after the cooldown window.
+ * Keys and JSON types must survive because pi-ai validates grammar-tool input
+ * properties when replaying calls.
  *
  * Why only the arguments, not the whole toolCall or its toolResult:
  *   - The toolResult content (e.g. "Error: file not found") is small and carries
@@ -58,8 +92,11 @@ export function purgeErroredArgs(messages: any[], config: ErrorPurgeConfig): any
       const argBody = JSON.stringify(block.arguments);
       if (argBody.length < config.minArgChars) return block;
 
+      const [shrunk, changed] = shrinkStrings(block.arguments);
+      if (!changed) return block;
+
       contentModified = true;
-      return { ...block, arguments: { _purged: `<purged-errored-args size="${argBody.length}"/>` } };
+      return { ...block, arguments: shrunk };
     });
 
     if (!contentModified) return msg;

package/src/pruner.test.ts

@@ -278,7 +278,7 @@ describe("pruneMessages", () => {
 
   it("purges errored toolCall args through errorPurge wiring", () => {
     const indexer = makeMockIndexer();
-    const largeArgs = { content: "x".repeat(200) };
+    const largeArgs = { path: "src/foo.ts", content: "x".repeat(300) };
     const messages: any[] = [
       {
         role: "assistant",
@@ -344,7 +344,8 @@ describe("pruneMessages", () => {
     expect(pruned).toBe(true);
     const errAsst = out.find((m: any) => m.role === "assistant" && m.timestamp === 100) as any;
     expect(errAsst).toBeDefined();
-    expect(errAsst.content[0].arguments._purged).toMatch(/^<purged-errored-args size=/);
+    expect(errAsst.content[0].arguments.path).toBe("src/foo.ts");
+    expect(errAsst.content[0].arguments.content).toMatch(/^<purged-errored-args size=/);
   });
 
   it("spill stub tolerates absent spillBytes/resultPreview", () => {
@@ -1009,7 +1010,7 @@ describe("G4/C3: orphan-sweep zero-fire proof across pruner fixtures", () => {
     }],
     ["purges errored toolCall args through errorPurge wiring", () => {
       const indexer = makeMockIndexer();
-      const largeArgs = { content: "x".repeat(200) };
+      const largeArgs = { path: "src/foo.ts", content: "x".repeat(300) };
       const messages: any[] = [
         { role: "assistant", content: [{ type: "toolCall", id: "tc-err", name: "write", arguments: largeArgs }], timestamp: 100, usage: {}, stopReason: "tool_use" },
         { role: "toolResult", toolCallId: "tc-err", toolName: "write", content: [{ type: "text", text: "Error: permission denied" }], isError: true, timestamp: 110 },

package/src/pruner.ts

@@ -155,7 +155,7 @@ export function pruneMessages(
     }
   }
 
-  // Phase 2: error purge — replace failed toolCall arg bodies after cooldown
+  // Phase 2: error purge - shrink long strings in failed toolCall args after cooldown
   if (errorPurge?.enabled) {
     const afterPurge = purgeErroredArgs(current, errorPurge);
     if (afterPurge !== current) {

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.