pi-condense 2.4.2 → 2.5.0

package/CHANGELOG.md

@@ -7,6 +7,14 @@ 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.
+
 ## [2.4.2] - 2026-08-04
 
 - **No-op renders skip context serialization.** `pruneMessages` (`src/pruner.ts`) computed `sizeMessages` (a full `JSON.stringify` over the entire message array) unconditionally on every `context` render, including no-ops where the result is never read (`index.ts` consumes `beforeChars`/`afterChars` only under `if (result.pruned)`). It now computes both sizes lazily in the pruned branch and returns a `{ beforeChars: 0, afterChars: 0 }` sentinel on a no-op, so a render that prunes nothing does zero `JSON.stringify` over the array. CPU/GC only - zero token cost, no wire or return-shape change. Also corrects a stale fast-path comment in the `context` handler (`index.ts`): index/registry emptiness alone does not imply a no-op, because error-purge and thinking-strip prune independently.

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, so "last K assistant turns" is measured over the turns that actually survive to the LLM:
-
-```
-[stub-replace] → [error-purge] → [chain-range-prune] → [thinking-strip]
-```
-
-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 K.
-
-### Cache impact
-
-Each new assistant turn slides the keep-window by one, stripping the turn that falls out and invalidating the prefix cache from that point (~K turns deep). The stable cached prefix (everything older than the window) still grows monotonically; only a K-deep tail churns. The trade vs the status quo: without stripping, thinking accrues without bound and is billed as cached input on every request until the window overflows; with stripping, total context is bounded at the cost of re-processing the last ~K turns' thinking each turn. Net-positive for long sessions; a literal no-op for sessions under `keepLastTurns` turns. Smaller K is cheaper on both savings and churn (worse only for reasoning continuity).
-
-### 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

@@ -486,6 +486,15 @@ export default function (pi: ExtensionAPI) {
               ? "skipped-deduped"
               : "skipped-trivial";
 
+      // 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.chainCompression.enabled) {
+        branchMessages = ctx.sessionManager.getBranch()
+          .filter((e: any) => e.type === "message" && e.message)
+          .map((e: any) => e.message);
+      }
+
       const frontierSnapshot: PruneFrontier = {
         lastAttemptedToolCallId: lastTC.toolCallId,
         lastAttemptedToolName: lastTC.toolName,
@@ -524,14 +533,11 @@ export default function (pi: ExtensionAPI) {
       // Non-fatal: a failure here does not roll back the successful summarization.
       if (currentConfig.value.chainCompression.enabled) {
         try {
-          const branch = ctx.sessionManager.getBranch();
-          const branchMessages = branch
-            .filter((e: any) => e.type === "message" && e.message)
-            .map((e: any) => e.message);
           // 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.
-          const chains = detectChains(withClosingMessage(branchMessages, options.closingMessage), protectionPredicate);
-          const inGrace = inGraceRecoveryToolCallIds(branchMessages, currentConfig.value.recoveryGraceTurns);
+          // 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(
             chains,
             currentConfig.value.chainCompression.rollingWindow,
@@ -819,16 +825,14 @@ 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,
     );

package/package.json

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

@@ -0,0 +1,173 @@
+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 = {
+  lastAttemptedToolCallId: "tc1",
+  lastAttemptedToolName: "bash",
+  lastAttemptedTurnIndex: 3,
+  lastAttemptedTimestamp: 1000,
+  attemptedBatchCount: 1,
+  attemptedToolCallCount: 2,
+  rawCharCount: 500,
+  summaryCharCount: 100,
+  outcome: "summarized",
+};
+
+describe("PruneFrontierTracker.fromJSON", () => {
+  test("round-trips a full frontier", () => {
+    const t = new PruneFrontierTracker();
+    t.fromJSON({ ...base });
+    expect(t.get()?.lastAttemptedToolCallId).toBe("tc1");
+    expect(t.get()?.outcome).toBe("summarized");
+  });
+
+  test("ignores an entry with no lastAttemptedToolCallId", () => {
+    const t = new PruneFrontierTracker();
+    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", () => {
+  test("reconstructs from a persisted frontier entry", () => {
+    const t = new PruneFrontierTracker();
+    const entries = [
+      { type: "custom", customType: "context-prune-frontier", data: { ...base, lastAttemptedTimestamp: 2000 } },
+    ];
+    const fakeCtx = { sessionManager: { getBranch: () => entries } } as any;
+    t.reconstructFromSession(fakeCtx);
+    expect(t.get()?.lastAttemptedTimestamp).toBe(2000);
+  });
+
+  // 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, lastAttemptedTimestamp: 2000, thinkingStripBoundaryTimestamp: legacyBoundary },
+      },
+    ];
+    const fakeCtx = { sessionManager: { getBranch: () => entries } } as any;
+
+    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/pruner.test.ts

@@ -374,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",
@@ -393,21 +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);
+    expect(assistants.length).toBe(5);
+    expect(assistants.every((a: any) => a.content.some((c: any) => c.type === "thinking"))).toBe(true);
   });
 });
 
@@ -437,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);
@@ -468,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");
   });
 
@@ -478,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");
@@ -490,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");
   });
@@ -510,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");
   });
@@ -526,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,
     );
@@ -545,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");
   });
 
@@ -560,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");
@@ -572,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,7 +64,6 @@ export function pruneMessages(
   indexer: ToolCallIndexer,
   chainCompression?: ChainCompressionConfig,
   errorPurge?: ErrorPurgeConfig,
-  thinkingStrip?: ThinkingStripConfig,
   protection?: ProtectionConfig,
   recoveryGraceTurns: number = 0,
 ): { messages: any[]; pruned: boolean; beforeChars: number; afterChars: number } {
@@ -154,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);
-    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/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,

package/src/thinking-strip.test.ts

@@ -1,175 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { stripOldThinking } 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));
-  });
-});

package/src/thinking-strip.ts

@@ -1,42 +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): any[] {
-  if (!config.enabled) return messages;
-  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;
-}