@adeildo/pi-compact 5.7.1 → 5.7.2

package/README.md

@@ -22,7 +22,9 @@ Output hidden to save context, about 4.2k tokens. It came from: read src/view.ts
 
 Long arguments go the same way, like a script sent to bash or a file sent to write. Your messages, the agent's own words, errors and the last 10 turns stay whole. After a prune the agent gets the session's [tasks](../tasks) at the end of its context, so it keeps its goals.
 
-Each prune leaves a line in the chat, with what the next request pays to rewrite the prompt cache and when that pays back. `Ctrl+O` lists the calls it hid.
+On Anthropic models that think, a prune also costs the agent its earlier reasoning. Anthropic signs each thinking block together with the conversation before it, and drops the blocks whose earlier conversation changed. pi then shows "Anthropic dropped N thinking blocks". The visible words stay.
+
+Each prune leaves a line in the chat, with the most the next request pays to rewrite the prompt cache and when that pays back. `Ctrl+O` lists the calls it hid.
 
 <!-- docs:compact/prune -->
 
@@ -42,10 +44,10 @@ On six recorded sessions, an agent that only had the summary answered 48 questio
 
 - Hiding old tool output works as well as summarizing it and costs less. Summaries made agents run 13 to 15% longer ([JetBrains, NeurIPS 2025](https://arxiv.org/abs/2508.21433)).
 - A model that picks what to keep cost 94% more with no gain in quality ([OpenHands, 2026](https://arxiv.org/abs/2605.18854)). The rules here are plain code.
-- Every edit rewrites the prompt cache ([Anthropic](https://platform.claude.com/docs/en/build-with-claude/context-editing)), so a prune waits until it frees at least a fifth of the context at once. Without that, the same sessions cost 12% more.
+- After a prune, the next request writes the whole conversation to the prompt cache again. Anthropic reuses cache only where an earlier request wrote it ([Anthropic](https://platform.claude.com/docs/en/build-with-claude/context-editing)), and the writes near old outputs have expired. So a prune waits until it frees at least two fifths of the context at once. Pruning a little every turn would cost 3.4 times as much.
 - Errors stay and every placeholder keeps its call, after [Manus](https://manus.im/blog/Context-Engineering-for-AI-Agents-Lessons-from-Building-Manus).
 
-Replaying a week of real sessions through it, mostly Opus with a 1M context, costs 34% less, the cache rewrites included. `bun packages/compact/eval/replay.ts` replays yours.
+Replaying a week of real sessions through it, mostly Opus with a 1M context, costs 32% less. The replay has each prune's next request write all of the context again, so the real saving is at least that. `bun packages/compact/eval/replay.ts` replays yours.
 
 ## With pi's compaction
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@adeildo/pi-compact",
-	"version": "5.7.1",
+	"version": "5.7.2",
 	"description": "Keeps a long pi session's context small: hides old tool output, keeping each call so the agent can run it again, and writes pi's compaction summary from the session's tasks.",
 	"keywords": [
 		"compaction",
@@ -37,7 +37,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@adeildo/pi-kit": "5.7.1"
+		"@adeildo/pi-kit": "5.7.2"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",

package/src/index.ts

@@ -15,7 +15,7 @@ import {
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 
-import { describeCall, KEEP_TURNS, pruneNow, rewrittenAfter, sizeAfter } from "./prune.ts";
+import { describeCall, KEEP_TURNS, pruneNow, sizeAfter } from "./prune.ts";
 import {
 	hiddenCalls,
 	NOTE_MESSAGE,
@@ -86,7 +86,8 @@ export const compact = defineFeature({
 				message.usage,
 				ctx.model?.cost.cacheRead ?? 0,
 				before - after,
-				rewrittenAfter(plan, before),
+				// Only the system prompt stays cached, so the next request writes all of this again.
+				after,
 			);
 			const record: PruneRecord = {
 				before,

package/src/prune.ts

@@ -7,7 +7,7 @@ import {
 // 10 turns did best on SWE-bench: arxiv.org/abs/2508.21433
 export const KEEP_TURNS = 10;
 // Each prune rewrites the prompt cache, so it waits to free this much at once.
-export const MIN_FREED_SHARE = 0.2;
+export const MIN_FREED_SHARE = 0.4;
 const MIN_OUTPUT_TOKENS = 250;
 const MIN_ARGUMENT_CHARS = 1500;
 const LONG_STRING = 200;
@@ -26,8 +26,6 @@ export interface PrunePlan {
 	/** Estimated, like `total`: compare them, never `freed` with tokens the API reported. */
 	freed: number;
 	total: number;
-	/** Estimated tokens before the first edit, which the prompt cache keeps. */
-	cachedPrefix: number;
 }
 
 export type AgentMessage = ProjectedSessionEntry["messages"][number];
@@ -43,7 +41,7 @@ interface Visible {
 }
 
 export function planPrune(entries: readonly ProjectedSessionEntry[]): PrunePlan {
-	const plan: PrunePlan = { edits: [], hidden: [], freed: 0, total: 0, cachedPrefix: 0 };
+	const plan: PrunePlan = { edits: [], hidden: [], freed: 0, total: 0 };
 	const visible = entries.flatMap(({ sourceEntry, messages }): Visible[] =>
 		sourceEntry.type === "message" && messages.length === 1 && messages[0] !== undefined
 			? [{ id: sourceEntry.id, message: messages[0] }]
@@ -69,11 +67,6 @@ export function planPrune(entries: readonly ProjectedSessionEntry[]): PrunePlan
 		if (message.role === "toolResult") hideOutput(plan, id, message, calls.get(message.toolCallId));
 		if (message.role === "assistant") cutArguments(plan, id, message);
 	}
-	const edited = new Set(plan.edits.map((edit) => edit.targetId));
-	const first = visible.findIndex(({ id }) => edited.has(id));
-	plan.cachedPrefix = visible
-		.slice(0, Math.max(0, first))
-		.reduce((sum, { message }) => sum + estimateTokens(message), 0);
 	return plan;
 }
 
@@ -95,12 +88,6 @@ export function sizeAfter(plan: PrunePlan, contextTokens: number): number {
 	return Math.round(contextTokens - plan.freed * scale(plan, contextTokens));
 }
 
-/** What the next request writes to the cache again: everything after the first edit. */
-export function rewrittenAfter(plan: PrunePlan, contextTokens: number): number {
-	const kept = plan.cachedPrefix * scale(plan, contextTokens);
-	return Math.max(0, Math.round(sizeAfter(plan, contextTokens) - kept));
-}
-
 function scale(plan: PrunePlan, contextTokens: number): number {
 	return plan.total === 0 ? 0 : contextTokens / plan.total;
 }

package/src/record.ts

@@ -113,7 +113,7 @@ export function costRows(record: PruneRecord): [string, string][] {
 	const requests = Math.ceil(rewrite / saving);
 	const back = requests === 1 ? "back in 1 request" : `back in ${requests} requests`;
 	return [
-		["cache rewrite on the next request", money(rewrite)],
+		["cache rewrite on the next request, at most", money(rewrite)],
 		[`saved on each request after, ${back}`, money(saving)],
 	];
 }

package/src/settings.ts

@@ -23,7 +23,7 @@ export const pruneAbove = setting({
 		section: PRUNE_SECTION,
 		label: "Above",
 		description:
-			"Context size that starts a prune. Each prune rewrites the prompt cache once, so it waits until it can free at least a fifth of the context.",
+			"Context size that starts a prune. Each prune rewrites the prompt cache once, so it waits until it can free at least two fifths of the context.",
 		control: { type: "number", min: 20_000, max: 2_000_000, step: 10_000, unit: " tokens" },
 	},
 });