pi-condense 2.4.3 → 2.6.0

package/src/commands.test.ts

@@ -6,9 +6,13 @@ const cfg = (enabled: boolean): ContextPruneConfig => ({ enabled } as ContextPru
 const cfgVisible = (enabled: boolean): ContextPruneConfig =>
   ({ enabled, showPruneStatusLine: true } as ContextPruneConfig);
 
-function captureStatus(config: ContextPruneConfig, value?: Parameters<typeof setPruneStatusWidget>[2]): string | undefined {
+function captureStatus(
+  config: ContextPruneConfig,
+  value?: Parameters<typeof setPruneStatusWidget>[2],
+  diagnostics?: Parameters<typeof setPruneStatusWidget>[3],
+): string | undefined {
   let captured: string | undefined;
-  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value);
+  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value, diagnostics);
   return captured;
 }
 
@@ -65,3 +69,28 @@ describe("setPruneStatusWidget", () => {
     expect(captureStatus(cfg(true))).toBeUndefined();
   });
 });
+
+describe("diagnostic counters on the status line", () => {
+  const zeroDiag = { "unresolved-range": 0, "range-id-mismatch": 0, "orphan-sweep": 0 } as const;
+  const mixedDiag = { "unresolved-range": 2, "range-id-mismatch": 0, "orphan-sweep": 1 } as const;
+
+  it("omits the diagnostic segment when all counters are zero", () => {
+    expect(pruneStatusText(cfg(true), undefined, zeroDiag)).toBe("prune: ON");
+  });
+
+  it("appends a compact segment when a counter fires, omitting zero kinds", () => {
+    const text = pruneStatusText(cfg(true), undefined, mixedDiag);
+    expect(text).toBe("prune: ON \u00b7 diag u2/o1");
+  });
+
+  it("appends the diagnostic segment to the reclaim form too", () => {
+    const text = pruneStatusText(cfg(true), { beforeChars: 368000, afterChars: 56000 }, mixedDiag);
+    expect(text).toBe("prune: ON \u00b7 92.0k->14.0k (-85%) \u00b7 diag u2/o1");
+  });
+
+  it("setPruneStatusWidget forwards the counters", () => {
+    expect(captureStatus(cfgVisible(true), undefined, { "unresolved-range": 1, "range-id-mismatch": 0, "orphan-sweep": 0 })).toBe(
+      "\u2502 prune: ON \u00b7 diag u1",
+    );
+  });
+});

package/src/commands.ts

