pi-condense 2.11.5 → 2.13.0

package/CHANGELOG.md

@@ -7,6 +7,28 @@ 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.13.0] - 2026-10-20
+
+### Changed
+
+- Argument purge shrinks long string arguments of indexed, summarized calls in the same render that stubs their results; `context_tree_query` recovers the stored arguments and result. Dedup aliases keep their own arguments because only canonical arguments are indexed. The existing `purgeErrors` toggle and size gate cover both summarized and errored calls; cooldown remains error-only.
+
+### Fixed
+
+- Protected reads now supersede earlier reads of the same normalized path only when their delivered line ranges cover the earlier content. Disjoint chunks and tails outside a capped full read stay verbatim; identical capped reads still supersede the older copy. Supersession keeps its existing cache-rewrite cadence.
+
+## [2.12.0] - 2026-10-17
+
+### Fixed
+
+- Virtual (router-backed) models work as the summarizer - via `summarizerModel: "default"`, an explicit virtual `provider/id`, or as the outage-fallback session model. Summarizer calls now go through `ctx.modelRegistry.streamSimple()` instead of pi-ai's provider table, which had no `pi-virtual` entry and threw `No API provider registered for api: pi-virtual`. (#20)
+- A summarizer stream that ignores the abort signal (a virtual router whose `route()` never resolves) no longer wedges the flush: the idle and ceiling timers now end the wait themselves. (#20)
+
+### Changed
+
+- `summarizerThinking` applies on every provider; it was sent as an OpenAI-specific `reasoningEffort` option that Anthropic-style adapters ignored. `default` and `off` still send no reasoning option, which on Anthropic means `thinkingEnabled: false` as before. (#20)
+- Minimum supported host is pi 1.3.0; dev dependencies on `@earendil-works/pi-ai`, `pi-coding-agent`, and `pi-tui` move from `^0.83.0` to `^1.3.0`. (#20)
+
 ## [2.11.5] - 2026-10-08
 
 ### Changed

package/PRUNING.md

@@ -30,7 +30,7 @@
 10. [Chain Compression](#chain-compression)
     - [Protected-output relocation](#protected-output-relocation)
 11. [Occurrence Identity](#occurrence-identity)
-12. [Error Purge](#error-purge)
+12. [Argument Purge](#argument-purge)
 13. [Orphan Sweep](#orphan-sweep)
 14. [Diagnostics](#diagnostics)
 15. [Why Summarization Works: Research Evidence](#why-summarization-works-research-evidence)
@@ -184,7 +184,7 @@ graph TB
 
 **Key points:**
 
-- The `AssistantMessage` tool-call blocks are **kept** (they carry the `toolCallId`s the model uses to reference originals via `context_tree_query`).
+- The `AssistantMessage` tool-call blocks are **kept**, preserving their ids and result pairing; eligible long argument strings shrink through [Argument Purge](#argument-purge).
 - `ToolResultMessage` entries for summarized tool calls are **replaced with a small stub** (`[Summarized in pruner summary, ref \`tN\`. Use context_tree_query to retrieve full output.]`) carrying`role: "toolResult"`, the original`toolCallId`/`toolName`/`timestamp`, and`isError: false`. The stub preserves role alternation, so pi-ai's`transformMessages.insertSyntheticToolResults` no longer injects a synthetic `{ isError: true, "No result provided" }` for the (no-longer-)orphaned tool call. See [Stub-replace instead of delete](#stub-replace-instead-of-delete).
 - Every pruned tool call is also copied into the pruner's runtime/session index with its `toolCallId`, tool name, args, status, turn index, timestamp, and full `resultText`.
 - A summary message is injected as a `"steer"` (`pi.sendMessage` runtime path) or appended directly via `sessionManager.appendCustomMessageEntry` (session path, used when Pi may already be shutting down). Both deliver before the next LLM call.
@@ -283,7 +283,7 @@ So after pruning, the model is working with a **two-layer memory**:
 
 | Part of old turn | After pruning | Why |
 |---|---|---|
-| Assistant tool-call block | **Kept in context** | Preserves the `toolCallId` anchors the model uses to reference originals |
+| Assistant tool-call block | **Kept in context; eligible long argument strings shrink** | Preserves `toolCallId` anchors and result pairing; indexed arguments remain recoverable through `context_tree_query` (dedup aliases keep their own arguments) |
 | Tool result message | **Replaced by a short stub in active context** | Saves tokens (typical 50–100× reduction per call) while keeping the `toolCallId` anchor and giving the model an explicit `context_tree_query` breadcrumb. The stub keeps `role: "toolResult"` and `isError: false` so role alternation stays intact |
 | Summary message | **Added to context** | Gives the model a compact description of what happened |
 | Indexed tool-call record | **Stored in pruner index** (`context-prune-index` session entry) | Lets the model re-open the original raw output later via `context_tree_query` |
@@ -584,8 +584,8 @@ graph LR
 captured batches (from turn_end or session scan)
   │
   ├─ 1. Protected-tools/paths filter   (capture-time, see below)
-  │     newest read per protected path stays verbatim; older reads of the same
-  │     path are stubbed at render time once the cache is cold anyway (see § Supersession)
+  │     protected reads stay verbatim unless a later same-path read covers their
+  │     delivered lines; stubbing waits for a shared rewrite or cold cache (see below)
   │     tool calls whose toolName is in protectedTools, OR whose args.path
   │     matches any protectedPaths glob, never enter the batch
   │
@@ -633,7 +633,7 @@ Implementation: `src/pruner.ts` `pruneMessages(messages, indexer)` returns `{ me
 
 ### Protected tools & paths
 
-A tool call is protected if **either** its `toolName` is in `protectedTools` **or** its `args.path` (string) matches any glob in `protectedPaths`. Protected calls are filtered out **at capture time** - they never enter the `pendingBatches` queue, so their raw `ToolResultMessage` stays verbatim in future LLM context until a newer read of the same path supersedes it (below).
+A tool call is protected if **either** its `toolName` is in `protectedTools` **or** its `args.path` (string) matches any glob in `protectedPaths`. Protected calls are filtered out **at capture time** - they never enter the `pendingBatches` queue, so their raw `ToolResultMessage` stays verbatim in future LLM context until a later read of the same path covers its delivered lines and supersedes it (below).
 
 **`protectedTools: string[]`** (default `[]`) - allowlist of tool names. Covers tools whose output is a small handle that must be reused byte-for-byte (e.g. a session-id) or planning tools like `todowrite` / `todoread`.
 
@@ -643,9 +643,30 @@ Glob contract: full-path match against the raw `args.path` string with `\` norma
 
 **Render-time re-check:** stub replacement runs in-flight on every turn (`pruneMessages`). If a tool call's persisted `args` now satisfy `isProtected` (e.g. a pattern was added mid-session), the stub is skipped and the raw result is left verbatim - this repairs already-summarized records in existing sessions with no schema change. Declared limitation: records inside already-compressed chains (`context-prune-chain` entries) are NOT repaired - their `protectedToolCallIds` set is fixed at compression time (forward-only). Dedup-alias edge: an alias resolving to an unprotected original stays stubbed.
 
-**Supersession (phase 1b, `src/supersede.ts`):** protected calls are never indexed, so content-hash dedup never sees them. Instead, at render time only the **newest** protected occurrence per normalized `args.path` (backslash -> slash; `offset`/`limit` ignored) stays verbatim; every earlier occurrence with a paired result becomes the one-line stub `[Superseded: <path> was read again later in this conversation - see the newer read. Re-read the file if this earlier content is needed.]`. The stub keeps `toolCallId`/`toolName`/`timestamp`, so pi-ai's orphan repair never fires; the assistant `toolCall` block is untouched. A call without a paired result never participates (an aborted call cannot steal the win). Recovery is "re-read the file" - no `t<N>` ref. Provider tool-call ids repeat across turns and an aborted call has no result, so a result is paired only with the same-id call in the immediately preceding assistant message (the per-turn open-set model orphan-sweep uses) - never by a global per-id cursor.
+**Supersession (phase 1b, `src/supersede.ts`):** protected calls are never indexed, so content-hash dedup never sees them. A paired occurrence participates only when `isProtected(toolName, args)` is true and `typeof args.path === "string"`. Occurrences group by normalized `args.path` (backslash -> slash). An earlier occurrence is a supersession candidate only when **any later occurrence** of that path covers its delivered line range, not just when the last occurrence covers it. Different paths never interact; disjoint chunks stay verbatim.
 
-**Cadence (prompt-cache economics):** a superseded read is stubbed only when the pruner is already rewriting at or before its position - `floor` is the earliest result timestamp phase 1 will stub on the next render (indexed batches, plus dedup aliases registered in the pre-flush pass - those are stubbed by phase 1 whatever their batch's outcome; a `skipped-trivial`/`skipped-oversized` batch's own calls set none) or the `startUserTimestamp` of a chain compressed this turn - or on a guaranteed-cold event: `session_start`, `session_tree`, `model_select`, `session_compact`, `thinking_level_select` (`floor = 0`, activate all). Activation is session-sticky (in-memory `occKey` set, cleared on `session_start`/`session_tree`); between those moments a freshly superseded copy stays verbatim on purpose, since a mid-prefix rewrite re-bills the whole tail once. `isProtected` is evaluated live, so a path that stops matching `protectedPaths` drops out of supersession and rejoins the normal pipeline. No config key: supersession is on whenever protection is. Spec: `doc/specs/2026-09-07-protected-path-supersede.md`.
+**Requested and delivered ranges:** numeric `offset` normalizes to `max(1, offset)`; absent, `null`, or non-numeric offsets start at line 1. Numeric `limit > 0` requests `[start, start + limit - 1]`; absent, `null`, or non-numeric limits give `[start, inf)`. A `limit <= 0` delivers no lines: it supersedes nothing and is covered by any later nonempty read of the path. A read that returns pi's oversized-first-line warning instead of content delivers no lines, so it covers nothing. Otherwise, without a cap footer, the delivered range is the requested range. A pi footer such as `[Showing lines 1-1800 of 3000 (50.0KB limit). Use offset=1801 to continue.]` bounds the delivered end at 1800. The footer parser also accepts the line-cap form without the parenthetical and any `(<size> limit)` form. This bound applies to both earlier and later reads: a capped full read never covers a tail it did not deliver. Coverage requires the later delivered start to be at or below the earlier start and its end at or above the earlier end.
+
+For a file of 3000 lines, "capped" means pi truncated the output:
+
+| Sequence on one path | Superseded |
+|---|---|
+| full, full | first |
+| chunk `1-2000`, chunk `2001-` | none |
+| chunk `1-2000`, full capped at line 2000 | chunk (delivered ranges equal) |
+| chunk `2001-3000`, full capped at line 2000 | none (the later read never delivered the tail) |
+| full, chunk | none |
+| chunk 1, chunk 2, chunk 1 again | first chunk 1 |
+| full capped at line 2000, full capped again | first (same delivered lines) |
+| `limit: 2500` byte-capped at line 1800, full capped at line 2000 | first (`[1, 1800]` is inside `[1, 2000]`) |
+| full capped at line 2000, `limit: 2500` byte-capped at line 1800 | none |
+| `offset: 0, limit: 100`, full | first (offset 0 is line 1) |
+| `offset: null` no limit, chunk `1-50` | none (`[1, inf)` is not covered by `[1, 50]`) |
+| chunk `1-50`, `offset: null, limit: 50` | first (`[1, 50]` covers `[1, 50]`) |
+
+Once activated by the cadence gate below, a candidate becomes the one-line stub `[Superseded: <path> was read again later in this conversation - see the newer read. Re-read the file if this earlier content is needed.]`. The stub keeps `toolCallId`/`toolName`/`timestamp`, so pi-ai's orphan repair never fires; the assistant `toolCall` block is untouched. A call without a paired result never participates. Recovery is "re-read the file" - no `t<N>` ref. Results pair only with an open same-id call in the preceding assistant turn; each assistant turn resets the open set, and any non-assistant/non-toolResult message clears it. A paired result consumes its call, so reused provider ids never pair through a global per-id cursor.
+
+**Cadence (prompt-cache economics):** a superseded read is stubbed only when the pruner is already rewriting at or before its position - `state.floor` is the earliest result timestamp phase 1 will stub on the next render (indexed batches, plus dedup aliases registered in the pre-flush pass - those are stubbed by phase 1 whatever their batch's outcome; a `skipped-trivial`/`skipped-oversized` batch's own calls set none) or the `startUserTimestamp` of a chain compressed this turn - or on a guaranteed-cold event: `session_start`, `session_tree`, `model_select`, `session_compact`, `thinking_level_select` (`state.floor = 0`, activate all). Activation is session-sticky (`state.activated`, an in-memory `occKey` set cleared on `session_start`/`session_tree`); between those moments a freshly superseded copy stays verbatim on purpose, since a mid-prefix rewrite re-bills the whole tail once. `isProtected` is evaluated live, so a path that stops matching `protectedPaths` drops out of supersession and rejoins the normal pipeline. No config key: supersession is on whenever protection is. Specs: [delivered-range coverage](doc/specs/2026-10-20-multi-stage-context-retention.md#change-2-range-aware-supersession) and [cadence and stub contract](doc/specs/2026-09-07-protected-path-supersede.md).
 
 Names and patterns that don't match any captured tool call are silently ignored.
 
@@ -724,7 +745,7 @@ The frontier's `lastAttemptedTurnIndex` uses a session-wide numbering domain: it
 - **Tree browser (`/pruner tree`):** interactive, foldable tree of pruned tool calls grouped under their summaries. `Ctrl-O` on a summary node opens the full markdown summary in a bordered overlay.
 - **Configurable summarizer thinking (`summarizerThinking`):** trade summary cost / latency for quality (`off` / `minimal` / `low` / `medium` / `high` / `xhigh`). `default` omits the option entirely so the provider chooses.
 - **Cumulative stats:** `context-prune-stats` entries track input/output tokens and cost of every summarizer call; full detail surfaces in `/pruner stats`. Cost is also emitted on the `cost:external` pi.events channel for external aggregators (cumulative per session, live only).
-- **Live reclaim ratio:** measured once per `pruneMessages` call via `sizeMessages(messages)` = the sum of `charsOf(message)` (`src/context-metrics.ts`): whole-message JSON chars with each image block priced at a flat 1,600 tokens (6,400 chars) instead of its base64 length, the same estimate the frontier-gap trigger uses. This compares the input array before pruning to the result after. Estimated tokens = chars / 4. The measurement covers all five phases in a single point (stub-replace, supersede, error-purge, chain-range-prune, orphan-sweep); appears on the status line as `│ prune: ON · 92.0k->14.0k (-85%)` once at least one prune has occurred (the leading `│` keeps the segment visually isolated in the shared footer, load-order independent - there is no trailing divider, since the footer's own space-join between segments already provides one).
+- **Live reclaim ratio:** measured once per `pruneMessages` call via `sizeMessages(messages)` = the sum of `charsOf(message)` (`src/context-metrics.ts`): whole-message JSON chars with each image block priced at a flat 1,600 tokens (6,400 chars) instead of its base64 length, the same estimate the frontier-gap trigger uses. This compares the input array before pruning to the result after. Estimated tokens = chars / 4. The measurement covers all five phases in a single point (stub-replace, supersede, argument-purge, chain-range-prune, orphan-sweep); appears on the status line as `│ prune: ON · 92.0k->14.0k (-85%)` once at least one prune has occurred (the leading `│` keeps the segment visually isolated in the shared footer, load-order independent - there is no trailing divider, since the footer's own space-join between segments already provides one).
 - **Live progress for `/pruner now`:** an `aboveEditor` widget shows one row per pending batch with braille spinner, streamed summary-char count, and ✓ / ⚠ status.
 
 ### Summarizer outage fallback
@@ -918,7 +939,7 @@ raw messages from session
   │
   ├─ [1] tool-result stub-replace   (per-batch; existing)
   ├─ [1b] supersede                (older protected reads of a re-read path -> stub; see § Supersession)
-  ├─ [2] error-purge                (phase 2)
+  ├─ [2] argument-purge             (phase 2)
   ├─ [3] chain-range-prune          (runs AFTER stubs)
   │        resolve each entry to a positional index range
   │        drop assistant / toolResult / per-batch-summary inside the range
@@ -1099,45 +1120,42 @@ Short refs (`tN`) always resolve 1:1 - one ref, one record - and are the primary
 
 ---
 
-## Error Purge
+## Argument Purge
 
-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.
+An indexed call whose result has been summarized loses its long string arguments in the same render its result is stubbed; `context_tree_query` returns both the arguments and the result.
 
-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:
+Two exceptions stay separate: an errored call waits `purgeErrors.cooldownTurns` assistant turns (default 2), whether or not it was indexed, so recovery through `context_tree_query` is available only when it was also indexed. A dedup alias is never shrunk: the index stores only the canonical call's arguments, and recovery on the shared ref returns those arguments, not the alias's own prompt.
+
+**Shared gates and shape:** `purgeErrors.enabled` controls both sources. The JSON-stringified `block.arguments` body must be at least `purgeErrors.minArgChars` characters (default 500). Only strings longer than 200 characters (`PURGE_STRING_MIN_CHARS` in `src/error-purge.ts`, not configurable) shrink. Keys, JSON types, array lengths, non-string values, and strings of 200 characters or fewer survive. A qualifying body with no long string stays unchanged. Keeping the shape preserves provider schema validation while leaving short paths and commands readable.
+
+Both markers carry the original string length; summarized calls also carry the short ref from the result stub:
 
 ```
-{ "path": "src/foo.ts", "content": "<purged-errored-args size=\"30000\"/>" }
+<purged-args size="30000" ref="t6"/>
+<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:**
+**Pairing and source selection:** phase 1 hands phase 2 a map from each stubbed result's resolved occurrence key to its short ref, excluding dedup aliases. Phase 2 pairs results positionally with open same-id tool-call blocks in the preceding assistant turn. Each assistant turn resets the open set, a result consumes its paired call, and any non-assistant/non-toolResult message clears the set. Rewrites target the exact assistant position and block id, so a reused provider id cannot authorize shrinking a sibling call in another turn. Timestamped results use `id@resultTimestamp`; timestamp-less results use the bare id for the handoff lookup, not for selecting a rewrite position.
 
-- 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. A body that qualifies but holds no string over 200 characters is returned unchanged.
+A result phase 1 stubs has `isError: false`, so its arguments get `<purged-args>` even if the original result errored. Before that stub render, an expired error cooldown can produce `<purged-errored-args>`. Argument purge does not rewrite result content; unsummarized error messages stay visible.
 
-**What error purge does NOT touch:**
+**Cadence and identity:** summarized calls have no separate cooldown. Shrinking coincides with the result-stub rewrite; delaying it would invalidate the prefix again on a later turn. Each context render starts from raw history and reapplies the same transformation: for fixed index and recovery-grace state, the emitted prefix bytes are deterministic across fresh-history renders. The input array is returned by identity only when nothing changes, including an already-shrunk input whose markers fall below the string floor.
 
-- 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`.
+Protected calls and trivial batches have no phase 1 stub and do not qualify through the summarized source. Calls in the recovery grace window keep both their raw result and arguments until the window expires; stubbing and shrinking then happen together. Dedup alias results still get stubs, but their arguments stay intact. The separate errored source retains its cooldown behavior for calls with `isError: true`.
 
-**Transform position:** Error purge runs in Phase 2, after stub-replace and before chain range prune.
+**Transform position:** argument purge runs in Phase 2, after stub-replace and supersession and before chain range prune.
 
 ```
-[stub-replace] → [supersede] → [error-purge] → [chain-range-prune] → [orphan-sweep]
+[stub-replace] → [supersede] → [argument-purge] → [chain-range-prune] → [orphan-sweep]
 ```
 
-**Config keys:**
+**Config keys:** persisted names stay `purgeErrors.*`; the settings overlay labels the shared toggle and size gate as argument purge and the cooldown as error-only.
 
 | Key | Default | Description |
 |---|---|---|
-| `purgeErrors.enabled` | `true` | Master toggle |
-| `purgeErrors.cooldownTurns` | `2` | Turns to wait after error before purging |
-| `purgeErrors.minArgChars` | `500` | Minimum JSON body size for a failed call to be scanned; only strings over 200 chars inside it are replaced |
+| `purgeErrors.enabled` | `true` | Toggle for summarized and errored argument purge |
+| `purgeErrors.cooldownTurns` | `2` | Assistant turns to wait after an error; applies only to the errored source |
+| `purgeErrors.minArgChars` | `500` | Minimum JSON body size for either source; only strings over 200 chars inside it are replaced |
 
 ---
 

package/README.md

@@ -126,6 +126,8 @@ These are most informative for long single-chain sessions where Phase 3 (chain c
 
 Published to npm as [`pi-condense`](https://www.npmjs.com/package/pi-condense).
 
+Requires pi >= 1.3.0: the summarizer calls `ctx.modelRegistry.streamSimple()`, which is what lets a virtual (router-backed) model serve as the summarizer. Older hosts are unsupported; before pi 0.86.0 the method does not exist and every summarizer call fails with a `TypeError` notice.
+
 **User scope** (all repos under your pi profile):
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.11.5",
+  "version": "2.13.0",
   "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",
@@ -57,9 +57,9 @@
     "@sinclair/typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.83.0",
-    "@earendil-works/pi-coding-agent": "^0.83.0",
-    "@earendil-works/pi-tui": "^0.83.0",
+    "@earendil-works/pi-ai": "^1.3.0",
+    "@earendil-works/pi-coding-agent": "^1.3.0",
+    "@earendil-works/pi-tui": "^1.3.0",
     "@sinclair/typebox": "^0.34.52"
   }
 }

package/src/commands.test.ts

@@ -12,6 +12,8 @@ import { pruneStatusText, setPruneStatusWidget, registerCommands } from "./comma
 import { settingsPath } from "./config.js";
 import type { ContextPruneConfig, ContextMetricsSnapshot, SummarizerStats } from "./types.js";
 import { DEFAULT_CONFIG } from "./types.js";
+import { Container, SettingsList } from "@earendil-works/pi-tui";
+import { initTheme } from "@earendil-works/pi-coding-agent";
 
 const cfg = (enabled: boolean): ContextPruneConfig => ({ enabled } as ContextPruneConfig);
 const cfgVisible = (enabled: boolean): ContextPruneConfig =>
@@ -41,6 +43,7 @@ function setupPrunerCommand(overrides: {
   let handler: (args: string, ctx: any) => Promise<void>;
   const notifications: { message: string; type?: string }[] = [];
   const flushCalls: any[] = [];
+  let overlay: Container & { handleInput(data: string): void };
 
   const flushPending =
     overrides.flushPending ??
@@ -79,6 +82,9 @@ function setupPrunerCommand(overrides: {
         notifications.push({ message, type });
       },
       setStatus() {},
+      async custom(factory: (...args: any[]) => typeof overlay) {
+        overlay = factory(undefined, undefined, undefined, () => {});
+      },
     },
   };
 
@@ -87,9 +93,49 @@ function setupPrunerCommand(overrides: {
     notifications,
     flushCalls,
     currentConfig,
+    get overlay() { return overlay; },
   };
 }
 
+describe("/pruner settings argument purge", () => {
+  initTheme("dark");
+
+  it.each([
+    ["purgeErrorsEnabled", "Argument purge", "Shrink long strings in summarized calls when their results are stubbed in the same render, and in errored calls after the error cooldown, keeping argument shape."],
+    ["purgeErrorsCooldown", "Error purge cooldown (turns)", "Wait this many turns after a tool error before purging its argument body."],
+    ["purgeErrorsMinArgChars", "Argument purge min arg chars", "Only purge summarized or errored argument bodies at least this many chars."],
+  ])("describes %s through the settings overlay", async (id, label, description) => {
+    const harness = setupPrunerCommand({ save: async () => {} });
+    await harness.run("settings");
+    const list = harness.overlay.children.find((child) => child instanceof SettingsList) as SettingsList;
+    list.selectItem(id);
+
+    const rendered = harness.overlay.render(400).join("\n");
+    expect(rendered).toContain(label);
+    expect(rendered).toContain(description);
+    if (id === "purgeErrorsCooldown") expect(rendered).not.toContain("same render");
+  });
+
+  it("persists the shared disabled toggle and minimum using only existing purgeErrors fields", async () => {
+    const saved: ContextPruneConfig[] = [];
+    const harness = setupPrunerCommand({ save: async (config) => { saved.push(structuredClone(config)); } });
+    const initial = structuredClone(harness.currentConfig.value);
+    await harness.run("settings");
+    const list = harness.overlay.children.find((child) => child instanceof SettingsList) as SettingsList;
+
+    list.selectItem("purgeErrorsEnabled");
+    harness.overlay.handleInput(" ");
+    list.selectItem("purgeErrorsMinArgChars");
+    harness.overlay.handleInput(" ");
+
+    expect(saved).toEqual([
+      { ...initial, purgeErrors: { ...initial.purgeErrors, enabled: false } },
+      { ...initial, purgeErrors: { ...initial.purgeErrors, enabled: false, minArgChars: 1000 } },
+    ]);
+    expect(harness.currentConfig.value).toEqual(saved[1]);
+  });
+});
+
 describe("/pruner now (empty capture)", () => {
   it("invokes flushPending even when nothing is pending, so a flush-metrics entry is recorded", async () => {
     const harness = setupPrunerCommand({ capturePendingBatches: () => [] });

package/src/commands.ts

@@ -672,10 +672,10 @@ export function registerCommands(
             },
             {
               id: "purgeErrorsEnabled",
-              label: "Error purge",
+              label: "Argument purge",
               values: ["true", "false"],
               currentValue: String(config.purgeErrors.enabled),
-              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"}.`,
+              description: `Shrink long strings in summarized calls when their results are stubbed in the same render, and in errored calls after the error cooldown, keeping argument shape. Currently ${config.purgeErrors.enabled ? "ON" : "OFF"}.`,
             },
             {
               id: "purgeErrorsCooldown",
@@ -688,12 +688,12 @@ export function registerCommands(
             },
             {
               id: "purgeErrorsMinArgChars",
-              label: "Error purge min arg chars",
+              label: "Argument purge min arg chars",
               values: PURGE_MIN_ARG_PRESETS.map((p) => p.value),
               currentValue: PURGE_MIN_ARG_PRESETS.some((p) => p.value === String(config.purgeErrors.minArgChars))
                 ? String(config.purgeErrors.minArgChars)
                 : PURGE_MIN_ARG_PRESETS[1].value,
-              description: `Only purge arg bodies at least this many chars. Currently ${config.purgeErrors.minArgChars}.`,
+              description: `Only purge summarized or errored argument bodies at least this many chars. Currently ${config.purgeErrors.minArgChars}.`,
             },
             {
               // Read-only display row. Editing goes through `/pruner protected-tools`

package/src/error-purge.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import { purgeErroredArgs } from "./error-purge.js";
+import { occKey } from "./occurrence-key.js";
+import { expectNoOrphanToolResults } from "./test-support.js";
 import type { ErrorPurgeConfig } from "./types.js";
 
 const defaultConfig: ErrorPurgeConfig = {
@@ -11,7 +13,7 @@ const defaultConfig: ErrorPurgeConfig = {
 const LONG = "x".repeat(300);
 const PLACEHOLDER_RE = /^<purged-errored-args size="\d+"\/>$/;
 
-function makeAssistant(toolCallId: string, argsObj: Record<string, any>, turnN?: number) {
+function makeAssistant(toolCallId: string, argsObj: any, turnN?: number) {
   return {
     role: "assistant",
     content: [
@@ -271,3 +273,91 @@ describe("purgeErroredArgs", () => {
     expect(original).toEqual(snapshot);
   });
 });
+
+describe("positional argument purge", () => {
+  const marker = '<purged-args size="600" ref="t6"/>';
+  const body = "x".repeat(600);
+
+  it.each([
+    ["below body threshold", { code: body }, 612, false],
+    ["at body threshold", { code: body }, 611, true],
+    ["200-char string", { code: "x".repeat(200) }, 10, false],
+    ["201-char string", { code: "x".repeat(201) }, 10, true],
+    ["only short strings", { code: Array(20).fill("x".repeat(100)) }, 500, false],
+    ["top-level string", body, 10, true],
+  ])("summarized gates: %s", (_, args, minArgChars, changed) => {
+    const messages = [makeAssistant("tc1", args), makeToolResult("tc1", false)];
+    expectNoOrphanToolResults(messages);
+    const refs = new Map([[occKey("tc1", 2), "t6"]]);
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 99, minArgChars }, refs);
+    expectNoOrphanToolResults(result);
+    if (changed) {
+      expect(result).not.toBe(messages);
+      expect((result[0] as any).content[0].arguments).toEqual(
+        typeof args === "string" ? marker : { code: `<purged-args size="${args.code.length}" ref="t6"/>` },
+      );
+    } else expect(result).toBe(messages);
+    expect(purgeErroredArgs(result, { ...defaultConfig, minArgChars }, refs)).toBe(result);
+  });
+
+  it("keeps nested shapes, grammar keys, and own prototype keys without mutation", () => {
+    const args = { code: body, nested: [[body, true, null, 42, "short"]], ...JSON.parse(`{"__proto__":"${body}"}`) };
+    const snapshot = structuredClone(args);
+    const messages = [makeAssistant("tc1", args), makeToolResult("tc1", false)];
+    expectNoOrphanToolResults(messages);
+    const result = purgeErroredArgs(messages, defaultConfig, new Map([[occKey("tc1", 2), "t6"]]));
+    expectNoOrphanToolResults(result);
+    const shrunk = (result[0] as any).content[0].arguments;
+    expect(Object.keys(shrunk)).toEqual(Object.keys(args));
+    expect(shrunk).toEqual({ code: marker, nested: [[marker, true, null, 42, "short"]], ...JSON.parse(`{"__proto__":${JSON.stringify(marker)}}`) });
+    expect(args).toEqual(snapshot);
+    expect(result[1]).toBe(messages[1]);
+  });
+
+  it.each([false, true])("disabled leaves summarized and error sources intact (error=%s)", (isError) => {
+    const messages = [makeAssistant("tc1", { code: body }), makeToolResult("tc1", isError)];
+    expectNoOrphanToolResults(messages);
+    expect(purgeErroredArgs(messages, { ...defaultConfig, enabled: false, cooldownTurns: 0 }, new Map([[occKey("tc1", 2), "t6"]]))).toBe(messages);
+  });
+
+  it("prefers the summarized marker even when the paired result is errored", () => {
+    const messages = [makeAssistant("tc1", { code: body }), makeToolResult("tc1", true)];
+    expectNoOrphanToolResults(messages);
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 0 }, new Map([[occKey("tc1", 2), "t6"]]));
+    expectNoOrphanToolResults(result);
+    expect((result[0] as any).content[0].arguments.code).toBe(marker);
+  });
+
+  it.each([
+    ["timestamped summarized", "summarized", true, "paired"],
+    ["timestamp-less summarized", "summarized", false, "paired"],
+    ["error only", "error", true, "paired"],
+    ["summarized after aborted call", "summarized", true, "aborted"],
+    ["timestamp-less after aborted call", "summarized", false, "aborted"],
+    ["error after aborted call", "error", true, "aborted"],
+    ["summarized after user barrier", "summarized", true, "barrier"],
+    ["timestamp-less after user barrier", "summarized", false, "barrier"],
+    ["error after user barrier", "error", true, "barrier"],
+  ])("isolates reused ids: %s", (_, source, timestamped, earlier) => {
+    const first = makeAssistant("reused", { code: body });
+    const lastResult: any = { ...makeToolResult("reused", source === "error"), timestamp: 4 };
+    if (!timestamped) delete lastResult.timestamp;
+    const messages: any[] = [first];
+    if (earlier === "paired") {
+      // A timestamp-less sibling must not resolve the later timestamped key (or vice versa).
+      const sibling: any = makeToolResult("reused", false);
+      if (timestamped) delete sibling.timestamp;
+      messages.push(sibling);
+    }
+    if (earlier === "barrier") messages.push({ role: "user", content: "continue" });
+    messages.push(makeAssistant("reused", { code: body }, 3), lastResult);
+    expectNoOrphanToolResults(messages);
+    const refs = source === "summarized" ? new Map([[occKey("reused", timestamped ? 4 : undefined), "t6"]]) : new Map<string, string>();
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 0 }, refs);
+    expectNoOrphanToolResults(result);
+    expect(result[0]).toBe(first);
+    expect((result[result.length - 2] as any).content[0].arguments.code).toBe(
+      source === "summarized" ? marker : '<purged-errored-args size="600"/>',
+    );
+  });
+});

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

@@ -35,6 +35,7 @@ const meta = { api: "openai-completions", provider: "openai", model: "grammar-te
 
 function history(codeArgs: Record<string, unknown>) {
   return [
+    { role: "system", content: "", toolsAdded: [codemode], timestamp: 0 },
     { 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 },
@@ -60,7 +61,7 @@ describe("error purge x pi-ai grammar tools (#19)", () => {
 
   it("purged codemode args pass getGrammarToolInput (reporter repro)", () => {
     const purged = purgeErroredArgs(history({ code: "x".repeat(1000) }), config);
-    const args = purged[1].content[0].arguments;
+    const args = purged[2].content[0].arguments;
     expect(typeof args.code).toBe("string");
     expect(Object.keys(args)).toEqual(["code"]);
     expect(JSON.stringify(args).length).toBeLessThan(500);
@@ -69,7 +70,7 @@ describe("error purge x pi-ai grammar tools (#19)", () => {
 
   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=/);
+    expect(purged[2].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.
@@ -80,7 +81,7 @@ describe("error purge x pi-ai grammar tools (#19)", () => {
 
   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"/>' };
+    legacy[2].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/);