pi-condense 2.12.0 → 2.13.0

package/CHANGELOG.md

@@ -7,6 +7,16 @@ 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

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/package.json

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

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.ts

@@ -1,17 +1,21 @@
+import { occKey, resultTimestampOf } from "./occurrence-key.js";
 import type { ErrorPurgeConfig } from "./types.js";
 
-// Keep short paths and commands readable while reclaiming large failed-call bodies.
+// Keep short paths and commands readable while reclaiming large completed-call bodies.
 const PURGE_STRING_MIN_CHARS = 200;
 
-function shrinkStrings(value: unknown): [unknown, boolean] {
+function shrinkStrings(
+  value: unknown,
+  marker: (size: number) => string = (size) => `<purged-errored-args size="${size}"/>`,
+): [unknown, boolean] {
   if (typeof value === "string") {
-    if (value.length > PURGE_STRING_MIN_CHARS) return [`<purged-errored-args size="${value.length}"/>`, true];
+    if (value.length > PURGE_STRING_MIN_CHARS) return [marker(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]);
+      const [next, changed] = shrinkStrings(value[i], marker);
       if (!changed) continue;
       out ??= value.slice();
       out[i] = next;
@@ -22,7 +26,7 @@ function shrinkStrings(value: unknown): [unknown, boolean] {
     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]);
+      const [next, changed] = shrinkStrings(object[key], marker);
       if (!changed) continue;
       // Spread creates own data properties, including JSON's possible __proto__ key.
       out ??= { ...object };
@@ -34,65 +38,64 @@ function shrinkStrings(value: unknown): [unknown, boolean] {
 }
 
 /**
- * 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
- *     the failure signal the model needs to understand what went wrong.
- *   - The toolCall block itself must remain so the provider can pair it with its
- *     result and avoid injecting a synthetic "No result provided" error.
- *   - The arguments body is what grows large — failed `write` / `edit` calls
- *     embed the full file content that will never be acted on again.
- *
- * Why the cooldown:
- *   - Gives the model 1–2 turns to retry before context is mutated. Purging
- *     immediately would remove the call detail before the model has had a
- *     chance to see the error and adapt.
- *
- * Turn index is computed internally by counting AssistantMessages in the input.
- * This avoids threading a turn counter through index.ts.
+ * Shrinks summarized arguments immediately and errored arguments after cooldown.
+ * Keys and JSON types survive pi-ai grammar validation during replay.
  */
-export function purgeErroredArgs(messages: any[], config: ErrorPurgeConfig): any[] {
-  // Pass 1: collect errored toolCallIds → the turn index at which the error occurred.
-  // Turn index = number of AssistantMessages seen up to and including the one that
-  // issued the tool call (ToolResultMessages follow immediately after).
-  const erroredAtTurn = new Map<string, number>();
+export function purgeErroredArgs(
+  messages: any[],
+  config: ErrorPurgeConfig,
+  summarizedRefs: ReadonlyMap<string, string> = new Map(),
+): any[] {
+  if (!config.enabled) return messages;
+
+  const targets = new Map<number, Map<string, { turn: number; ref?: string }>>();
+  const open = new Map<string, { assistantIndex: number; turn: number }>();
   let turnCount = 0;
-  for (const msg of messages) {
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
     if (msg.role === "assistant") {
-      // Count each assistant turn; toolResults referencing the turn come next.
       turnCount++;
-    } else if (msg.role === "toolResult" && msg.isError === true) {
-      // Record the turn this errored call belongs to for cooldown comparison.
-      erroredAtTurn.set(msg.toolCallId, turnCount);
+      open.clear();
+      for (const block of msg.content) {
+        if (block.type === "toolCall") open.set(block.id, { assistantIndex: i, turn: turnCount });
+      }
+    } else if (msg.role === "toolResult") {
+      const paired = open.get(msg.toolCallId);
+      if (!paired) continue;
+      open.delete(msg.toolCallId);
+      const ref = summarizedRefs.get(occKey(msg.toolCallId, resultTimestampOf(msg.timestamp)));
+      if (ref === undefined && msg.isError !== true) continue;
+      let blocks = targets.get(paired.assistantIndex);
+      if (!blocks) targets.set(paired.assistantIndex, blocks = new Map());
+      blocks.set(msg.toolCallId, { turn: paired.turn, ref });
+    } else {
+      open.clear();
     }
   }
 
-  if (erroredAtTurn.size === 0) return messages;
-
-  const currentTurnIndex = turnCount;
+  if (targets.size === 0) return messages;
 
   // Pass 2: rewrite AssistantMessages whose toolCall args should be purged.
   let anyModified = false;
-  const result = messages.map((msg) => {
-    if (msg.role !== "assistant") return msg;
+  const result = messages.map((msg, assistantIndex) => {
+    const targetsForTurn = targets.get(assistantIndex);
+    if (!targetsForTurn) return msg;
 
     let contentModified = false;
     const newContent = (msg.content as any[]).map((block) => {
       if (block.type !== "toolCall") return block;
 
-      const errorTurn = erroredAtTurn.get(block.id);
-      if (errorTurn === undefined) return block;
-
-      const age = currentTurnIndex - errorTurn;
-      if (age < config.cooldownTurns) return block;
+      const target = targetsForTurn.get(block.id);
+      if (!target) return block;
+      if (target.ref === undefined && turnCount - target.turn < config.cooldownTurns) return block;
 
       const argBody = JSON.stringify(block.arguments);
       if (argBody.length < config.minArgChars) return block;
 
-      const [shrunk, changed] = shrinkStrings(block.arguments);
+      const [shrunk, changed] = shrinkStrings(
+        block.arguments,
+        target.ref === undefined ? undefined : (size) => `<purged-args size="${size}" ref="${target.ref}"/>`,
+      );
       if (!changed) return block;
 
       contentModified = true;

package/src/frontier.test.ts

@@ -85,6 +85,7 @@ describe("PruneFrontierTracker.reconstructFromSession", () => {
 
     const indexer = {
       isSummarized: (id: string) => id === "tc-old" || id === "tc-stub",
+      isDedupAlias: () => false,
       hasLegacyBareRecord: (id: string) => id === "tc-old" || id === "tc-stub",
       getShortRefForToolCallId: (id: string) => (id === "tc-stub" ? "t1" : id === "tc-old" ? "told" : undefined),
       getRecord: () => undefined,

package/src/indexer.test.ts

@@ -132,6 +132,28 @@ describe("occurrence keying", () => {
     expect(records.map((r) => r.resultTimestamp)).toEqual([1150, 9150]);
   });
 
+  test("isDedupAlias checks exact registered keys without resolving refs or sibling occurrences", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "SAME" }]), () => {});
+    indexer.addBatch(batch(1, 2000, [{ id: "bash_23", ts: 2150, text: "OTHER" }]), () => {});
+    indexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 }]);
+    indexer.registerDuplicate("bash_23@9150", "bash_23@1150", () => {});
+    indexer.registerDuplicate("bash_legacy", "bash_23@1150", () => {});
+
+    for (const [key, expected] of [
+      ["bash_23@9150", true],
+      ["bash_legacy", true],
+      ["bash_23@1150", false],
+      ["bash_23@2150", false],
+      ["bash_23", false],
+      ["bash_legacy@9150", false],
+      ["unknown", false],
+      ["t1", false],
+    ] as const) {
+      expect(indexer.isDedupAlias(key)).toBe(expected);
+    }
+  });
+
   test("summary body lookups are occurrence-keyed", () => {
     const indexer = new ToolCallIndexer();
     indexer.registerSummaryBody(["bash_23@1150"], "summary of FIRST");
@@ -302,6 +324,10 @@ describe("session rebuild", () => {
     expect(indexer.getRecord("bash_99@4150")?.resultText).toBe("FIRST");
     expect(indexer.getShortRefForToolCallId("bash_99@4150")).toBe("t1");
     expect(indexer.getPerBatchSummaryTextForToolCallIds(["bash_23@2150"])).toBe("summary text");
+    expect(indexer.isDedupAlias("bash_99@4150")).toBe(true);
+    expect(indexer.isDedupAlias("bash_99")).toBe(false);
+    expect(indexer.isDedupAlias("bash_23@1150")).toBe(false);
+    expect(indexer.isDedupAlias("t1")).toBe(false);
   });
 
   test("legacy entries without resultTimestamp keep bare-id keys", () => {
@@ -336,6 +362,8 @@ describe("session rebuild", () => {
     expect(indexer.hasLegacyBareRecord("bash_7")).toBe(true);
     expect(indexer.hasLegacyBareRecord("bash_23")).toBe(false);
     expect(indexer.isSummarized("bash_8")).toBe(true);
+    expect(indexer.isDedupAlias("bash_8")).toBe(true);
+    expect(indexer.isDedupAlias("bash_7")).toBe(false);
   });
 });
 

package/src/indexer.ts

@@ -183,6 +183,10 @@ export class ToolCallIndexer {
     return this.index.has(occurrenceKey) || this.dedupAliasToOriginal.has(occurrenceKey);
   }
 
+  isDedupAlias(key: string): boolean {
+    return this.dedupAliasToOriginal.has(key);
+  }
+
   /**
    * Returns the full runtime index map.
    */

package/src/pruner.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { pruneMessages, sizeMessages } from "./pruner.js";
+import { purgeErroredArgs } from "./error-purge.js";
 import { charsOf } from "./context-metrics.js";
 import { ToolCallIndexer } from "./indexer.js";
 import { CUSTOM_TYPE_INDEX } from "./types.js";
@@ -33,6 +34,7 @@ function makeMockIndexer({
 } = {}) {
   return {
     isSummarized: (id: string) => summarized.has(id),
+    isDedupAlias: (_key: string) => false,
     hasLegacyBareRecord: (id: string) => summarized.has(id),
     getShortRefForToolCallId: (id: string) => shortRefs.get(id),
     getRecord: (id: string) => records.get(id),
@@ -47,6 +49,116 @@ function makeMockIndexer({
   } as any;
 }
 
+describe("summarized argument handoff", () => {
+  const prompt = "p".repeat(600);
+  const config = { enabled: true, minArgChars: 300, cooldownTurns: 2 };
+  const history = (name = "subagent"): any[] => [
+    { role: "assistant", content: [{ type: "toolCall", id: "call", name, arguments: { prompt } }] },
+    { role: "toolResult", toolCallId: "call", toolName: name, timestamp: 10, content: [{ type: "text", text: "original output" }], isError: false },
+  ];
+  const render = (messages: any[], indexer: any, options = config, protection?: any, grace = 0) => {
+    expectNoOrphanToolResults(messages);
+    const result = pruneWithZeroSweepAssertion(messages, indexer, undefined, options, protection, grace);
+    expectNoOrphanToolResults(result.messages);
+    return result.messages;
+  };
+  const indexed = (key = "call@10", record?: any) => makeMockIndexer({
+    summarized: new Set([key]), shortRefs: new Map([[key, "t6"]]),
+    records: new Map([[key, record]]),
+  });
+
+  for (const row of [
+    { label: "summary", record: undefined },
+    { label: "spill", record: { spillPath: "/tmp/output", toolName: "subagent" } },
+    { label: "legacy fallback", key: "call" },
+    { label: "timestamp-less", key: "call" },
+  ]) {
+    it(`stubs and shrinks together: ${row.label}`, () => {
+      const raw = history();
+      if (row.label === "timestamp-less") delete raw[1].timestamp;
+      const out = render(raw, indexed(row.key, row.record));
+      expect(out[1].content[0].text).toContain("`t6`");
+      expect(out[0].content[0].arguments.prompt).toBe(`<purged-args size="${prompt.length}" ref="t6"/>`);
+      expect(raw[0].content[0].arguments.prompt).toBe(prompt);
+      expect(purgeErroredArgs(out, config, new Map([[row.label === "timestamp-less" ? "call" : "call@10", "t6"]]))).toBe(out);
+    });
+  }
+
+  for (const row of [
+    { label: "disabled", options: { ...config, enabled: false } },
+    { label: "body below gate", options: { ...config, minArgChars: 1000 } },
+    { label: "no long strings", args: { a: "a".repeat(180), b: "b".repeat(180) } },
+    { label: "unindexed", unindexed: true },
+    { label: "protected", record: { toolName: "read", args: { path: "keep.md" } }, protection: { protectedTools: [], protectedPaths: ["keep.md"] } },
+  ]) {
+    it(`retains arguments: ${row.label}`, () => {
+      const raw = history();
+      if (row.args) raw[0].content[0].arguments = row.args;
+      const out = render(raw, row.unindexed ? makeMockIndexer() : indexed(undefined, row.record), row.options, row.protection);
+      expect(out[0]).toBe(raw[0]);
+      expect(out[1] === raw[1]).toBe(!!row.unindexed || !!row.protection);
+    });
+  }
+
+  it("pairs timestamp-less handoff positionally without shrinking a reused-id sibling", () => {
+    const indexer = indexed("call");
+    indexer.hasLegacyBareRecord = () => false;
+    const raw = [...history(), { role: "user", content: "next" }, ...history()];
+    delete raw[4].timestamp;
+    const out = render(raw, indexer);
+    expect(out[0]).toBe(raw[0]);
+    expect(out[1]).toBe(raw[1]);
+    expect(out[3].content[0].arguments.prompt).toBe('<purged-args size="600" ref="t6"/>');
+    expect(out[4].content[0].text).toContain("`t6`");
+  });
+
+  it("uses the same raw-id fallback ref in the stub and argument marker", () => {
+    const out = render(history(), makeMockIndexer({ summarized: new Set(["call@10"]) }));
+    expect(out[1].content[0].text).toContain("`call`");
+    expect(out[0].content[0].arguments.prompt).toBe('<purged-args size="600" ref="call"/>');
+  });
+
+  it("advances recovery grace with stub and shrink at the same boundary", () => {
+    const raw = history("context_tree_query");
+    const indexer = indexed();
+    expect(render(raw, indexer, config, undefined, 1)).toBe(raw);
+    raw.push({ role: "user", content: "next" }, { role: "assistant", content: [] }, { role: "user", content: "again" });
+    const out = render(raw, indexer, config, undefined, 1);
+    expect(out[1].content[0].text).toContain("`t6`");
+    expect(out[0].content[0].arguments.prompt).toBe(`<purged-args size="600" ref="t6"/>`);
+  });
+
+  it("switches aged error markers on indexing and keeps fresh-render prefixes stable", () => {
+    const raw = history();
+    raw[1].isError = true;
+    raw.push({ role: "assistant", content: [] }, { role: "user", content: "next" }, { role: "assistant", content: [] });
+    const before = render(structuredClone(raw), makeMockIndexer());
+    expect(before[0].content[0].arguments.prompt).toBe('<purged-errored-args size="600"/>');
+    const indexer = indexed();
+    const first = render(structuredClone(raw), indexer);
+    expect(first[0].content[0].arguments.prompt).toBe('<purged-args size="600" ref="t6"/>');
+    expect(first[1].isError).toBe(false);
+    expect(JSON.stringify(render(structuredClone(raw), indexer))).toBe(JSON.stringify(first));
+    const extended = [...structuredClone(raw), { role: "user", content: "continue" }, { role: "assistant", content: [] }];
+    expect(JSON.stringify(render(extended, indexer).slice(0, raw.length))).toBe(JSON.stringify(first));
+  });
+
+  it("keeps dedup alias prompts while shrinking the recoverable canonical prompt", () => {
+    const indexer = new ToolCallIndexer();
+    const raw = history();
+    indexer.addBatch({ turnIndex: 0, timestamp: 0, assistantText: "", toolCalls: [{ toolCallId: "call", toolName: "subagent", args: raw[0].content[0].arguments, resultText: "original output", isError: false, resultTimestamp: 10 }] }, () => {});
+    indexer.registerSummaryRefs([{ shortId: "t6", toolCallId: "call", resultTimestamp: 10 }]);
+    indexer.registerDuplicate("alias@20", "call@10", () => {});
+    raw.push({ role: "assistant", content: [{ type: "toolCall", id: "alias", name: "subagent", arguments: { prompt: "alias".repeat(120) } }] }, { ...raw[1], toolCallId: "alias", timestamp: 20 });
+    const out = render(raw, indexer);
+    expect(out[0].content[0].arguments.prompt).toBe('<purged-args size="600" ref="t6"/>');
+    expect(out[2]).toBe(raw[2]);
+    expect(out[1].content[0].text).toContain("`t6`");
+    expect(out[3].content[0].text).toContain("`t6`");
+    expect(indexer.getRecord("call@10")?.args).toEqual({ prompt });
+  });
+});
+
 const enabledCC: ChainCompressionConfig = {
   enabled: true,
   rollingWindow: 0,

package/src/pruner.ts

@@ -46,9 +46,9 @@ export function sizeMessages(messages: any[]): number {
  * See src/supersede.ts. Runs before phase 3 so a superseded read inside a
  * compressed chain relocates as the stub, not the verbatim body.
  *
- * Phase 2 — error purge: replaces failed toolCall arg bodies with stubs after a
- * cooldown, reclaiming context from large `write`/`edit` arguments that will
- * never succeed. The toolResult error message stays visible.
+ * Phase 2 - argument purge: shrinks summarized toolCall arguments in the
+ * stub render and failed toolCall arguments after cooldown. Unsummarized
+ * toolResult error messages stay visible.
  *
  * Phase 3 — chain range prune: closed chains older than the rolling window
  * are dropped (middle assistant + toolResult messages) and replaced with a
@@ -75,9 +75,8 @@ export function sizeMessages(messages: any[]): number {
  *     the only consumer (`index.ts` live-reclaim) reads them solely under
  *     `if (result.pruned)`.
  *
- * AssistantMessage tool-call blocks (which carry the IDs) are kept
- * unchanged so the model can still reference them by id when calling
- * `context_tree_query`.
+ * Tool-call ids, names, and result pairing stay unchanged; eligible argument
+ * strings shrink with a ref for recovery through `context_tree_query`.
  */
 export function pruneMessages(
   messages: any[],
@@ -91,6 +90,7 @@ export function pruneMessages(
 ): { messages: any[]; pruned: boolean; beforeChars: number; afterChars: number } {
   // Phase 1: stub-replace summarized tool results
   let pruned = false;
+  const summarizedRefs = new Map<string, string>();
   const inGrace = inGraceRecoveryToolCallIds(messages, recoveryGraceTurns);
   const next = messages.map((msg) => {
     if (msg.role !== "toolResult") return msg;
@@ -124,6 +124,7 @@ export function pruneMessages(
     }
     pruned = true;
     const ref = indexer.getShortRefForToolCallId(lookupKey) ?? msg.toolCallId;
+    if (!indexer.isDedupAlias(lookupKey)) summarizedRefs.set(key, ref);
     const text = record?.spillPath
       ? [
           `[Oversized output spilled to file — ${record.spillBytes ?? "?"} bytes.]`,
@@ -155,9 +156,9 @@ export function pruneMessages(
     }
   }
 
-  // Phase 2: error purge - shrink long strings in failed toolCall args after cooldown
+  // Phase 2: argument purge - summarized now, errored after cooldown
   if (errorPurge?.enabled) {
-    const afterPurge = purgeErroredArgs(current, errorPurge);
+    const afterPurge = purgeErroredArgs(current, errorPurge, summarizedRefs);
     if (afterPurge !== current) {
       current = afterPurge;
       pruned = true;

package/src/query-tool.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { pruneWithZeroSweepAssertion, expectNoOrphanToolResults } from "./test-support.js";
 import { registerQueryTool } from "./query-tool.js";
 import { imageDigest } from "./batch-capture.js";
 import { ToolCallIndexer } from "./indexer.js";
@@ -91,6 +92,33 @@ describe("context_tree_query image recovery", () => {
 });
 
 describe("context_tree_query occurrence handling", () => {
+  test("alias ref recovers unclipped canonical arguments after rendering, not alias arguments", async () => {
+    const idx = new ToolCallIndexer();
+    const prompt = "canonical".repeat(80);
+    const aliasPrompt = "alias".repeat(120);
+    idx.addBatch({ turnIndex: 0, timestamp: 0, assistantText: "", toolCalls: [{ toolCallId: "canonical", toolName: "subagent", args: { prompt }, resultText: "shared original output", isError: false, resultTimestamp: 10 }] }, () => {});
+    idx.registerSummaryRefs([{ shortId: "t6", toolCallId: "canonical", resultTimestamp: 10 }]);
+    idx.registerDuplicate("alias@20", "canonical@10", () => {});
+    const raw = [
+      { role: "assistant", content: [{ type: "toolCall", id: "canonical", name: "subagent", arguments: { prompt } }] },
+      { role: "toolResult", toolCallId: "canonical", toolName: "subagent", timestamp: 10, content: [{ type: "text", text: "shared original output" }] },
+      { role: "assistant", content: [{ type: "toolCall", id: "alias", name: "subagent", arguments: { prompt: aliasPrompt } }] },
+      { role: "toolResult", toolCallId: "alias", toolName: "subagent", timestamp: 20, content: [{ type: "text", text: "shared original output" }] },
+    ];
+    expectNoOrphanToolResults(raw);
+    const out = pruneWithZeroSweepAssertion(raw, idx, undefined, { enabled: true, minArgChars: 300, cooldownTurns: 2 }).messages;
+    expectNoOrphanToolResults(out);
+    expect(out[0].content[0].arguments.prompt).toBe(`<purged-args size="${prompt.length}" ref="t6"/>`);
+    expect(out[2].content[0].arguments.prompt).toBe(aliasPrompt);
+    const aliasRef = idx.getShortRefForToolCallId("alias@20");
+    expect(aliasRef).toBe("t6");
+    expect(idx.getRecordsForId(aliasRef!)[0].args).toEqual({ prompt });
+    const text = await runTool(idx, [aliasRef!]);
+    expect(text).toContain(`Args: ${JSON.stringify({ prompt }, null, 2)}`);
+    expect(text).toContain("shared original output");
+    expect(text).not.toContain(aliasPrompt);
+    expect(text).not.toContain("<purged-args");
+  });
   test("a bare id with two occurrences returns both blocks, chronologically", async () => {
     const idx = new ToolCallIndexer();
     capture(idx, "bash_23", 2150, "SECOND", 1);

package/src/supersede.test.ts

@@ -7,9 +7,9 @@ import {
   findSuperseded,
   lowerFloor,
   supersededStub,
-  type SupersedeState,
 } from "./supersede.js";
 import { isProtected } from "./protected.js";
+import { expectNoOrphanToolResults } from "./test-support.js";
 import { occKey } from "./occurrence-key.js";
 
 const cfg = { protectedTools: ["phase_tracker"], protectedPaths: ["**/skills/**/*.md"] };
@@ -42,9 +42,15 @@ describe("findSuperseded", () => {
     expect(findSuperseded(msgs, prot).map((c) => c.toolCallId)).toEqual(["a", "b"]);
   });
 
-  test("different offset/limit slices of one path -> older is a candidate", () => {
+  test("different offset/limit slices of one path -> neither is a candidate", () => {
     const msgs = [...call("a", 10, { path: SKILL, offset: 1, limit: 400 }), ...call("b", 20, { path: SKILL, offset: 400, limit: 50 })];
-    expect(findSuperseded(msgs, prot).map((c) => c.toolCallId)).toEqual(["a"]);
+    expectNoOrphanToolResults(msgs);
+    expect(findSuperseded(msgs, prot)).toEqual([]);
+    const state = createSupersedeState();
+    state.floor = 0;
+    const out = applySupersede(msgs, state, prot);
+    expect(out).toBe(msgs);
+    expectNoOrphanToolResults(out);
   });
 
   test("two paths interleaved -> per-path winners and candidates", () => {
@@ -153,6 +159,70 @@ describe("findSuperseded", () => {
   });
 });
 
+type RangeRead = { offset?: unknown; limit?: unknown; cap?: string; text?: string; path?: string };
+const oversizedLine = `[Line 1 is 61.2KB, exceeds 50.0KB limit. Use bash: sed -n '1p' ${SKILL} | head -c 51200]`;
+const cap1800 = "[Showing lines 1-1800 of 3000 (50.0KB limit). Use offset=1801 to continue.]";
+const cap2000 = "[Showing lines 1-2000 of 3000. Use offset=2001 to continue.]";
+
+describe("delivered range coverage", () => {
+  const cases: [string, RangeRead[], string[]][] = [
+    ["full/full", [{}, {}], ["r0"]],
+    ["tail then oversized-first-line warning", [{ offset: 2001 }, { text: oversizedLine }], []],
+    ["oversized-first-line warning then full", [{ text: oversizedLine }, {}], ["r0"]],
+    ["disjoint chunks", [{ limit: 2000 }, { offset: 2001 }], []],
+    ["chunk then capped full", [{ limit: 2000 }, { cap: cap2000 }], ["r0"]],
+    ["tail then capped full", [{ offset: 2001, limit: 1000 }, { cap: cap2000 }], []],
+    ["full then chunk", [{}, { limit: 50 }], []],
+    ["chunk1/chunk2/chunk1", [{ limit: 2000 }, { offset: 2001 }, { limit: 2000 }], ["r0"]],
+    ["equal capped full reads", [{ cap: cap2000 }, { cap: cap2000 }], ["r0"]],
+    ["byte-capped limit then capped full", [{ limit: 2500, cap: cap1800 }, { cap: cap2000 }], ["r0"]],
+    ["capped full then byte-capped limit", [{ cap: cap2000 }, { limit: 2500, cap: cap1800 }], []],
+    ["zero offset", [{ offset: 0, limit: 100 }, {}], ["r0"]],
+    ["null offset full then chunk", [{ offset: null }, { limit: 50 }], []],
+    ["null offset limited", [{ limit: 50 }, { offset: null, limit: 50 }], ["r0"]],
+    ["negative offset", [{ offset: -10, limit: 50 }, { limit: 50 }], ["r0"]],
+    ["null limit is open", [{ limit: null }, { limit: 50 }], []],
+    ["string values are open", [{ offset: "2001", limit: "50" }, { limit: 50 }], []],
+    ["later string values cover full", [{}, { offset: "2001", limit: "50" }], ["r0"]],
+    ["later null limit covers full", [{}, { limit: null }], ["r0"]],
+    ["zero limit covers nothing", [{ limit: 50 }, { limit: 0 }], []],
+    ["negative limit covers nothing", [{ limit: 50 }, { limit: -1 }], []],
+    ["empty cannot cover empty", [{ limit: 0 }, { limit: -1 }], []],
+    ["nonempty covers empty", [{ offset: 2001, limit: 0 }, { limit: 50 }], ["r0"]],
+    ["partial overlap", [{ offset: 10, limit: 50 }, { offset: 20, limit: 50 }], []],
+    ["equal end with earlier start", [{ offset: 10, limit: 41 }, { limit: 50 }], ["r0"]],
+    ["different paths", [{ limit: 50 }, { path: OTHER }], []],
+    ["intermediate covering read", [{ limit: 50 }, { limit: 100 }, { offset: 2001 }], ["r0"]],
+    ["offset byte cap", [{ offset: 1001, limit: 2500, cap: "[Showing lines 1001-2800 of 4000 (50.0KB limit). Use offset=2801 to continue.]" }, { offset: 1001, limit: 1800 }], ["r0"]],
+    ["ordinary continuation keeps limit", [{ limit: 50, cap: "[2950 more lines in file. Use offset=51 to continue.]" }, { limit: 50 }], ["r0"]],
+    ["nonterminal notice is body text", [{ cap: cap2000 + "\nmore body" }, { limit: 2000 }], []],
+  ];
+
+  test.each(cases)("%s", (_name, reads, expected) => {
+    const msgs = reads.flatMap(({ cap, text, ...args }, i) => {
+      const pair = call(`r${i}`, i * 10, { path: SKILL, ...args });
+      if (text) pair[1].content[0].text = text;
+      if (cap) pair[1].content[0].text += `\n\n${cap}`;
+      return pair;
+    });
+    expectNoOrphanToolResults(msgs);
+    expect(findSuperseded(msgs, prot).map((c) => c.toolCallId)).toEqual(expected);
+    const state = createSupersedeState();
+    expect(applySupersede(msgs, state, prot)).toBe(msgs);
+    state.floor = 0;
+    const out = applySupersede(msgs, state, prot);
+    expectNoOrphanToolResults(out);
+    if (expected.length === 0) expect(out).toBe(msgs);
+    for (let i = 0; i < reads.length; i++) {
+      if (expected.includes(`r${i}`)) expect(out[i * 2 + 1].content[0].text).toBe(supersededStub(SKILL));
+      else expect(out[i * 2 + 1]).toBe(msgs[i * 2 + 1]);
+    }
+    const sticky = applySupersede(msgs, state, prot);
+    expect(sticky).toEqual(out);
+    expectNoOrphanToolResults(sticky);
+  });
+});
+
 describe("floor helpers", () => {
   test("lowerFloor sets when undefined, lowers monotonically, ignores undefined input", () => {
     const s = createSupersedeState();

package/src/supersede.ts

@@ -1,11 +1,7 @@
 import { normalizePath } from "./protected.js";
 import { occKey, resultTimestampOf } from "./occurrence-key.js";
 
-/**
- * Protected reads are never indexed, so nothing else in the pipeline ever
- * collapses a re-read of the same skill file. This module keeps only the
- * newest protected read per `args.path` verbatim (spec 2026-09-07).
- */
+/** Protected reads stay verbatim until a later same-path read covers their delivered lines. */
 export interface SupersededCandidate {
   toolCallId: string;
   path: string;
@@ -49,11 +45,34 @@ export function supersededStub(path: string): string {
 
 export type IsProtectedFn = (toolName: string, args: unknown) => boolean;
 
+interface DeliveredRange {
+  start: number;
+  end: number;
+}
+
+function deliveredRange(args: Record<string, unknown>, result: any): DeliveredRange {
+  const start = typeof args.offset === "number" ? Math.max(1, args.offset) : 1;
+  const limit = args.limit;
+  let end = typeof limit === "number" ? (limit <= 0 ? start - 1 : start + limit - 1) : Infinity;
+  for (const block of result.content ?? []) {
+    if (block?.type !== "text" || typeof block.text !== "string") continue;
+    if (/^\[Line \d+ is [^,]+, exceeds [^ ]+ limit\. Use bash: .*\]$/.test(block.text)) return { start, end: start - 1 };
+    const cap = block.text.match(/(?:^|\n)\[Showing lines \d+-(\d+) of \d+(?: \([^)]*limit\))?\. Use offset=\d+ to continue\.\]$/);
+    if (cap) end = Math.min(end, Number(cap[1]));
+  }
+  return { start, end };
+}
+
+function covers(later: DeliveredRange, earlier: DeliveredRange): boolean {
+  if (later.end < later.start) return false;
+  return earlier.end < earlier.start || (later.start <= earlier.start && later.end >= earlier.end);
+}
+
 export function findSuperseded(messages: any[], isProtected: IsProtectedFn): SupersededCandidate[] {
   // Provider ids repeat across turns and an aborted call has no result, so pairing
   // uses the same per-turn open-set model as orphan-sweep, not a global per-id cursor.
   let open = new Map<string, any>();
-  const byPath = new Map<string, SupersededCandidate[]>();
+  const byPath = new Map<string, { candidate: SupersededCandidate; range: DeliveredRange }[]>();
 
   for (let i = 0; i < messages.length; i++) {
     const m = messages[i];
@@ -77,16 +96,25 @@ export function findSuperseded(messages: any[], isProtected: IsProtectedFn): Sup
         timestamp: resultTimestampOf(m.timestamp),
         resultIndex: i,
       };
+      const occurrence = { candidate: cand, range: deliveredRange(args, m) };
       const list = byPath.get(path);
-      if (list) list.push(cand);
-      else byPath.set(path, [cand]);
+      if (list) list.push(occurrence);
+      else byPath.set(path, [occurrence]);
       continue;
     }
     open = new Map();
   }
 
   const out: SupersededCandidate[] = [];
-  for (const list of byPath.values()) for (let i = 0; i < list.length - 1; i++) out.push(list[i]);
+  for (const list of byPath.values()) {
+    for (let i = 0; i < list.length - 1; i++) {
+      for (let j = i + 1; j < list.length; j++) {
+        if (!covers(list[j].range, list[i].range)) continue;
+        out.push(list[i].candidate);
+        break;
+      }
+    }
+  }
   out.sort((a, b) => a.resultIndex - b.resultIndex);
   return out;
 }