@@ -5,6 +5,7 @@ import {
   type CapturedBatch,
   type ChainCompressionEntry,
   type FlushOptions,
+  type DiagnosticKind,
   PRUNE_ON_MODES,
   BATCHING_MODES,
   STATUS_WIDGET_ID,
@@ -16,7 +17,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,
@@ -58,25 +58,38 @@ class SettingsOverlay extends Container {
 
 // ── Status widget text ──────────────────────────────────────────────────────
 
-export function pruneStatusText(config: ContextPruneConfig, reclaim?: LiveReclaim): string {
+export function pruneStatusText(
+  config: ContextPruneConfig,
+  reclaim?: LiveReclaim,
+  diagnostics?: Record<DiagnosticKind, number>,
+): string {
   if (!config.enabled) return "prune: OFF";
-  if (!reclaim || reclaim.beforeChars <= 0) return "prune: ON";
+  const diag = diagnostics
+    ? [
+        diagnostics["unresolved-range"] ? `u${diagnostics["unresolved-range"]}` : "",
+        diagnostics["range-id-mismatch"] ? `m${diagnostics["range-id-mismatch"]}` : "",
+        diagnostics["orphan-sweep"] ? `o${diagnostics["orphan-sweep"]}` : "",
+      ].filter(Boolean)
+    : [];
+  const suffix = diag.length > 0 ? ` \u00b7 diag ${diag.join("/")}` : "";
+  if (!reclaim || reclaim.beforeChars <= 0) return `prune: ON${suffix}`;
   const beforeTok = Math.round(reclaim.beforeChars / 4);
   const afterTok = Math.round(reclaim.afterChars / 4);
   const reduction = Math.max(0, Math.round((1 - afterTok / beforeTok) * 100));
-  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)`;
+  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)${suffix}`;
 }
 
 export function setPruneStatusWidget(
   ctx: { ui: { setStatus: (id: string, text?: string) => void } },
   config: ContextPruneConfig,
   value?: LiveReclaim | string,
+  diagnostics?: Record<DiagnosticKind, number>,
 ): void {
   if (!config.showPruneStatusLine) {
     ctx.ui.setStatus(STATUS_WIDGET_ID, undefined);
     return;
   }
-  const text = typeof value === "string" ? value : pruneStatusText(config, value);
+  const text = typeof value === "string" ? value : pruneStatusText(config, value, diagnostics);
   // Leading-only separator: the footer joins extension status segments with a
   // single space, so a trailing divider collides with the next segment's leading
   // one and renders doubled. One leading bar yields single dividers between
@@ -456,6 +469,7 @@ export function registerCommands(
   getLiveReclaim: () => LiveReclaim | undefined,
   indexer: ToolCallIndexer,
   compactChains: (ctx: ExtensionCommandContext) => Promise<{ compressedEntries: ChainCompressionEntry[]; skipped: number }>,
+  getDiagnosticCounts?: () => Record<DiagnosticKind, number>,
 ): void {
   // Register the /pruner command
   pi.registerCommand("pruner", {
@@ -648,22 +662,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 +799,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") {
@@ -826,7 +816,7 @@ export function registerCommands(
             }
             currentConfig.value = newConfig;
             saveConfig(newConfig);
-            setPruneStatusWidget(ctx, newConfig, getLiveReclaim());
+            setPruneStatusWidget(ctx, newConfig, getLiveReclaim(), getDiagnosticCounts?.());
             settingsList?.invalidate();
           };
 
@@ -861,7 +851,7 @@ export function registerCommands(
           currentConfig.value = { ...currentConfig.value, enabled: true };
           saveConfig(currentConfig.value);
           ctx.ui.notify("Context pruning enabled.");
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -870,7 +860,7 @@ export function registerCommands(
           currentConfig.value = { ...currentConfig.value, enabled: false };
           saveConfig(currentConfig.value);
           ctx.ui.notify("Context pruning disabled.");
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -989,7 +979,7 @@ export function registerCommands(
             currentConfig.value = { ...currentConfig.value, pruneOn: modeArg as ContextPruneConfig["pruneOn"] };
           }
           saveConfig(currentConfig.value);
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -1036,7 +1026,7 @@ export function registerCommands(
             // tool-result savings; but assistant-message savings (thinking + toolCall args + text)
             // are not counted at all, so the two errors partly cancel. Treat as a rough proxy.
             const droppedChars = compressedEntries.reduce((total, entry) => {
-              const records = indexer.lookupToolCalls(entry.droppedToolCallIds);
+              const records = indexer.lookupToolCalls(entry.droppedOccurrenceKeys ?? entry.droppedToolCallIds);
               return total + records.reduce((s, r) => s + r.resultText.length, 0);
             }, 0);
             const reclaimedTokens = Math.ceil(droppedChars / 4);
@@ -1086,7 +1076,7 @@ export function registerCommands(
 
           // Remove the widget and restore the normal footer status.
           clearWidget();
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
 
           if (!result.ok) {
             const suffix = "error" in result && result.error ? ` (${result.error})` : "";

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/diagnostics.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, spyOn, test } from "bun:test";
+import { DiagnosticSink } from "./diagnostics.js";
+import { CUSTOM_TYPE_DIAGNOSTIC } from "./types.js";
+
+const sinkWithLog = () => {
+  const appended: Array<{ type: string; data: any }> = [];
+  const sink = new DiagnosticSink((type, data) => appended.push({ type, data }));
+  return { sink, appended };
+};
+
+describe("DiagnosticSink", () => {
+  test("writes one session entry per distinct (kind, dedupKey)", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "blockId=b5 start=1000 final=null");
+    expect(appended).toHaveLength(1);
+    expect(appended[0].type).toBe(CUSTOM_TYPE_DIAGNOSTIC);
+    expect(appended[0].data).toEqual({ kind: "unresolved-range", detail: "blockId=b5 start=1000 final=null" });
+  });
+
+  test("dedupes a repeated (kind, dedupKey) within the session", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "first");
+    sink.report("unresolved-range", "b5", "second");
+    expect(appended).toHaveLength(1);
+    expect(sink.counts()["unresolved-range"]).toBe(1);
+  });
+
+  test("a different dedupKey of the same kind still reports", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "x");
+    sink.report("unresolved-range", "b7", "y");
+    expect(appended).toHaveLength(2);
+    expect(sink.counts()["unresolved-range"]).toBe(2);
+  });
+
+  test("the same dedupKey under two different kinds both report", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "x");
+    sink.report("range-id-mismatch", "b5", "y");
+    expect(appended).toHaveLength(2);
+    expect(appended[0].type).toBe(CUSTOM_TYPE_DIAGNOSTIC);
+    expect(appended[1].type).toBe(CUSTOM_TYPE_DIAGNOSTIC);
+    expect(sink.counts()["unresolved-range"]).toBe(1);
+    expect(sink.counts()["range-id-mismatch"]).toBe(1);
+  });
+
+  test("counts are per kind and start at zero", () => {
+    const { sink } = sinkWithLog();
+    expect(sink.counts()).toEqual({ "unresolved-range": 0, "range-id-mismatch": 0, "orphan-sweep": 0 });
+    sink.report("orphan-sweep", "a,b", "swept 2");
+    expect(sink.counts()["orphan-sweep"]).toBe(1);
+  });
+
+  test("an appendEntry failure never throws into the render path, and does not mark the key as seen", () => {
+    const spy = spyOn(console, "error").mockImplementation(() => {});
+    const sink = new DiagnosticSink(() => {
+      throw new Error("session closed");
+    });
+    expect(() => sink.report("orphan-sweep", "a", "detail")).not.toThrow();
+    expect(spy).toHaveBeenCalled();
+    expect(sink.counts()["orphan-sweep"]).toBe(0);
+    spy.mockRestore();
+  });
+
+  test("a retry of the same (kind, dedupKey) after appendEntry starts working persists and counts", () => {
+    const spy = spyOn(console, "error").mockImplementation(() => {});
+    let working = false;
+    const appended: Array<{ type: string; data: any }> = [];
+    const sink = new DiagnosticSink((type, data) => {
+      if (!working) throw new Error("session closed");
+      appended.push({ type, data });
+    });
+
+    expect(() => sink.report("orphan-sweep", "a", "detail")).not.toThrow();
+    expect(sink.counts()["orphan-sweep"]).toBe(0);
+    expect(appended).toHaveLength(0);
+
+    working = true;
+    sink.report("orphan-sweep", "a", "detail");
+    expect(sink.counts()["orphan-sweep"]).toBe(1);
+    expect(appended).toHaveLength(1);
+
+    spy.mockRestore();
+  });
+
+  test("counts() returns a snapshot; mutating it does not affect internal counters", () => {
+    const { sink } = sinkWithLog();
+    sink.report("orphan-sweep", "a", "detail");
+    const snapshot = sink.counts();
+    snapshot["orphan-sweep"] = 999;
+    expect(sink.counts()["orphan-sweep"]).toBe(1);
+  });
+
+  test("reset() zeroes all counters", () => {
+    const { sink } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "x");
+    sink.report("orphan-sweep", "a", "y");
+    sink.reset();
+    expect(sink.counts()).toEqual({ "unresolved-range": 0, "range-id-mismatch": 0, "orphan-sweep": 0 });
+  });
+
+  test("reset() allows a previously-seen (kind, dedupKey) to report again", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "first");
+    expect(appended).toHaveLength(1);
+
+    sink.reset();
+
+    sink.report("unresolved-range", "b5", "second");
+    expect(appended).toHaveLength(2);
+    expect(appended[1].data).toEqual({ kind: "unresolved-range", detail: "second" });
+    expect(sink.counts()["unresolved-range"]).toBe(1);
+  });
+});

