pi-condense 2.4.3 → 2.5.0

package/CHANGELOG.md

@@ -7,6 +7,10 @@ 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.5.0] - 2026-08-05
+
+- **Removed the main-loop thinking strip (breaking: `contextPrune.thinkingStrip.*` no longer read).** The feature assumed thinking blocks we send are thinking blocks we are billed for. Verified against the live Anthropic API (`count_tokens` and real billed usage agree to the token), the actual rule is: thinking in a *closed* cycle bills 0 input tokens, and thinking in an *open* cycle survives only as an unbroken run starting at the cycle's first assistant turn — any gap discards everything after it. `keepLastTurns` kept the **last** K, so firing it punched a gap at the front and the API dropped all of it: the model received no thinking either way, and the no-gap → gap transition cost a full cache invalidation (measured +33% in a controlled 24-tool-call A/B, $0.6430 → $0.8531, with turn 17 rewriting 63113 tokens at 0% reuse). Across 58 sessions / 1233 open cycles the strip fired 253 times and reached its ~130-turn break-even twice. It was also redundant: chain compression's synthetic block is a `role: "user"` text message, which closes the cycle and frees all prior thinking server-side at zero cache cost. `pruneMessages` drops to three phases (`stub-replace → error-purge → chain-range-prune`); `src/thinking-strip.ts`, `ThinkingStripConfig`, `KEEP_LAST_TURNS_PRESETS`, the two `/pruner` settings entries, and `PruneFrontier.thinkingStripBoundaryTimestamp` are gone. A leftover `thinkingStrip` block in `settings.json` is inert and round-trips untouched (`normalize()` never filters unknown keys); a persisted `context-prune-frontier` entry carrying the old boundary field loads and is ignored. Rationale and measurements: `doc/specs/2026-08-05-remove-thinking-strip.md`.
+
 ## [2.4.3] - 2026-08-04
 
 - **Flush-gated, timestamp-keyed thinking strip ([#3](https://github.com/jjuraszek/pi-condense/issues/3)).** Phase 4 (`stripOldThinking`, `src/thinking-strip.ts`) recomputed its keep-window from the *live assistant count on every `context` render*, so each turn the `(count - keepLastTurns)`-th assistant slid forward and its thinking was stripped **deep in history**. pi-ai sets prompt-cache breakpoints only at `tools + system + last message` (verified in `@earendil-works/pi-ai` `api/anthropic-messages.js` `convertMessages` - no in-history breakpoint), so every deep mutation busted the cached suffix - roughly every render inside a tool loop. The strip boundary is now a **flush-computed, persisted assistant-message timestamp** (`thinkingStripBoundaryTimestamp`, added to the `PruneFrontier` snapshot on the existing `context-prune-frontier` entry): fixed between flushes so consecutive renders are byte-stable in their historical prefix (the cache survives a whole tool loop), advancing only on a non-empty flush (piggybacking summarization's own cache bust - zero marginal busts), monotonically clamped (never re-adds thinking to an already-stripped message, even when `keepLastTurns` is increased mid-session), and keyed by timestamp rather than array index so it is robust to phase-3 chain-range middle drops. An absent boundary (pre-feature sessions, pre-first-flush) falls back to the original live-count window verbatim. Additive optional field, fully backward-compatible; **no new config key**, `keepLastTurns` presets unchanged. `PRUNING.md` cache-impact model corrected. Turns the old k-busts-per-render into ~1-per-request.

package/PRUNING.md

@@ -28,12 +28,11 @@
 10. [Chain Compression](#chain-compression)
     - [Protected-output relocation](#protected-output-relocation)
 11. [Error Purge](#error-purge)
-12. [Main-loop Thinking Strip](#main-loop-thinking-strip)
-13. [Why Summarization Works: Research Evidence](#why-summarization-works-research-evidence)
+12. [Why Summarization Works: Research Evidence](#why-summarization-works-research-evidence)
     - [SUPO — Summarization augmented Policy Optimization](#supo--summarization-augmented-policy-optimization)
     - [ReSum — Recursive Summarization for Long-Horizon Agents](#resum--recursive-summarization-for-long-horizon-agents)
     - [ACON — Agent Context Optimization](#acon--agent-context-optimization)
-14. [Summary](#summary)
+13. [Summary](#summary)
 
 ---
 
@@ -688,7 +687,7 @@ The last attempted prune boundary is persisted as `context-prune-frontier` so `f
 - **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) = JSON.stringify(messages).length`, comparing the input array before pruning to the result after. Estimated tokens = chars / 4. The measurement covers all four reclaim mechanisms in a single point (stub-replace, error-purge, chain-range-prune, thinking-strip); appears on the status line as `│ prune: ON · 92k->14k (-85%) │` once at least one prune has occurred (the `│ … │` wrapper keeps the segment visually isolated in the shared footer, load-order independent).
+- **Live reclaim ratio:** measured once per `pruneMessages` call via `sizeMessages(messages) = JSON.stringify(messages).length`, comparing the input array before pruning to the result after. Estimated tokens = chars / 4. The measurement covers all three reclaim mechanisms in a single point (stub-replace, error-purge, chain-range-prune); appears on the status line as `│ prune: ON · 92k->14k (-85%) │` once at least one prune has occurred (the `│ … │` wrapper keeps the segment visually isolated in the shared footer, load-order independent).
 - **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
@@ -863,6 +862,8 @@ A **closed chain** is a span of messages from one user message through any numbe
 | Final text-only assistant | **Kept**, thinking blocks stripped (safe — no following tool cycle depends on the signature) |
 | Synthetic `<compressed-chain>` user message | **Injected** immediately after the start user message |
 
+**Why there is no separate thinking strip.** The synthetic `<compressed-chain>` block is injected as a `role: "user"` text message, which Anthropic reads as a genuine user turn. That closes the assistant cycle, and the API drops every prior thinking block from the context window server-side - verified against the live API: the same 8-turn loop bills 3152 thinking tokens with a full `toolResult` history and 0 once a user text block precedes the final assistant. So chain compression already reclaims thinking mass for free, as a side effect of the range drop that was rewriting that region anyway. Stub replacement does not have this effect: it preserves `role: "toolResult"`, so the cycle stays open. A dedicated strip phase shipped through v2.4.3; removed in v2.5.0 - see `doc/specs/2026-08-05-remove-thinking-strip.md`.
+
 ### Transform composition order
 
 ```
@@ -870,14 +871,13 @@ raw messages from session
   │
   ├─ [1] tool-result stub-replace   (per-batch; existing)
   ├─ [2] error-purge                (phase 2)
-  ├─ [3] chain-range-prune          (runs AFTER stubs)
-  │        for each compressed chain:
-  │          drop middle assistants (by toolCallId overlap)
-  │          drop middle toolResults (by toolCallId)
-  │          suppress per-batch summaries (by toolCallRefs overlap)
-  │          inject <compressed-chain> after start user
-  │          strip thinking from final assistant
-  └─ [4] thinking-strip             (keep thinking on last K assistant turns)
+  └─ [3] chain-range-prune          (runs AFTER stubs)
+           for each compressed chain:
+             drop middle assistants (by toolCallId overlap)
+             drop middle toolResults (by toolCallId)
+             suppress per-batch summaries (by toolCallRefs overlap)
+             inject <compressed-chain> after start user
+             strip thinking from final assistant
 ```
 
 ### Identification model
@@ -981,7 +981,7 @@ Error purge replaces those arg bodies with compact stubs after the error has coo
 **Transform position:** Error purge runs in Phase 2, after stub-replace and before chain range prune.
 
 ```
-[stub-replace] → [error-purge] → [chain-range-prune] → [thinking-strip]
+[stub-replace] → [error-purge] → [chain-range-prune]
 ```
 
 **Config keys:**
@@ -994,52 +994,6 @@ Error purge replaces those arg bodies with compact stubs after the error has coo
 
 ---
 
-## Main-loop Thinking Strip
-
-Chain compression and the summarizer target *tool* mass. But in long single-agent sessions the dominant cost is often **assistant `thinking` blocks**: on Opus 4.5+/Sonnet 4.6+ the API retains every prior-turn thinking block by default, and pi-ai replays them all (with signatures) on every request. One autonomous ops session held ~405 K tokens (~80% of a 500 K window) in thinking alone, untouched by every other strategy — chain compression only fires on *closed* spans, and that session was one long open span.
-
-Thinking strip is a deterministic, zero-LLM transform (Phase 4) that keeps `thinking` blocks only on the last `keepLastTurns` **assistant turns** and strips them from older assistant messages, leaving each message's `text` and `toolCall` blocks intact.
-
-### Turn unit
-
-`keepLastTurns` counts **assistant messages**, not user-bounded spans. The target failure mode is a single long open chain (zero subagents, near-zero user turns) where a span-based window would keep everything. Counting assistant turns directly bounds thinking accumulation regardless of whether any chain closes.
-
-### Provider safety
-
-Anthropic's extended-thinking contract during tool use:
-
-- Only the **last assistant turn's** thinking is required; "you can omit thinking blocks from prior assistant role turns" and the API auto-filters them.
-- A message's thinking blocks must be dropped **all-or-nothing** ("the entire sequence of consecutive thinking blocks must match the outputs … you can't rearrange or modify the sequence"). The strip reuses `withoutThinkingBlocks`, which removes every thinking block (and its signature) from a message.
-
-`keepLastTurns` is clamped to `>= 1`, so the most-recent assistant turn — the one that may be awaiting tool results — always keeps its thinking. This is the minimum safe window; the default of 16 is far above the floor and preserves recent reasoning continuity.
-
-### Transform position
-
-Thinking strip runs **last**, after chain-range-prune, at render time:
-
-```
-[stub-replace] → [error-purge] → [chain-range-prune] → [thinking-strip]
-```
-
-The keep-window is a flush-computed assistant-message timestamp (the `keepLastTurns`-back boundary over the **raw** session branch — see the **Cache impact** note below), not a render-time recount over the post-phase-3 survivors. So when chain compression drops closed middle turns inside the window, fewer than `keepLastTurns` *surviving* turns may retain thinking — deliberate, and it only ever strips more, never re-adds. In a session with no closed chains, Phases 1–3 may be no-ops and thinking strip does all the work. Where chain compression *does* fire, the two cooperate: chain compression drops whole old middle turns (including their thinking); thinking strip mops up thinking in the surviving recent / in-flight turns beyond the boundary.
-
-### Cache impact
-
-pi-ai serializes prompt-cache breakpoints only at `tools`, `system`, and the last conversation message (verified in `@earendil-works/pi-ai` `api/anthropic-messages.js` `convertMessages`) - there is **no in-history breakpoint**. So the strip boundary is flush-gated, not per-render: it is a persisted assistant-message timestamp on the `context-prune-frontier` entry that stays fixed between flushes and advances only on a non-empty flush. Between flushes every render is byte-stable in its historical prefix, so the cache holds through a whole tool loop; the boundary moves at most once per flush (~once per request), turning the old k-busts-per-render into ~1-per-request. That residual bust is not always free: for a request shorter than `keepLastTurns` turns the boundary (tail-K) sits deeper than the current request's just-summarized tool results, so thinking-strip is the dominant invalidator, ~1 deep reprocess per request; for a request longer than `keepLastTurns` turns summarization's stub-replace reaches deeper and subsumes it (~0 marginal). Retained thinking is bounded to `keepLastTurns` raw-session turns, drifting up to `keepLastTurns + turns-since-flush` between flushes (deliberate: the frozen boundary is what buys cache stability). Note `error-purge` still mutates old history off a live per-render count, an independent cache-bust source not addressed here.
-
-### Recovery
-
-Stripped thinking is **not** recoverable via `context_tree_query` — unlike tool outputs, thinking blocks are not indexed. The raw thinking remains in the session JSONL on disk (the `context` hook never mutates storage); reloading the session without the extension, or reading the file directly, shows the original blocks. Thinking is transient model-internal reasoning, so drop-without-recovery is intentional.
-
-### Config keys
-
-| Key | Default | Description |
-|---|---|---|
-| `thinkingStrip.enabled` | `true` | Master toggle (gated behind the top-level `enabled`) |
-| `thinkingStrip.keepLastTurns` | `16` | Keep thinking on the last N assistant turns; strip older. Clamped to `>= 1` |
-
----
-
 ## Summary
 
 | Concern | How Pruning Addresses It |

package/index.ts

@@ -36,7 +36,6 @@ import { PruneFrontierTracker } from "./src/frontier.js";
 import { BlockRefIssuer } from "./src/block-refs.js";
 import { compressEligible } from "./src/chain-compressor.js";
 import { detectChains, withClosingMessage } from "./src/chain-detector.js";
-import { computeThinkingBoundary } from "./src/thinking-strip.js";
 import { inGraceRecoveryToolCallIds } from "./src/recovery-grace.js";
 import { shouldBudgetFlush, shouldDeltaFlush, usageFraction } from "./src/budget.js";
 import { spillOversizedBatch } from "./src/spill.js";
@@ -487,34 +486,15 @@ export default function (pi: ExtensionAPI) {
               ? "skipped-deduped"
               : "skipped-trivial";
 
-      // Raw session branch, unwrapped once and shared by the thinking-strip boundary
-      // computation and the chain-compression block below - both walk it, so avoid a
-      // second O(session-size) pass on every flush. Only materialized when at least
-      // one consumer is enabled.
+      // Raw session branch, unwrapped once for the chain-compression block below.
+      // Only materialized when chain compression is enabled.
       let branchMessages: any[] | undefined;
-      if (currentConfig.value.thinkingStrip.enabled || currentConfig.value.chainCompression.enabled) {
+      if (currentConfig.value.chainCompression.enabled) {
         branchMessages = ctx.sessionManager.getBranch()
           .filter((e: any) => e.type === "message" && e.message)
           .map((e: any) => e.message);
       }
 
-      // Flush-gated thinking-strip boundary: recompute the (count - keepLastTurns)-th
-      // assistant timestamp over the RAW branch (+ the not-yet-persisted closing
-      // assistant), monotonically clamped. Stays on the frontier snapshot so renders
-      // between flushes read a fixed value and keep the cache prefix. Carries prev
-      // through when disabled. Must run regardless of chainCompression.enabled.
-      let thinkingBoundary = frontier.get()?.thinkingStripBoundaryTimestamp;
-      if (currentConfig.value.thinkingStrip.enabled) {
-        const assistantTimestamps = withClosingMessage(branchMessages!, options.closingMessage)
-          .filter((m: any) => m?.role === "assistant" && typeof m.timestamp === "number")
-          .map((m: any) => m.timestamp);
-        thinkingBoundary = computeThinkingBoundary(
-          assistantTimestamps,
-          currentConfig.value.thinkingStrip.keepLastTurns,
-          thinkingBoundary,
-        );
-      }
-
       const frontierSnapshot: PruneFrontier = {
         lastAttemptedToolCallId: lastTC.toolCallId,
         lastAttemptedToolName: lastTC.toolName,
@@ -525,7 +505,6 @@ export default function (pi: ExtensionAPI) {
         rawCharCount: totalRawCharCount,
         summaryCharCount: totalSummaryCharCount,
         outcome: flushOutcome,
-        thinkingStripBoundaryTimestamp: thinkingBoundary,
       };
 
       try {
@@ -556,7 +535,7 @@ export default function (pi: ExtensionAPI) {
         try {
           // message_end fires before pi persists the closing assistant, so thread it
           // in here; otherwise the newest chain reads as open and K over-retains by 1.
-          // branchMessages was unwrapped once above (shared with the boundary block).
+          // branchMessages was unwrapped once above, gated on chainCompression.enabled.
           const chains = detectChains(withClosingMessage(branchMessages!, options.closingMessage), protectionPredicate);
           const inGrace = inGraceRecoveryToolCallIds(branchMessages!, currentConfig.value.recoveryGraceTurns);
           const { compressedEntries } = await compressEligible(
@@ -846,19 +825,16 @@ export default function (pi: ExtensionAPI) {
 
     // pruneMessages is the single source of truth for "is there work to do".
     // It returns the original array reference (pruned: false) only when none of
-    // the four phases changed anything; index/registry emptiness alone does not
-    // imply a no-op, since error-purge (phase 2) and thinking-strip (phase 4)
-    // prune independently of them. Calling it unconditionally is safe and avoids
-    // a split gate here.
+    // the three phases changed anything; index/registry emptiness alone does not
+    // imply a no-op, since error-purge (phase 2) prunes independently of them.
+    // Calling it unconditionally is safe and avoids a split gate here.
     const result = pruneMessages(
       messages,
       indexer,
       currentConfig.value.chainCompression,
       currentConfig.value.purgeErrors,
-      currentConfig.value.thinkingStrip,
       currentConfig.value,
       currentConfig.value.recoveryGraceTurns,
-      frontier.get()?.thinkingStripBoundaryTimestamp,
     );
     if (result.pruned) {
       messages = result.messages;

package/package.json

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

@@ -16,7 +16,6 @@ import {
   SUMMARIZER_MAX_TIMEOUT_PRESETS,
   AUTO_BUDGET_PRESETS,
   ROLLING_WINDOW_PRESETS,
-  KEEP_LAST_TURNS_PRESETS,
   PURGE_COOLDOWN_PRESETS,
   PURGE_MIN_ARG_PRESETS,
   DEFAULT_CONFIG,
@@ -648,22 +647,6 @@ export function registerCommands(
               currentValue: String(config.chainCompression.fuseRangeSummary),
               description: `Fuse a compressed chain's per-batch summaries into one cohesive LLM summary (one extra summarizer call per multi-batch span). Off keeps the per-batch concatenation. Currently ${config.chainCompression.fuseRangeSummary ? "ON" : "OFF"}.`,
             },
-            {
-              id: "thinkingStripEnabled",
-              label: "Thinking strip",
-              values: ["true", "false"],
-              currentValue: String(config.thinkingStrip.enabled),
-              description: `Strip thinking blocks from assistant turns older than the last ${config.thinkingStrip.keepLastTurns}. Reclaims main-loop thinking accumulation; no-op under ${config.thinkingStrip.keepLastTurns} turns. Currently ${config.thinkingStrip.enabled ? "ON" : "OFF"}.`,
-            },
-            {
-              id: "thinkingStripKeepLastTurns",
-              label: "Thinking keep (last N turns)",
-              values: KEEP_LAST_TURNS_PRESETS.map((p) => p.value),
-              currentValue: KEEP_LAST_TURNS_PRESETS.some((p) => p.value === String(config.thinkingStrip.keepLastTurns))
-                ? String(config.thinkingStrip.keepLastTurns)
-                : KEEP_LAST_TURNS_PRESETS[2].value,
-              description: `Keep thinking on the last N assistant turns; strip older. Counts assistant turns, not chains. Currently ${config.thinkingStrip.keepLastTurns}.`,
-            },
             {
               id: "purgeErrorsEnabled",
               label: "Error purge",
@@ -801,14 +784,6 @@ export function registerCommands(
               newConfig.chainCompression = { ...newConfig.chainCompression, stripFinalAssistantThinking: newValue === "true" };
             } else if (id === "chainCompressionFuseRange") {
               newConfig.chainCompression = { ...newConfig.chainCompression, fuseRangeSummary: newValue === "true" };
-            } else if (id === "thinkingStripEnabled") {
-              newConfig.thinkingStrip = { ...newConfig.thinkingStrip, enabled: newValue === "true" };
-            } else if (id === "thinkingStripKeepLastTurns") {
-              const parsed = Number.parseInt(newValue, 10);
-              newConfig.thinkingStrip = {
-                ...newConfig.thinkingStrip,
-                keepLastTurns: Number.isFinite(parsed) && parsed >= 1 ? parsed : DEFAULT_CONFIG.thinkingStrip.keepLastTurns,
-              };
             } else if (id === "purgeErrorsEnabled") {
               newConfig.purgeErrors = { ...newConfig.purgeErrors, enabled: newValue === "true" };
             } else if (id === "purgeErrorsCooldown") {

package/src/config.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, beforeAll, afterAll } from "bun:test";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { DEFAULT_CONFIG } from "./types.js";
@@ -14,6 +14,7 @@ import { DEFAULT_CONFIG } from "./types.js";
  */
 let tmpDir: string;
 let loadConfig: typeof import("./config.js").loadConfig;
+let saveConfig: typeof import("./config.js").saveConfig;
 let settingsPath: typeof import("./config.js").settingsPath;
 
 beforeAll(async () => {
@@ -21,6 +22,7 @@ beforeAll(async () => {
   process.env.PI_CODING_AGENT_DIR = tmpDir;
   const mod = await import("./config.js");
   loadConfig = mod.loadConfig;
+  saveConfig = mod.saveConfig;
   settingsPath = mod.settingsPath;
 });
 
@@ -99,3 +101,27 @@ describe("loadConfig summarizer timeout normalization", () => {
     expect(config.summarizerIdleTimeoutMs).toBe(1234);
   });
 });
+
+describe("loadConfig backward compatibility with removed thinkingStrip key", () => {
+  it("loads without error and round-trips a stale contextPrune.thinkingStrip block unchanged", async () => {
+    const stale = { enabled: true, keepLastTurns: 16 };
+    await writeContextPrune({ thinkingStrip: stale });
+
+    const config = await loadConfig();
+
+    // thinkingStrip is no longer a recognized key: DEFAULT_CONFIG carries no
+    // such field, so nothing reads or acts on it.
+    expect((DEFAULT_CONFIG as unknown as Record<string, unknown>).thinkingStrip).toBeUndefined();
+    // normalize() spreads { ...DEFAULT_CONFIG, ...existing } and re-spreads
+    // the merge, so the unrecognized key survives verbatim on the loaded value.
+    expect((config as unknown as Record<string, unknown>).thinkingStrip).toEqual(stale);
+
+    // saveConfig() re-serializes the same config object it's given, so the
+    // stale block written above must still be present, byte-equivalent, after
+    // a full load -> save round trip through the real settingsPath() file.
+    await saveConfig(config);
+    const raw = await readFile(settingsPath(), "utf-8");
+    const written = JSON.parse(raw);
+    expect(written.contextPrune.thinkingStrip).toEqual(stale);
+  });
+});

package/src/frontier.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { PruneFrontierTracker } from "./frontier.js";
+import { pruneMessages } from "./pruner.js";
 import type { PruneFrontier } from "./types.js";
 
 const base: PruneFrontier = {
@@ -14,39 +15,159 @@ const base: PruneFrontier = {
   outcome: "summarized",
 };
 
-describe("PruneFrontierTracker.fromJSON - thinkingStripBoundaryTimestamp", () => {
-  test("round-trips the boundary field", () => {
+describe("PruneFrontierTracker.fromJSON", () => {
+  test("round-trips a full frontier", () => {
     const t = new PruneFrontierTracker();
-    t.fromJSON({ ...base, thinkingStripBoundaryTimestamp: 777 });
-    expect(t.get()?.thinkingStripBoundaryTimestamp).toBe(777);
+    t.fromJSON({ ...base });
+    expect(t.get()?.lastAttemptedToolCallId).toBe("tc1");
+    expect(t.get()?.outcome).toBe("summarized");
   });
 
-  test("absent boundary stays undefined (live-count fallback)", () => {
+  test("ignores an entry with no lastAttemptedToolCallId", () => {
     const t = new PruneFrontierTracker();
-    t.fromJSON({ ...base });
-    expect(t.get()?.thinkingStripBoundaryTimestamp).toBeUndefined();
+    t.fromJSON({} as PruneFrontier);
+    expect(t.get()).toBeNull();
+  });
+
+  test("tolerates a legacy entry carrying the removed thinkingStripBoundaryTimestamp", () => {
+    const t = new PruneFrontierTracker();
+    t.fromJSON({ ...base, thinkingStripBoundaryTimestamp: 777 } as PruneFrontier);
+    expect(t.get()?.lastAttemptedToolCallId).toBe("tc1");
+    expect((t.get() as any).thinkingStripBoundaryTimestamp).toBeUndefined();
   });
 });
 
-describe("PruneFrontierTracker.reconstructFromSession - boundary survives reload", () => {
-  test("reconstructs thinkingStripBoundaryTimestamp from a persisted frontier entry", () => {
+describe("PruneFrontierTracker.reconstructFromSession", () => {
+  test("reconstructs from a persisted frontier entry", () => {
     const t = new PruneFrontierTracker();
     const entries = [
-      { type: "custom", customType: "context-prune-frontier", data: { ...base, thinkingStripBoundaryTimestamp: 555 } },
+      { type: "custom", customType: "context-prune-frontier", data: { ...base, lastAttemptedTimestamp: 2000 } },
     ];
     const fakeCtx = { sessionManager: { getBranch: () => entries } } as any;
     t.reconstructFromSession(fakeCtx);
-    expect(t.get()?.thinkingStripBoundaryTimestamp).toBe(555);
+    expect(t.get()?.lastAttemptedTimestamp).toBe(2000);
   });
 
-  test("a persisted entry without the field reconstructs as undefined (live-count fallback)", () => {
+  // Spans frontier.ts + pruner.ts on purpose: proves a resumed legacy frontier carries
+  // no boundary into an *actively-pruning* pipeline, not just an inert one. Phase 1
+  // (stub-replace) and Phase 3 (chain-range-prune) are both wired live here -- a
+  // summarized toolResult gets stubbed and a chain entry produces a synthetic
+  // <compressed-chain> message -- and every surviving assistant turn, both older and
+  // newer than the legacy boundary, still carries its thinking block. This does not
+  // (and cannot) prove the deleted thinking-strip phase stays deleted; it proves the
+  // phases that remain do not touch thinking regardless of the legacy field's presence.
+  test("a legacy frontier entry with thinkingStripBoundaryTimestamp resumes without error and strips nothing", () => {
+    const legacyBoundary = 555;
     const t = new PruneFrontierTracker();
     const entries = [
-      { type: "custom", customType: "context-prune-frontier", data: { ...base } },
+      {
+        type: "custom",
+        customType: "context-prune-frontier",
+        data: { ...base, lastAttemptedTimestamp: 2000, thinkingStripBoundaryTimestamp: legacyBoundary },
+      },
     ];
     const fakeCtx = { sessionManager: { getBranch: () => entries } } as any;
-    t.reconstructFromSession(fakeCtx);
-    expect(t.get()).not.toBeNull();
-    expect(t.get()?.thinkingStripBoundaryTimestamp).toBeUndefined();
+
+    expect(() => t.reconstructFromSession(fakeCtx)).not.toThrow();
+    const frontier = t.get();
+    expect(frontier).not.toBeNull();
+    expect(frontier?.lastAttemptedToolCallId).toBe("tc1");
+    expect((frontier as any).thinkingStripBoundaryTimestamp).toBeUndefined();
+
+    const chainEntry = {
+      blockId: "b1",
+      startUserTimestamp: 560,
+      droppedToolCallIds: ["tc-old"],
+      finalAssistantTimestamp: 600,
+      toolRefs: ["told"],
+      compressedAt: 9999,
+    };
+
+    const indexer = {
+      isSummarized: (id: string) => id === "tc-old" || id === "tc-stub",
+      getShortRefForToolCallId: (id: string) => (id === "tc-stub" ? "t1" : id === "tc-old" ? "told" : undefined),
+      getRecord: () => undefined,
+      getChainEntries: () => [chainEntry],
+      getPerBatchSummaryTextForToolCallIds: () => "chain summary text",
+      findChainEntryByBlockId: () => undefined,
+    } as any;
+
+    const mkAsst = (ts: number) => ({
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "t", thinkingSignature: "s" },
+        { type: "text", text: "x" },
+      ],
+      timestamp: ts,
+      usage: {},
+      stopReason: "end_turn",
+    });
+    const mkAsstWithCall = (ts: number, toolCallId: string) => ({
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "t", thinkingSignature: "s" },
+        { type: "toolCall", id: toolCallId, name: "bash", arguments: {} },
+      ],
+      timestamp: ts,
+      usage: {},
+      stopReason: "tool_use",
+    });
+
+    // Timestamps straddle the legacy boundary: old code would have stripped the ones below it.
+    // tc-stub is a plain summarized tool result (phase 1 target, outside the chain).
+    // tc-old is dropped by the chain entry (phase 3 target).
+    const messages: any[] = [
+      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 1 },
+      mkAsst(legacyBoundary - 100),
+      mkAsstWithCall(legacyBoundary - 55, "tc-stub"),
+      {
+        role: "toolResult",
+        toolCallId: "tc-stub",
+        toolName: "bash",
+        content: [{ type: "text", text: "raw stub-target output" }],
+        isError: false,
+        timestamp: legacyBoundary - 50,
+      },
+      mkAsst(legacyBoundary - 1),
+      { role: "user", content: [{ type: "text", text: "do it" }], timestamp: 560 },
+      mkAsstWithCall(570, "tc-old"),
+      {
+        role: "toolResult",
+        toolCallId: "tc-old",
+        toolName: "bash",
+        content: [{ type: "text", text: "raw chain output" }],
+        isError: false,
+        timestamp: 575,
+      },
+      mkAsst(600),
+      mkAsst(legacyBoundary + 100),
+    ];
+
+    const { messages: out, pruned } = pruneMessages(messages, indexer, {
+      enabled: true,
+      rollingWindow: 0,
+      stripFinalAssistantThinking: false,
+      fuseRangeSummary: false,
+    });
+
+    // Non-vacuity: the pipeline actually did something.
+    expect(pruned).toBe(true);
+
+    // Phase 1 fired: the summarized-but-not-chained toolResult was stub-replaced.
+    const stubResult = out.find((m: any) => m.role === "toolResult" && m.toolCallId === "tc-stub") as any;
+    expect(stubResult).toBeDefined();
+    expect(stubResult.content[0].text).toContain("`t1`");
+    expect(stubResult.content[0].text).not.toContain("raw stub-target output");
+
+    // Phase 3 fired: the chain entry produced a synthetic compressed-chain message.
+    const synthetic = out.find(
+      (m: any) => m.role === "user" && typeof m.content?.[0]?.text === "string" && m.content[0].text.startsWith("<compressed-chain"),
+    );
+    expect(synthetic).toBeDefined();
+
+    // Every surviving assistant turn, older and newer than the legacy boundary, keeps thinking.
+    const assistants = out.filter((m: any) => m.role === "assistant");
+    expect(assistants.length).toBe(5);
+    expect(assistants.every((a: any) => a.content.some((c: any) => c.type === "thinking"))).toBe(true);
   });
 });

package/src/frontier.ts

@@ -32,7 +32,6 @@ export class PruneFrontierTracker {
       rawCharCount: data.rawCharCount ?? 0,
       summaryCharCount: data.summaryCharCount ?? 0,
       outcome: data.outcome ?? "summarized",
-      thinkingStripBoundaryTimestamp: data.thinkingStripBoundaryTimestamp,
     };
   }
 

package/src/pruner.test.ts

@@ -1,7 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { pruneMessages, sizeMessages } from "./pruner.js";
-import type { ChainCompressionConfig, ChainCompressionEntry, ThinkingStripConfig } from "./types.js";
-import { ToolCallIndexer } from "./indexer.js";
+import type { ChainCompressionConfig, ChainCompressionEntry } from "./types.js";
 
 // Minimal mock exposing only the ToolCallIndexer surface that pruneMessages calls.
 function makeMockIndexer({
@@ -375,7 +374,7 @@ describe("pruneMessages", () => {
     expect(pruned).toBe(false);
   });
 
-  it("composes stub-replace (Phase 1) with thinking-strip (Phase 4)", () => {
+  it("leaves thinking blocks on every assistant turn (no thinking-strip phase)", () => {
     const indexer = makeMockIndexer({ summarized: new Set(["c10"]), shortRefs: new Map([["c10", "t1"]]) });
     const mkAsst = (ts: number) => ({
       role: "assistant",
@@ -394,40 +393,17 @@ describe("pruneMessages", () => {
       messages.push(mkAsst(10 + i));
       messages.push({ role: "toolResult", toolCallId: id, toolName: "bash", content: [{ type: "text", text: "o" }], isError: false, timestamp: 100 + i });
     }
-    const { messages: out, pruned } = pruneMessages(messages, indexer, undefined, undefined, {
-      enabled: true,
-      keepLastTurns: 2,
+    const { messages: out, pruned } = pruneMessages(messages, indexer, {
+      enabled: true, rollingWindow: 0, stripFinalAssistantThinking: false, fuseRangeSummary: false,
     });
+    // Phase 1 still fires: c10's toolResult is stub-replaced.
     expect(pruned).toBe(true);
-
-    // Phase 1: c10 toolResult stub-replaced
     const tr = out.find((m: any) => m.role === "toolResult" && m.toolCallId === "c10") as any;
     expect(tr.content[0].text).toContain("`t1`");
-
-    // Phase 4: oldest 3 assistant turns stripped, last 2 keep thinking
+    // No phase strips thinking any more — all five assistants keep theirs.
     const assistants = out.filter((m: any) => m.role === "assistant");
-    const hasThinking = (m: any) => m.content.some((c: any) => c.type === "thinking");
-    expect(assistants.slice(0, 3).every((a: any) => !hasThinking(a))).toBe(true);
-    expect(assistants.slice(-2).every((a: any) => hasThinking(a))).toBe(true);
-  });
-
-  it("threads thinkingBoundaryTimestamp into phase 4", () => {
-    const indexer = new ToolCallIndexer();
-    const strip: ThinkingStripConfig = { enabled: true, keepLastTurns: 16 };
-    const messages: any[] = [
-      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 1 },
-      { role: "assistant", content: [{ type: "thinking", thinking: "old", thinkingSignature: "s" }, { type: "text", text: "a" }], timestamp: 10, usage: {}, stopReason: "stop" },
-      { role: "assistant", content: [{ type: "thinking", thinking: "new", thinkingSignature: "s" }, { type: "text", text: "b" }], timestamp: 30, usage: {}, stopReason: "stop" },
-    ];
-    // Boundary 20: ts=10 assistant older -> stripped; ts=30 kept.
-    // Live-count would strip nothing (2 assistants < keepLastTurns=16), so a pass
-    // proves the boundary arg reached phase 4.
-    const { messages: out, pruned } = pruneMessages(messages, indexer, undefined, undefined, strip, undefined, 0, 20);
-    expect(pruned).toBe(true);
-    const older = out.find((m: any) => m.timestamp === 10) as any;
-    const newer = out.find((m: any) => m.timestamp === 30) as any;
-    expect(older.content.some((c: any) => c.type === "thinking")).toBe(false);
-    expect(newer.content.some((c: any) => c.type === "thinking")).toBe(true);
+    expect(assistants.length).toBe(5);
+    expect(assistants.every((a: any) => a.content.some((c: any) => c.type === "thinking"))).toBe(true);
   });
 });
 
@@ -457,7 +433,7 @@ describe("render-time protection re-check", () => {
 
   it("leaves a summarized record verbatim once its path matches protectedPaths", () => {
     const { messages, pruned } = pruneMessages(
-      [skillMsg], indexer as any, undefined, undefined, undefined,
+      [skillMsg], indexer as any, undefined, undefined,
       { protectedTools: [], protectedPaths: ["**/skills/**/*.md"] },
     );
     expect(pruned).toBe(false);
@@ -488,7 +464,7 @@ describe("pruneMessages recovery grace", () => {
       shortRefs: new Map([["tc-recover", "t1"]]),
     });
     const messages = [mkQueryResult("tc-recover", 1)];
-    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, undefined, 3);
+    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, 3);
     expect(out[0].content[0].text).toBe("VERBATIM RECOVERY OUTPUT");
   });
 
@@ -498,7 +474,7 @@ describe("pruneMessages recovery grace", () => {
       shortRefs: new Map([["tc-recover", "t1"]]),
     });
     const messages: any[] = [mkQueryResult("tc-recover", 1), mkUser(2), mkUser(3), mkUser(4), mkUser(5)];
-    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, undefined, 3);
+    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, 3);
     const tr = out.find((m: any) => m.toolCallId === "tc-recover") as any;
     expect(tr.content[0].text).toContain("context_tree_query");
     expect(tr.content[0].text).not.toBe("VERBATIM RECOVERY OUTPUT");
@@ -510,7 +486,7 @@ describe("pruneMessages recovery grace", () => {
       shortRefs: new Map([["tc-recover", "t1"]]),
     });
     const messages = [mkQueryResult("tc-recover", 1)];
-    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, undefined, 0);
+    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, 0);
     expect(out[0].content[0].text).not.toBe("VERBATIM RECOVERY OUTPUT");
     expect(out[0].content[0].text).toContain("context_tree_query");
   });
@@ -530,7 +506,7 @@ describe("pruneMessages recovery grace", () => {
         timestamp: 1,
       },
     ];
-    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, undefined, 3);
+    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, 3);
     expect(out[0].content[0].text).not.toBe("VERBATIM RECOVERY OUTPUT");
     expect(out[0].content[0].text).toContain("context_tree_query");
   });
@@ -546,7 +522,7 @@ describe("pruneMessages recovery grace", () => {
     });
     const messages: any[] = [mkQueryResult("tc-recover", 1), mkUser(2), mkUser(3), mkUser(4), mkUser(5)];
     const { messages: out } = pruneMessages(
-      messages, indexer, undefined, undefined, undefined,
+      messages, indexer, undefined, undefined,
       { protectedTools: [], protectedPaths: ["**/skills/**/*.md"] },
       0,
     );
@@ -565,7 +541,7 @@ describe("pruneMessages recovery grace", () => {
       }]]),
     });
     const messages = [mkQueryResult("tc-recover", 1)];
-    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, undefined, 3);
+    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, 3);
     expect(out[0].content[0].text).toBe("VERBATIM RECOVERY OUTPUT");
   });
 
@@ -580,7 +556,7 @@ describe("pruneMessages recovery grace", () => {
       }]]),
     });
     const messages: any[] = [mkQueryResult("tc-recover", 1), mkUser(2), mkUser(3), mkUser(4), mkUser(5)];
-    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, undefined, 3);
+    const { messages: out } = pruneMessages(messages, indexer, undefined, undefined, undefined, 3);
     const tr = out.find((m: any) => m.toolCallId === "tc-recover") as any;
     expect(tr.content[0].text).not.toBe("VERBATIM RECOVERY OUTPUT");
     expect(tr.content[0].text).toContain("/blobs/tc-recover.txt");
@@ -592,7 +568,7 @@ describe("sizeMessages", () => {
   it("counts hidden fields (thinking blocks), not just visible text", () => {
     // Two messages with identical visible .text but different hidden content.
     // sizeMessages must count the full serialized weight so all reclaim
-    // mechanisms (thinking-strip, error-purge, etc.) register correctly.
+    // mechanisms (stub-replace, error-purge, chain-range-prune) register correctly.
     const withThinking = [{
       role: "assistant",
       content: [

package/src/pruner.ts

@@ -1,23 +1,22 @@
 import type { ToolCallIndexer } from "./indexer.js";
-import type { ChainCompressionConfig, ErrorPurgeConfig, ThinkingStripConfig } from "./types.js";
+import type { ChainCompressionConfig, ErrorPurgeConfig } from "./types.js";
 import { isProtected, type ProtectionConfig } from "./protected.js";
 import { applyChainCompressions } from "./chain-range-prune.js";
 import { purgeErroredArgs } from "./error-purge.js";
-import { stripOldThinking } from "./thinking-strip.js";
 import { inGraceRecoveryToolCallIds } from "./recovery-grace.js";
 
 /**
  * Estimate of a message array's context weight. Serializing the whole array
  * (not just visible text) is deliberate: it counts tool-call argument bodies
- * (error-purge), thinking blocks (thinking-strip), and tool-result arrays
- * (stub-replace / chain-range) so all reclaim mechanisms register.
+ * (error-purge) and tool-result arrays (stub-replace / chain-range) so all
+ * reclaim mechanisms register.
  */
 export function sizeMessages(messages: any[]): number {
   return JSON.stringify(messages).length;
 }
 
 /**
- * Transforms the `context` event message array in two passes:
+ * Transforms the `context` event message array in three phases:
  *
  * Phase 1 — stub-replace: ToolResultMessages for summarized tool calls are
  * replaced with short stubs pointing the model at `context_tree_query`.
@@ -43,12 +42,6 @@ export function sizeMessages(messages: any[]): number {
  * synthetic user message wrapping the existing per-batch summary text.
  * Only runs when `chainCompression.enabled` and chain entries exist.
  *
- * Phase 4 — thinking strip: keep `thinking` blocks only on the last
- * `keepLastTurns` assistant turns; strip them from older assistant messages
- * (preserving text + toolCall). Runs last so the window counts the assistant
- * turns that actually survive to the LLM. Only runs when
- * `thinkingStrip.enabled`.
- *
  * Return shape:
  *   - `pruned: true`  — at least one change happened; the returned
  *     `messages` is a freshly allocated array.
@@ -71,10 +64,8 @@ export function pruneMessages(
   indexer: ToolCallIndexer,
   chainCompression?: ChainCompressionConfig,
   errorPurge?: ErrorPurgeConfig,
-  thinkingStrip?: ThinkingStripConfig,
   protection?: ProtectionConfig,
   recoveryGraceTurns: number = 0,
-  thinkingBoundaryTimestamp?: number,
 ): { messages: any[]; pruned: boolean; beforeChars: number; afterChars: number } {
   // Phase 1: stub-replace summarized tool results
   let pruned = false;
@@ -155,15 +146,6 @@ export function pruneMessages(
     }
   }
 
-  // Phase 4: thinking strip — keep thinking only on the last K assistant turns
-  if (thinkingStrip?.enabled) {
-    const afterStrip = stripOldThinking(current, thinkingStrip, thinkingBoundaryTimestamp);
-    if (afterStrip !== current) {
-      current = afterStrip;
-      pruned = true;
-    }
-  }
-
   return pruned
     ? { messages: current, pruned, beforeChars: sizeMessages(messages), afterChars: sizeMessages(current) }
     : { messages, pruned, beforeChars: 0, afterChars: 0 };

package/src/range-compression.integration.test.ts

@@ -5,7 +5,7 @@ import { compressEligible } from "./chain-compressor.js";
 import { pruneMessages } from "./pruner.js";
 import { detectChains } from "./chain-detector.js";
 import { isProtected } from "./protected.js";
-import type { ChainRange, ChainCompressionConfig, ThinkingStripConfig } from "./types.js";
+import type { ChainRange, ChainCompressionConfig } from "./types.js";
 
 // End-to-end of the in-memory B path (everything except the LLM call, which is
 // the shared runSummarization already exercised live): a span's per-batch
@@ -249,46 +249,4 @@ describe("range compression integration", () => {
     expect(synthetic.content[0].text).toContain("batch one body");
     expect(synthetic.content[0].text).toContain("batch two body");
   });
-
-  test("boundary strips thinking on survivors after a real phase-3 chain drop", async () => {
-    const indexer = new ToolCallIndexer();
-    const blockRefs = new BlockRefIssuer();
-    indexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "tc1" }]);
-    indexer.registerSummaryBody(["tc1"], "summary of batch 1");
-
-    const chain: ChainRange = {
-      startUserTimestamp: 100,
-      middleToolCallIds: ["tc1"],
-      finalAssistantTimestamp: 400,
-    };
-    const { compressedEntries } = await compressEligible([chain], 0, {
-      indexer,
-      blockRefs,
-      appendEntry: () => {},
-      now: () => 999,
-    });
-    expect(compressedEntries).toHaveLength(1);
-
-    // A later assistant turn (ts 500) that carries thinking and sits OLDER than the boundary.
-    const messages: any[] = [
-      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 100 },
-      { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "bash", arguments: {} }], timestamp: 200, usage: {}, stopReason: "tool_use" },
-      { role: "toolResult", toolCallId: "tc1", toolName: "bash", content: [{ type: "text", text: "o1" }], isError: false, timestamp: 210 },
-      { role: "assistant", content: [{ type: "text", text: "mid" }], timestamp: 400, usage: {}, stopReason: "end_turn" },
-      { role: "assistant", content: [{ type: "thinking", thinking: "old-think", thinkingSignature: "s" }, { type: "text", text: "after" }], timestamp: 500, usage: {}, stopReason: "stop" },
-    ];
-
-    const cc: ChainCompressionConfig = { enabled: true, rollingWindow: 0, stripFinalAssistantThinking: true, fuseRangeSummary: false };
-    const strip: ThinkingStripConfig = { enabled: true, keepLastTurns: 16 };
-    // Boundary 600: the ts=500 assistant is older -> its thinking must be stripped,
-    // even though phase 3 has dropped the tc1 chain from the array first.
-    const { messages: out, pruned } = pruneMessages(messages, indexer, cc, undefined, strip, undefined, 0, 600);
-    expect(pruned).toBe(true);
-    // Chain middle dropped:
-    expect(out.filter((m: any) => m.role === "toolResult")).toHaveLength(0);
-    // Surviving ts=500 assistant older than boundary 600 -> thinking stripped:
-    const late = out.find((m: any) => m.role === "assistant" && m.timestamp === 500);
-    expect(late).toBeDefined();
-    expect(late.content.some((c: any) => c.type === "thinking")).toBe(false);
-  });
 });

package/src/types.ts

@@ -163,19 +163,6 @@ export const ROLLING_WINDOW_PRESETS: { value: string; label: string }[] = [
   { value: "10", label: "10" },
 ];
 
-/**
- * Cycling preset values for the `thinkingStrip.keepLastTurns` setting.
- * Stored as strings because SettingsList cycles string values; converted to
- * number when applied. Counts ASSISTANT turns (messages), not closed chains.
- */
-export const KEEP_LAST_TURNS_PRESETS: { value: string; label: string }[] = [
-  { value: "4", label: "4" },
-  { value: "8", label: "8" },
-  { value: "16", label: "16 (default)" },
-  { value: "32", label: "32" },
-  { value: "64", label: "64" },
-];
-
 /**
  * Cycling preset values for the `minBatchChars` setting in the SettingsList.
  * Stored as strings because SettingsList cycles string values; converted to
@@ -349,8 +336,6 @@ export interface ContextPruneConfig {
   chainCompression: ChainCompressionConfig;
   /** Replace failed toolCall argument bodies with compact stubs after a cooldown window. */
   purgeErrors: ErrorPurgeConfig;
-  /** Rolling main-loop thinking-block strip: keep thinking only on the last K assistant turns. */
-  thinkingStrip: ThinkingStripConfig;
   /**
    * Pre-flush content-hash dedup pass. When `true`, each captured tool call
    * is hashed by `(toolName, normalize(resultText))` and compared against
@@ -497,18 +482,6 @@ export interface ErrorPurgeConfig {
   minArgChars: number;
 }
 
-export interface ThinkingStripConfig {
-  enabled: boolean;
-  /**
-   * Keep `thinking` blocks on the last K assistant turns; strip them from
-   * older assistant messages (preserving text + toolCall blocks). Counts
-   * assistant messages, not closed chains. Clamped to >= 1 so the most-recent
-   * assistant turn always keeps its thinking (Anthropic requires the last
-   * assistant turn's thinking during tool use). Default 16.
-   */
-  keepLastTurns: number;
-}
-
 export const DEFAULT_CONFIG: ContextPruneConfig = {
   enabled: false,
   showPruneStatusLine: true,
@@ -534,10 +507,6 @@ export const DEFAULT_CONFIG: ContextPruneConfig = {
     cooldownTurns: 2,
     minArgChars: 500,
   },
-  thinkingStrip: {
-    enabled: true,
-    keepLastTurns: 16,
-  },
   dedupByContentHash: true,
   autoBudgetThreshold: null,
   spillThreshold: 65536,
@@ -730,14 +699,6 @@ export interface PruneFrontier {
   summaryCharCount: number;
   /** Whether the attempt actually pruned or was skipped for being oversized */
   outcome: PruneFrontierOutcome;
-  /**
-   * Assistant-message timestamp marking the flush-gated thinking-strip boundary:
-   * thinking is stripped from every assistant message older than this. Advances
-   * only at flushes (stays fixed between them so renders are prefix-stable and the
-   * prompt cache survives a tool loop). Absent on pre-feature entries - the render
-   * path then falls back to the live-count window. See src/thinking-strip.ts.
-   */
-  thinkingStripBoundaryTimestamp?: number;
 }
 
 /**

package/src/thinking-strip.test.ts

@@ -1,257 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { stripOldThinking, computeThinkingBoundary } from "./thinking-strip.js";
-import type { ThinkingStripConfig } from "./types.js";
-
-const cfg = (enabled: boolean, keepLastTurns: number): ThinkingStripConfig => ({ enabled, keepLastTurns });
-
-function userMsg(ts: number): any {
-  return { role: "user", content: [{ type: "text", text: "go" }], timestamp: ts };
-}
-
-function assistantToolsThinking(ts: number, toolCallIds: string[], thinkingBlocks = 1): any {
-  const content: any[] = [];
-  for (let i = 0; i < thinkingBlocks; i++) {
-    content.push({ type: "thinking", thinking: `t${ts}-${i}`, thinkingSignature: `sig${ts}-${i}` });
-  }
-  content.push({ type: "text", text: "working" });
-  for (const id of toolCallIds) content.push({ type: "toolCall", id, name: "bash", arguments: { cmd: "ls" } });
-  return { role: "assistant", content, timestamp: ts, usage: {}, stopReason: "toolUse" };
-}
-
-function assistantTextThinking(ts: number): any {
-  return {
-    role: "assistant",
-    content: [
-      { type: "thinking", thinking: "final reasoning", thinkingSignature: "sigf" },
-      { type: "text", text: "done" },
-    ],
-    timestamp: ts,
-    usage: {},
-    stopReason: "stop",
-  };
-}
-
-function toolResult(ts: number, toolCallId: string): any {
-  return {
-    role: "toolResult",
-    toolCallId,
-    toolName: "bash",
-    content: [{ type: "text", text: "out" }],
-    isError: false,
-    timestamp: ts,
-  };
-}
-
-function hasThinking(msg: any): boolean {
-  return Array.isArray(msg.content) && msg.content.some((c: any) => c.type === "thinking");
-}
-
-function countThinking(msg: any): number {
-  return Array.isArray(msg.content) ? msg.content.filter((c: any) => c.type === "thinking").length : 0;
-}
-
-/** user, then (n-1) tool-using assistant turns each followed by a toolResult, then 1 final text assistant. */
-function convo(nAssistantTurns: number): any[] {
-  const msgs: any[] = [userMsg(1)];
-  let ts = 2;
-  for (let i = 0; i < nAssistantTurns - 1; i++) {
-    const id = `tc${i}`;
-    msgs.push(assistantToolsThinking(ts++, [id]));
-    msgs.push(toolResult(ts++, id));
-  }
-  msgs.push(assistantTextThinking(ts++));
-  return msgs;
-}
-
-describe("stripOldThinking", () => {
-  test("disabled → same reference", () => {
-    const msgs = convo(20);
-    expect(stripOldThinking(msgs, cfg(false, 16))).toBe(msgs);
-  });
-
-  test("fewer assistant turns than keepLastTurns → same reference", () => {
-    const msgs = convo(10);
-    expect(stripOldThinking(msgs, cfg(true, 16))).toBe(msgs);
-  });
-
-  test("exactly keepLastTurns assistant turns → same reference (nothing older)", () => {
-    const msgs = convo(16);
-    expect(stripOldThinking(msgs, cfg(true, 16))).toBe(msgs);
-  });
-
-  test("strips thinking from turns older than the last K, keeps the last K", () => {
-    const msgs = convo(20);
-    const out = stripOldThinking(msgs, cfg(true, 16));
-    expect(out).not.toBe(msgs);
-    const assistants = out.filter((m) => m.role === "assistant");
-    expect(assistants.length).toBe(20);
-    for (const a of assistants.slice(-16)) expect(hasThinking(a)).toBe(true);
-    for (const a of assistants.slice(0, 4)) expect(hasThinking(a)).toBe(false);
-  });
-
-  test("keepLastTurns=1 keeps only the most-recent assistant turn's thinking", () => {
-    const msgs = convo(5);
-    const out = stripOldThinking(msgs, cfg(true, 1));
-    const assistants = out.filter((m) => m.role === "assistant");
-    expect(hasThinking(assistants[assistants.length - 1])).toBe(true);
-    for (const a of assistants.slice(0, -1)) expect(hasThinking(a)).toBe(false);
-  });
-
-  test("keepLastTurns=0 is clamped to 1 (never strips the last assistant turn)", () => {
-    const msgs = convo(5);
-    const out = stripOldThinking(msgs, cfg(true, 0));
-    const assistants = out.filter((m) => m.role === "assistant");
-    expect(hasThinking(assistants[assistants.length - 1])).toBe(true);
-    expect(hasThinking(assistants[0])).toBe(false);
-  });
-
-  test("trailing tool-use assistant awaiting results keeps its thinking", () => {
-    const msgs: any[] = [userMsg(1)];
-    let ts = 2;
-    for (let i = 0; i < 4; i++) {
-      const id = `x${i}`;
-      msgs.push(assistantToolsThinking(ts++, [id]));
-      msgs.push(toolResult(ts++, id));
-    }
-    const out = stripOldThinking(msgs, cfg(true, 1));
-    const assistants = out.filter((m) => m.role === "assistant");
-    const last = assistants[assistants.length - 1];
-    expect(hasThinking(last)).toBe(true);
-    expect(last.content.some((c: any) => c.type === "toolCall")).toBe(true);
-  });
-
-  test("stripped assistant keeps its text and toolCall blocks", () => {
-    const msgs = convo(20);
-    const out = stripOldThinking(msgs, cfg(true, 16));
-    const firstAssistant = out.find((m) => m.role === "assistant");
-    expect(hasThinking(firstAssistant)).toBe(false);
-    expect(firstAssistant.content.some((c: any) => c.type === "text")).toBe(true);
-    expect(firstAssistant.content.some((c: any) => c.type === "toolCall")).toBe(true);
-  });
-
-  test("strips all thinking blocks from a message (all-or-nothing)", () => {
-    const msgs: any[] = [userMsg(1), assistantToolsThinking(2, ["a"], 2), toolResult(3, "a")];
-    let ts = 4;
-    for (let i = 0; i < 3; i++) {
-      const id = `b${i}`;
-      msgs.push(assistantToolsThinking(ts++, [id], 2));
-      msgs.push(toolResult(ts++, id));
-    }
-    msgs.push(assistantTextThinking(ts++));
-    const out = stripOldThinking(msgs, cfg(true, 2));
-    expect(countThinking(out[1])).toBe(0);
-  });
-
-  test("no thinking anywhere → same reference", () => {
-    const msgs: any[] = [userMsg(1)];
-    let ts = 2;
-    for (let i = 0; i < 20; i++) {
-      const id = `n${i}`;
-      msgs.push({
-        role: "assistant",
-        content: [{ type: "text", text: "x" }, { type: "toolCall", id, name: "bash", arguments: {} }],
-        timestamp: ts++,
-        usage: {},
-        stopReason: "toolUse",
-      });
-      msgs.push(toolResult(ts++, id));
-    }
-    expect(stripOldThinking(msgs, cfg(true, 4))).toBe(msgs);
-  });
-
-  test("idempotent: second pass returns same reference", () => {
-    const msgs = convo(20);
-    const once = stripOldThinking(msgs, cfg(true, 16));
-    const twice = stripOldThinking(once, cfg(true, 16));
-    expect(twice).toBe(once);
-  });
-
-  test("preserves message order and length", () => {
-    const msgs = convo(20);
-    const out = stripOldThinking(msgs, cfg(true, 16));
-    expect(out.length).toBe(msgs.length);
-    out.forEach((m, i) => expect(m.role).toBe(msgs[i].role));
-  });
-});
-
-describe("stripOldThinking (boundaryTimestamp path)", () => {
-  test("strips assistants older than boundary, keeps boundary and newer", () => {
-    const msgs = convo(20);
-    const assistantTs = msgs.filter((m) => m.role === "assistant").map((m) => m.timestamp);
-    const boundary = assistantTs[4];
-    const out = stripOldThinking(msgs, cfg(true, 16), boundary);
-    expect(out).not.toBe(msgs);
-    const assistants = out.filter((m) => m.role === "assistant");
-    for (const a of assistants) {
-      if (a.timestamp < boundary) expect(hasThinking(a)).toBe(false);
-      else expect(hasThinking(a)).toBe(true);
-    }
-  });
-
-  test("prefix is byte-stable across a growing tail at a fixed boundary (the AC)", () => {
-    const msgs = convo(20);
-    const boundary = msgs.filter((m) => m.role === "assistant").map((m) => m.timestamp)[4];
-    const first = stripOldThinking(msgs, cfg(true, 16), boundary);
-    const prefixLen = first.length;
-    const grown = [...msgs, assistantToolsThinking(100, ["tcNew"]), toolResult(101, "tcNew")];
-    const second = stripOldThinking(grown, cfg(true, 16), boundary);
-    expect(JSON.stringify(second.slice(0, prefixLen))).toBe(JSON.stringify(first));
-  });
-
-  test("undefined boundary falls back to live-count (same as 2-arg)", () => {
-    const msgs = convo(20);
-    const viaUndefined = stripOldThinking(msgs, cfg(true, 16), undefined);
-    const viaTwoArg = stripOldThinking(msgs, cfg(true, 16));
-    expect(JSON.stringify(viaUndefined)).toBe(JSON.stringify(viaTwoArg));
-  });
-
-  test("assistant without a timestamp is kept, never stripped", () => {
-    const noTs: any = { role: "assistant", content: [{ type: "thinking", thinking: "x", thinkingSignature: "s" }, { type: "text", text: "y" }], usage: {}, stopReason: "stop" };
-    const msgs = [userMsg(1), noTs, ...convo(20).slice(1)];
-    const out = stripOldThinking(msgs, cfg(true, 16), 9999);
-    const kept = out.find((m) => m.role === "assistant" && m.timestamp === undefined);
-    expect(hasThinking(kept)).toBe(true);
-  });
-
-  test("post-chain-drop survivor array: surviving older turns stripped, boundary honored", () => {
-    const full = convo(20);
-    const assistantTs = full.filter((m) => m.role === "assistant").map((m) => m.timestamp);
-    const boundary = assistantTs[10];
-    const survivor = [...full.slice(0, 6), ...full.slice(8)];
-    const out = stripOldThinking(survivor, cfg(true, 16), boundary);
-    for (const a of out.filter((m) => m.role === "assistant")) {
-      if (a.timestamp < boundary) expect(hasThinking(a)).toBe(false);
-    }
-  });
-});
-
-describe("computeThinkingBoundary", () => {
-  const ts = Array.from({ length: 40 }, (_, i) => (i + 1) * 10);
-
-  test("count <= keep returns prev unchanged", () => {
-    expect(computeThinkingBoundary(ts.slice(0, 16), 16, undefined)).toBeUndefined();
-    expect(computeThinkingBoundary(ts.slice(0, 10), 16, 123)).toBe(123);
-  });
-
-  test("count > keep returns the (count-keep)-th timestamp", () => {
-    expect(computeThinkingBoundary(ts.slice(0, 20), 16, undefined)).toBe(ts[4]);
-  });
-
-  test("keepLastTurns=0 is clamped to 1 (no out-of-bounds)", () => {
-    expect(computeThinkingBoundary(ts.slice(0, 20), 0, undefined)).toBe(ts[19]);
-  });
-
-  test("monotonic clamp: never regresses when keepLastTurns increases", () => {
-    const first = computeThinkingBoundary(ts.slice(0, 40), 16, undefined);
-    expect(first).toBe(ts[24]);
-    const second = computeThinkingBoundary(ts.slice(0, 40), 32, first);
-    expect(second).toBe(first);
-  });
-
-  test("an added trailing turn (e.g. closingMessage) advances the boundary by one", () => {
-    const before = computeThinkingBoundary(ts.slice(0, 20), 16, undefined);
-    const after = computeThinkingBoundary(ts.slice(0, 21), 16, before);
-    expect(after).toBe(ts[5]);
-    expect(after).toBeGreaterThan(before as number);
-  });
-});

package/src/thinking-strip.ts

@@ -1,83 +0,0 @@
-import { withoutThinkingBlocks } from "./chain-range-prune.js";
-import type { ThinkingStripConfig } from "./types.js";
-
-/**
- * Rolling main-loop thinking strip.
- *
- * Keeps `thinking` blocks on the last `keepLastTurns` assistant turns and
- * strips them from all older assistant messages, preserving each message's
- * `text` and `toolCall` blocks. "Turn" counts ASSISTANT messages, not
- * user-bounded spans — the target failure mode is a single long open chain
- * (zero subagents, near-zero user turns) where a span-based window keeps
- * everything.
- *
- * Provider safety (Anthropic): during tool use only the LAST assistant turn's
- * thinking is required; prior turns may be omitted, and a message's thinking
- * blocks must be dropped all-or-nothing. `keepLastTurns` is clamped to >= 1 so
- * the most-recent assistant turn always keeps its thinking. Stripping reuses
- * `withoutThinkingBlocks` (drops the whole block incl. signature).
- *
- * Returns the original array reference unchanged when nothing is stripped, so
- * `pruneMessages` can skip reconstruction.
- */
-export function stripOldThinking(
-  messages: any[],
-  config: ThinkingStripConfig,
-  boundaryTimestamp?: number,
-): any[] {
-  if (!config.enabled) return messages;
-
-  // Flush-gated path: strip by the persisted timestamp boundary. Fixed between
-  // flushes, so consecutive renders produce a byte-identical historical prefix.
-  // `!(ts < boundary)` keeps a timestamp-less assistant (undefined < n === false),
-  // which is the provider-safe default (never over-strip an unknown-age turn).
-  if (boundaryTimestamp !== undefined && boundaryTimestamp !== null) {
-    let changed = false;
-    const out = messages.map((msg) => {
-      if (msg?.role !== "assistant" || !(msg.timestamp < boundaryTimestamp)) return msg;
-      if (!Array.isArray(msg.content) || !msg.content.some((c: any) => c.type === "thinking")) return msg;
-      changed = true;
-      return withoutThinkingBlocks(msg);
-    });
-    return changed ? out : messages;
-  }
-
-  // Fallback: live-count window (pre-first-flush / pre-feature sessions).
-  const keep = Math.max(1, config.keepLastTurns);
-
-  const assistantIdx: number[] = [];
-  for (let i = 0; i < messages.length; i++) {
-    if (messages[i]?.role === "assistant") assistantIdx.push(i);
-  }
-  if (assistantIdx.length <= keep) return messages;
-
-  const firstKeptAssistant = assistantIdx[assistantIdx.length - keep];
-  let changed = false;
-  const out = messages.map((msg, i) => {
-    if (i >= firstKeptAssistant || msg?.role !== "assistant") return msg;
-    if (!Array.isArray(msg.content) || !msg.content.some((c: any) => c.type === "thinking")) return msg;
-    changed = true;
-    return withoutThinkingBlocks(msg);
-  });
-  return changed ? out : messages;
-}
-
-/**
- * Flush-time computation of the thinking-strip boundary: the timestamp of the
- * (count - keepLastTurns)-th assistant message, monotonically clamped so the
- * boundary never moves backward (a mid-session `keepLastTurns` increase must not
- * re-add thinking to an already-stripped message). Stateless recompute - no
- * running counter. `keepLastTurns` is clamped to >= 1 to match `stripOldThinking`
- * and avoid an out-of-bounds index.
- */
-export function computeThinkingBoundary(
-  assistantTimestamps: number[],
-  keepLastTurns: number,
-  prev?: number,
-): number | undefined {
-  const keep = Math.max(1, keepLastTurns);
-  const count = assistantTimestamps.length;
-  if (count <= keep) return prev;
-  const candidate = assistantTimestamps[count - keep];
-  return Math.max(prev ?? candidate, candidate);
-}