pi-condense 2.4.2 → 2.4.3

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

@@ -1015,17 +1015,17 @@ Anthropic's extended-thinking contract during tool use:
 
 ### 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:
+Thinking strip runs **last**, after chain-range-prune, at render time:
 
 ```
 [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.
+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
 
-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).
+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
 

package/index.ts

@@ -36,6 +36,7 @@ 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";
@@ -486,6 +487,34 @@ 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.
+      let branchMessages: any[] | undefined;
+      if (currentConfig.value.thinkingStrip.enabled || 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,
@@ -496,6 +525,7 @@ export default function (pi: ExtensionAPI) {
         rawCharCount: totalRawCharCount,
         summaryCharCount: totalSummaryCharCount,
         outcome: flushOutcome,
+        thinkingStripBoundaryTimestamp: thinkingBoundary,
       };
 
       try {
@@ -524,14 +554,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 (shared with the boundary block).
+          const chains = detectChains(withClosingMessage(branchMessages!, options.closingMessage), protectionPredicate);
+          const inGrace = inGraceRecoveryToolCallIds(branchMessages!, currentConfig.value.recoveryGraceTurns);
           const { compressedEntries } = await compressEligible(
             chains,
             currentConfig.value.chainCompression.rollingWindow,
@@ -831,6 +858,7 @@ export default function (pi: ExtensionAPI) {
       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.2",
+  "version": "2.4.3",
   "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/frontier.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { PruneFrontierTracker } from "./frontier.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 - thinkingStripBoundaryTimestamp", () => {
+  test("round-trips the boundary field", () => {
+    const t = new PruneFrontierTracker();
+    t.fromJSON({ ...base, thinkingStripBoundaryTimestamp: 777 });
+    expect(t.get()?.thinkingStripBoundaryTimestamp).toBe(777);
+  });
+
+  test("absent boundary stays undefined (live-count fallback)", () => {
+    const t = new PruneFrontierTracker();
+    t.fromJSON({ ...base });
+    expect(t.get()?.thinkingStripBoundaryTimestamp).toBeUndefined();
+  });
+});
+
+describe("PruneFrontierTracker.reconstructFromSession - boundary survives reload", () => {
+  test("reconstructs thinkingStripBoundaryTimestamp from a persisted frontier entry", () => {
+    const t = new PruneFrontierTracker();
+    const entries = [
+      { type: "custom", customType: "context-prune-frontier", data: { ...base, thinkingStripBoundaryTimestamp: 555 } },
+    ];
+    const fakeCtx = { sessionManager: { getBranch: () => entries } } as any;
+    t.reconstructFromSession(fakeCtx);
+    expect(t.get()?.thinkingStripBoundaryTimestamp).toBe(555);
+  });
+
+  test("a persisted entry without the field reconstructs as undefined (live-count fallback)", () => {
+    const t = new PruneFrontierTracker();
+    const entries = [
+      { type: "custom", customType: "context-prune-frontier", data: { ...base } },
+    ];
+    const fakeCtx = { sessionManager: { getBranch: () => entries } } as any;
+    t.reconstructFromSession(fakeCtx);
+    expect(t.get()).not.toBeNull();
+    expect(t.get()?.thinkingStripBoundaryTimestamp).toBeUndefined();
+  });
+});

package/src/frontier.ts

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

package/src/pruner.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import { pruneMessages, sizeMessages } from "./pruner.js";
-import type { ChainCompressionConfig, ChainCompressionEntry } from "./types.js";
+import type { ChainCompressionConfig, ChainCompressionEntry, ThinkingStripConfig } from "./types.js";
+import { ToolCallIndexer } from "./indexer.js";
 
 // Minimal mock exposing only the ToolCallIndexer surface that pruneMessages calls.
 function makeMockIndexer({
@@ -409,6 +410,25 @@ describe("pruneMessages", () => {
     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);
+  });
 });
 
 describe("render-time protection re-check", () => {

package/src/pruner.ts

@@ -74,6 +74,7 @@ export function pruneMessages(
   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;
@@ -156,7 +157,7 @@ export function pruneMessages(
 
   // Phase 4: thinking strip — keep thinking only on the last K assistant turns
   if (thinkingStrip?.enabled) {
-    const afterStrip = stripOldThinking(current, thinkingStrip);
+    const afterStrip = stripOldThinking(current, thinkingStrip, thinkingBoundaryTimestamp);
     if (afterStrip !== current) {
       current = afterStrip;
       pruned = true;

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 } from "./types.js";
+import type { ChainRange, ChainCompressionConfig, ThinkingStripConfig } 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,4 +249,46 @@ 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/thinking-strip.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { stripOldThinking } from "./thinking-strip.js";
+import { stripOldThinking, computeThinkingBoundary } from "./thinking-strip.js";
 import type { ThinkingStripConfig } from "./types.js";
 
 const cfg = (enabled: boolean, keepLastTurns: number): ThinkingStripConfig => ({ enabled, keepLastTurns });
@@ -173,3 +173,85 @@ describe("stripOldThinking", () => {
     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

@@ -20,8 +20,29 @@ import type { ThinkingStripConfig } from "./types.js";
  * Returns the original array reference unchanged when nothing is stripped, so
  * `pruneMessages` can skip reconstruction.
  */
-export function stripOldThinking(messages: any[], config: ThinkingStripConfig): any[] {
+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[] = [];
@@ -40,3 +61,23 @@ export function stripOldThinking(messages: any[], config: ThinkingStripConfig):
   });
   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);
+}

package/src/types.ts

@@ -730,6 +730,14 @@ 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;
 }
 
 /**