package/src/diagnostics.ts

@@ -0,0 +1,46 @@
+import { CUSTOM_TYPE_DIAGNOSTIC } from "./types.js";
+import type { DiagnosticEntryData, DiagnosticKind } from "./types.js";
+
+/**
+ * Out-of-band diagnostic channel for prune-time degradations. Session entries
+ * only - never LLM context, so zero tokens and zero cache-prefix change.
+ * Deduped per (kind, dedupKey) so a permanently degraded condition writes one
+ * entry, not one per render.
+ */
+export class DiagnosticSink {
+  private readonly seen = new Set<string>();
+  private readonly counters: Record<DiagnosticKind, number> = {
+    "unresolved-range": 0,
+    "range-id-mismatch": 0,
+    "orphan-sweep": 0,
+  };
+
+  constructor(private readonly appendEntry: (customType: string, data?: unknown) => void) {}
+
+  report(kind: DiagnosticKind, dedupKey: string, detail: string): void {
+    const key = `${kind}:${dedupKey}`;
+    if (this.seen.has(key)) return;
+    const payload: DiagnosticEntryData = { kind, detail };
+    try {
+      this.appendEntry(CUSTOM_TYPE_DIAGNOSTIC, payload);
+    } catch (err) {
+      // The render path must never fail because bookkeeping failed.
+      console.error(`pruner: failed to persist ${kind} diagnostic:`, err);
+      return;
+    }
+    this.seen.add(key);
+    this.counters[kind]++;
+  }
+
+  counts(): Record<DiagnosticKind, number> {
+    return { ...this.counters };
+  }
+
+  /** Clears session-scoped state; call on session_start/session_tree since this sink is process-scoped, not session-scoped. */
+  reset(): void {
+    this.seen.clear();
+    for (const kind of Object.keys(this.counters) as DiagnosticKind[]) {
+      this.counters[kind] = 0;
+    }
+  }
+}

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,160 @@ 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",
+      hasLegacyBareRecord: (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,
     };
   }