@adeildo/pi-compact 5.7.2 → 5.9.0

package/README.md

@@ -7,7 +7,7 @@
 
 <p align="center">
   <strong>Keeps a long session's context small, so each request costs less.</strong><br>
-  Old tool output goes. The agent's words, your words and the decisions stay.
+  It hides old tool output and keeps the agent's words, your words and the decisions.
 </p>
 
 <p align="center"><code>pi install npm:@adeildo/pi-compact</code></p>
@@ -22,9 +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.
 
-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.
+On Anthropic's own models, Anthropic clears the old output on its side instead, with [`clear_tool_uses`](https://platform.claude.com/docs/en/build-with-claude/context-editing). Nothing edits the session, so the agent keeps its earlier thinking. Anthropic signs each thinking block with the conversation before it, and an edit drops the blocks of every later turn. The last 10 calls stay whole, and older ones keep their parameters, so the agent still sees what it read and ran. In a live test that cleared the parameters too, the agent took its own earlier reports for invented ones.
 
-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.
+Each prune or clear leaves a line in the chat, with what rewriting the prompt cache costs and when that pays back. `Ctrl+O` lists the calls it hid.
 
 <!-- docs:compact/prune -->
 
@@ -38,7 +38,7 @@ Each prune leaves a line in the chat, with the most the next request pays to rew
 
 When pi compacts anyway, pi's own prompt writes the summary on a small model, and the tasks and your last words go on top as they are, so no model rephrases a decision. Without tasks, pi writes the summary on the session's model.
 
-On six recorded sessions, an agent that only had the summary answered 48 questions about what was dropped. A judge graded the answers against the truth: pi's summary on Haiku scored as well as on Opus, within the judge's noise, for 1/40 of the price. A first version that wrote its own short summary from the tasks scored 2.6 of 5 against pi's 3.9, and was dropped. The method is [Factory's probes](https://factory.ai/news/evaluating-compression), and `bun packages/compact/eval/summary.ts` runs it.
+On six recorded sessions, an agent that only had the summary answered 48 questions about what was dropped. A judge graded the answers against the truth. pi's summary on Haiku scored as well as on Opus, within the judge's noise, for 1/40 of the price. A first version that wrote its own short summary from the tasks scored 2.6 of 5 against pi's 3.9, and was dropped. The method is [Factory's probes](https://factory.ai/news/evaluating-compression), and `bun packages/compact/eval/summary.ts` runs it.
 
 ## Why this way
 
@@ -47,27 +47,35 @@ On six recorded sessions, an agent that only had the summary answered 48 questio
 - 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 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.
+Replaying a week of real sessions, mostly Opus with a 1M context, costs 32% less with the prune and 27% less with Anthropic's clearing, which keeps the parameters and the thinking. 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 [--server 10]` replays yours.
 
 ## With pi's compaction
 
-Nothing of pi's is turned off. The prune runs at the end of each turn, right before pi checks its own compaction threshold, so pi rarely needs to compact. `/compact` and auto-compaction still work; this package only writes their summary. The prune is a `context_edit`, so the session file keeps every output, and `/tree` to an earlier point shows them again.
+The package turns off nothing of pi's. The prune runs at the end of each turn, right before pi checks its own compaction threshold, so pi rarely needs to compact. `/compact` and auto-compaction still work; this package only writes their summary. The prune is a `context_edit`, so the session file keeps every output, and `/tree` to an earlier point shows them again. Anthropic's clearing edits nothing in the session.
 
 ## Commands and settings
 
-`/prune` hides old output at the end of the next turn, whatever the context's size.
+`/prune` hides old output at the end of the next turn, whatever the context's size. It edits the context on Anthropic models too, so it drops the thinking there.
 
 On the Compact tab of `Alt+S`, stored under `compact` in `~/.pi/agent/extensions/pi-harness/settings.json`:
 
 | Setting                 | Default  | Does                                                                                                   |
 | ----------------------- | -------- | ------------------------------------------------------------------------------------------------------ |
 | Hide old tool output    | on       | The prune                                                                                              |
+| On Anthropic's side     | on       | On Anthropic models, Anthropic clears instead of the prune, and the agent keeps its thinking           |
 | Above                   | `150000` | Context tokens that start a prune                                                                      |
 | Write it from the tasks | on       | The tasks on top of pi's summary, written on the model below. Off, pi writes it on the session's model |
 | Model                   | `auto`   | Writes the summary. `auto` is the cheapest of the session's provider                                   |
 
 The tab also shows what this session's prunes freed and how many hidden outputs the agent ran again. A high share means the prune hides what the agent still needs.
 
+Part of [pi-harness](https://github.com/felipeadeildo/pi-harness), which brings every piece in one install.
+
 ## License
 
 MIT
+
+<p align="center">
+  <a href="https://adeildo.dev"><img src="https://adeildo.dev/assets/images/cat.svg" width="42" height="42" alt="adeildo.dev"></a><br>
+  Brought to you by <a href="https://adeildo.dev">adeildo.dev</a>
+</p>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@adeildo/pi-compact",
-	"version": "5.7.2",
+	"version": "5.9.0",
 	"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.2"
+		"@adeildo/pi-kit": "5.9.0"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",

package/src/index.ts

@@ -13,11 +13,16 @@ import {
 	estimateTokens,
 	type ExtensionAPI,
 	type ExtensionContext,
+	type SessionBoundaryDraft,
+	type TurnEndEvent,
 } from "@earendil-works/pi-coding-agent";
 
-import { describeCall, KEEP_TURNS, pruneNow, sizeAfter } from "./prune.ts";
+import { describeCall, KEEP_TURNS, planServerClear, pruneNow, sizeAfter } from "./prune.ts";
 import {
+	type Billed,
+	clearedEntries,
 	hiddenCalls,
+	lastPromptOf,
 	NOTE_MESSAGE,
 	PRUNE_ENTRY,
 	priced,
@@ -29,9 +34,11 @@ import {
 	spentOn,
 	tokens,
 } from "./record.ts";
+import { clearsOnServer, KEEP_TOOL_USES, serverCleared, withServerClearing } from "./server.ts";
 import {
 	COMPACT_SETTINGS,
 	model,
+	onServer,
 	prune,
 	PRUNE_SECTION,
 	pruneAbove,
@@ -50,12 +57,27 @@ export const compact = defineFeature({
 	setup(scope) {
 		let forced = false;
 		let hidden = new Set<string>();
+		let cleared = new Set<string>();
+		let lastPrompt: number | undefined;
 
 		const restore = (ctx: ExtensionContext) => {
-			hidden = hiddenCalls(ctx.sessionManager.getBranch());
+			const branch = ctx.sessionManager.getBranch();
+			hidden = hiddenCalls(branch);
+			cleared = clearedEntries(branch);
+			lastPrompt = lastPromptOf(branch);
 		};
 		scope.onSessionStart(restore);
 		scope.on("session_tree", (_event, ctx) => restore(ctx));
+		scope.on("session_compact", () => {
+			lastPrompt = undefined;
+		});
+
+		const onServerFor = (ctx: ExtensionContext) =>
+			prune.get(scope) && onServer.get(scope) && clearsOnServer(ctx.model);
+
+		scope.on("before_provider_request", (event, ctx) =>
+			onServerFor(ctx) ? withServerClearing(event.payload, pruneAbove.get(scope)) : undefined,
+		);
 
 		// Pi checks its own compaction right after turn_end, so pruning here usually spares it.
 		scope.on("turn_end", (event, ctx) => {
@@ -68,8 +90,18 @@ export const compact = defineFeature({
 			)
 				return undefined;
 			const { input, cacheRead, cacheWrite } = message.usage;
+			const prompt = input + cacheRead + cacheWrite;
+			const previous = lastPrompt;
+			lastPrompt = prompt;
+			if (!forced && onServerFor(ctx)) {
+				if (previous === undefined || !serverCleared(previous, prompt, pruneAbove.get(scope)))
+					return undefined;
+				return {
+					entries: [...event.entries, ...clearedOnServer(event, ctx, previous, message.usage)],
+				};
+			}
 			const outputs = event.toolResults.reduce((sum, result) => sum + estimateTokens(result), 0);
-			const before = input + cacheRead + cacheWrite + outputs;
+			const before = prompt + outputs;
 			const asked = forced;
 			forced = false;
 			const plan = pruneNow(event.context.contextEntries, before, pruneAbove.get(scope), asked);
@@ -97,13 +129,13 @@ export const compact = defineFeature({
 				...cost,
 			};
 			for (const { call } of plan.hidden) hidden.add(call);
-			const tasks =
-				currentTasks(scope.events)?.state ?? tasksFromEntries(ctx.sessionManager.getBranch());
+			// The next request is smaller for the edit, not for a server clear.
+			lastPrompt = undefined;
 			return {
 				entries: [
 					...event.entries,
 					...plan.edits,
-					note(tasks),
+					note(tasksNow(ctx), false),
 					{ type: "custom", customType: PRUNE_ENTRY, data: record },
 				],
 			};
@@ -133,7 +165,12 @@ export const compact = defineFeature({
 			description: "Hide old tool output at the end of the next turn, whatever the context's size",
 			handler: async (_args, ctx) => {
 				forced = true;
-				ctx.ui.notify(`Old tool output goes at the end of the next turn.`, "info");
+				ctx.ui.notify(
+					onServerFor(ctx)
+						? "Old tool output goes at the end of the next turn. On Anthropic models this edit drops the agent's earlier thinking, which Anthropic's own clearing keeps."
+						: "Old tool output goes at the end of the next turn.",
+					"info",
+				);
 			},
 		});
 
@@ -143,13 +180,48 @@ export const compact = defineFeature({
 		});
 
 		registerScreen(scope);
+
+		/** Records what Anthropic cleared on the request that just answered, and recites the tasks. */
+		function clearedOnServer(
+			event: TurnEndEvent,
+			ctx: ExtensionContext,
+			previous: number,
+			usage: Billed,
+		): SessionBoundaryDraft[] {
+			const prompt = usage.input + usage.cacheRead + usage.cacheWrite;
+			const entries = event.context.contextEntries;
+			const end = entries.findIndex((item) => item.sourceEntry.id === event.messageEntryId);
+			const plan = planServerClear(
+				end === -1 ? entries : entries.slice(0, end),
+				KEEP_TOOL_USES,
+				cleared,
+			);
+			for (const { entry, call } of plan.hidden) {
+				cleared.add(entry);
+				hidden.add(call);
+			}
+			const record: PruneRecord = {
+				before: previous,
+				after: prompt,
+				hidden: plan.hidden,
+				server: true,
+				...priced(usage, ctx.model?.cost.cacheRead ?? 0, previous - prompt, usage.cacheWrite),
+			};
+			return [note(tasksNow(ctx), true), { type: "custom", customType: PRUNE_ENTRY, data: record }];
+		}
+
+		function tasksNow(ctx: ExtensionContext): SessionTasks {
+			return currentTasks(scope.events)?.state ?? tasksFromEntries(ctx.sessionManager.getBranch());
+		}
 	},
 });
 
-// Recites the tasks after a prune, so the agent keeps its goals.
-function note(tasks: SessionTasks): CustomMessageEntryDraft {
+// Recites the tasks after a prune or a clear, so the agent keeps its goals.
+function note(tasks: SessionTasks, server: boolean): CustomMessageEntryDraft {
 	const parts = [
-		"Older tool output was hidden to save context. Each placeholder names the call it came from: run it again if you need it.",
+		server
+			? "Anthropic cleared older tool output to save context. The calls are still there: run one again if you need its output."
+			: "Older tool output was hidden to save context. Each placeholder names the call it came from: run it again if you need it.",
 	];
 	const stands = describeTasks(tasks, { done: 10, decisions: 10 });
 	if (stands !== "") parts.push(`Where the session stands:\n${stands}`);

package/src/prune.ts

@@ -12,7 +12,8 @@ const MIN_OUTPUT_TOKENS = 250;
 const MIN_ARGUMENT_CHARS = 1500;
 const LONG_STRING = 200;
 const SHOWN_CHARS = 120;
-const KEPT_TOOLS = new Set(["ask_questions"]);
+export const KEPT_TOOLS = ["ask_questions"];
+const SERVER_PLACEHOLDER = "[cleared]";
 
 export interface Hidden {
 	entry: string;
@@ -41,28 +42,15 @@ interface Visible {
 }
 
 export function planPrune(entries: readonly ProjectedSessionEntry[]): PrunePlan {
-	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] }]
-			: [],
-	);
-	plan.total = visible.reduce((sum, { message }) => sum + estimateTokens(message), 0);
+	const visible = visibleOf(entries);
+	const plan: PrunePlan = { edits: [], hidden: [], freed: 0, total: totalOf(visible) };
 	const turns = visible.flatMap((entry, index) =>
 		entry.message.role === "assistant" ? [index] : [],
 	);
 	const cutoff = turns.at(-KEEP_TURNS);
 	if (turns.length <= KEEP_TURNS || cutoff === undefined) return plan;
 
-	const calls = new Map(
-		visible.flatMap(({ message }) =>
-			message.role === "assistant"
-				? message.content.flatMap((part) =>
-						part.type === "toolCall" ? [[part.id, part] as const] : [],
-					)
-				: [],
-		),
-	);
+	const calls = callsOf(visible);
 	for (const { id, message } of visible.slice(0, cutoff)) {
 		if (message.role === "toolResult") hideOutput(plan, id, message, calls.get(message.toolCallId));
 		if (message.role === "assistant") cutArguments(plan, id, message);
@@ -83,11 +71,88 @@ export function pruneNow(
 	return plan;
 }
 
+/**
+ * What Anthropic's `clear_tool_uses` takes out when it runs: every tool result but the last
+ * `keep`, errors too, leaving the calls. `cleared` are the entries it took out before.
+ */
+export function planServerClear(
+	entries: readonly ProjectedSessionEntry[],
+	keep: number,
+	cleared: ReadonlySet<string> = new Set(),
+	inputs = false,
+): PrunePlan {
+	const visible = visibleOf(entries);
+	const plan: PrunePlan = { edits: [], hidden: [], freed: 0, total: totalOf(visible) };
+	const calls = callsOf(visible);
+	const results = visible.filter(
+		({ message }) => message.role === "toolResult" && !KEPT_TOOLS.includes(message.toolName),
+	);
+	for (const { id, message } of results.slice(0, Math.max(0, results.length - keep))) {
+		if (message.role !== "toolResult" || cleared.has(id)) continue;
+		const call = calls.get(message.toolCallId);
+		const tokens = estimateTokens(message);
+		const content = [{ type: "text" as const, text: SERVER_PLACEHOLDER }];
+		plan.edits.push({ type: "context_edit", targetId: id, replacement: { content } });
+		plan.hidden.push({
+			entry: id,
+			call: call === undefined ? message.toolName : describeCall(call.name, call.arguments),
+			tokens,
+		});
+		plan.freed += tokens - estimateTokens({ ...message, content });
+		// estimateTokens counts four characters a token.
+		if (inputs && call !== undefined) plan.freed += JSON.stringify(call.arguments).length / 4;
+	}
+	return plan;
+}
+
+/** The server clears only past `above`, and only when it frees `clearAtLeast` real tokens. */
+export function serverClearNow(
+	entries: readonly ProjectedSessionEntry[],
+	contextTokens: number,
+	above: number,
+	keep: number,
+	cleared: ReadonlySet<string> = new Set(),
+	inputs = false,
+): PrunePlan | undefined {
+	if (contextTokens < above) return undefined;
+	const plan = planServerClear(entries, keep, cleared, inputs);
+	if (plan.freed * scale(plan, contextTokens) < clearAtLeast(above)) return undefined;
+	return plan;
+}
+
+export function clearAtLeast(above: number): number {
+	return Math.round(MIN_FREED_SHARE * above);
+}
+
 /** The context's size after `plan`, in the tokens the API reported for it before. */
 export function sizeAfter(plan: PrunePlan, contextTokens: number): number {
 	return Math.round(contextTokens - plan.freed * scale(plan, contextTokens));
 }
 
+function visibleOf(entries: readonly ProjectedSessionEntry[]): Visible[] {
+	return entries.flatMap(({ sourceEntry, messages }): Visible[] =>
+		sourceEntry.type === "message" && messages.length === 1 && messages[0] !== undefined
+			? [{ id: sourceEntry.id, message: messages[0] }]
+			: [],
+	);
+}
+
+function totalOf(visible: readonly Visible[]): number {
+	return visible.reduce((sum, { message }) => sum + estimateTokens(message), 0);
+}
+
+function callsOf(visible: readonly Visible[]): Map<string, ToolCall> {
+	return new Map(
+		visible.flatMap(({ message }) =>
+			message.role === "assistant"
+				? message.content.flatMap((part) =>
+						part.type === "toolCall" ? [[part.id, part] as const] : [],
+					)
+				: [],
+		),
+	);
+}
+
 function scale(plan: PrunePlan, contextTokens: number): number {
 	return plan.total === 0 ? 0 : contextTokens / plan.total;
 }
@@ -99,7 +164,7 @@ function hideOutput(
 	call: ToolCall | undefined,
 ): void {
 	// Errors stay: without them the agent repeats what failed.
-	if (message.isError || KEPT_TOOLS.has(message.toolName)) return;
+	if (message.isError || KEPT_TOOLS.includes(message.toolName)) return;
 	const tokens = estimateTokens(message);
 	if (tokens < MIN_OUTPUT_TOKENS) return;
 	const described = call === undefined ? message.toolName : describeCall(call.name, call.arguments);
@@ -158,7 +223,7 @@ function shortenedValue(value: JsonValue): JsonValue {
 
 function clip(text: string): string {
 	const line = text.trim().split("\n")[0] ?? "";
-	return line.length <= SHOWN_CHARS ? line : `${line.slice(0, SHOWN_CHARS - 1)}\u2026`;
+	return line.length <= SHOWN_CHARS ? line : `${line.slice(0, SHOWN_CHARS - 3)}...`;
 }
 
 function rounded(tokens: number): string {

package/src/record.ts

@@ -17,7 +17,9 @@ export interface PruneRecord {
 	after: number;
 	hidden: Hidden[];
 	forced?: boolean;
-	/** Dollars the next request pays to write the cache again. */
+	/** Anthropic cleared it on its side, on the request this was recorded after. */
+	server?: boolean;
+	/** Dollars the next request pays to write the cache again, or paid already when `server`. */
 	rewrite?: number;
 	/** Dollars each request after saves. */
 	saving?: number;
@@ -48,6 +50,7 @@ export function recordOf(entry: unknown): PruneRecord | undefined {
 		before: data.before,
 		after: data.after,
 		hidden: Array.isArray(data.hidden) ? (data.hidden as Hidden[]) : [],
+		...(data.server === true ? { server: true } : {}),
 		...(typeof data.rewrite === "number" ? { rewrite: data.rewrite } : {}),
 		...(typeof data.saving === "number" ? { saving: data.saving } : {}),
 	};
@@ -82,6 +85,34 @@ export function spentOn(branch: readonly unknown[]): Spent {
 	return spent;
 }
 
+/** Entries Anthropic cleared on its side, which the session itself still holds whole. */
+export function clearedEntries(branch: readonly unknown[]): Set<string> {
+	const entries = new Set<string>();
+	for (const entry of branch) {
+		const record = recordOf(entry);
+		if (record?.server) for (const { entry: id } of record.hidden) entries.add(id);
+	}
+	return entries;
+}
+
+/**
+ * The last request's prompt, so the first clear after a reload is seen. Undefined after an edit or
+ * a compaction, which shrink the next request on their own.
+ */
+export function lastPromptOf(branch: readonly unknown[]): number | undefined {
+	for (const entry of branch.toReversed()) {
+		if (!isObject(entry) || entry.type === "compaction" || entry.type === "context_edit")
+			return undefined;
+		const message = entry.type === "message" && isObject(entry.message) ? entry.message : {};
+		const { role, stopReason, usage } = message;
+		if (role !== "assistant" || stopReason === "error" || stopReason === "aborted") continue;
+		if (!isObject(usage)) return undefined;
+		const { input, cacheRead, cacheWrite } = usage;
+		return Number(input) + Number(cacheRead) + Number(cacheWrite) || undefined;
+	}
+	return undefined;
+}
+
 export function hiddenCalls(branch: readonly unknown[]): Set<string> {
 	const calls = new Set<string>();
 	for (const entry of branch) {
@@ -110,10 +141,13 @@ export function costRows(record: PruneRecord): [string, string][] {
 	const { rewrite, saving } = record;
 	if (rewrite === undefined || saving === undefined || saving < 0.005) return [];
 	if (rewrite < 0.005) return [["saved on each request after", money(saving)]];
+	const paid = record.server
+		? "cache rewrite on this request"
+		: "cache rewrite on the next request, at most";
 	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, at most", money(rewrite)],
+		[paid, money(rewrite)],
 		[`saved on each request after, ${back}`, money(saving)],
 	];
 }
@@ -138,10 +172,10 @@ export class PruneEntry implements Component {
 
 	render(width: number): string[] {
 		const theme = this.#theme;
-		const { before, after, hidden } = this.#record;
+		const { before, after, hidden, server } = this.#record;
 		// Glyph on the tool box's border column, text on its content column, numbers on its edge.
 		const edge = width - 1;
-		const head = ` ${theme.fg("accent", `${GLYPH} pruned`)}  `;
+		const head = ` ${theme.fg("accent", `${GLYPH} ${server ? "cleared" : "pruned"}`)}  `;
 		const stats = `${tokens(before)} \u2192 ${tokens(after)} tokens`;
 		const lines = [row(head, theme.fg("text", outputsHidden(hidden.length)), stats, edge, theme)];
 		for (const [label, amount] of costRows(this.#record))
@@ -153,13 +187,13 @@ export class PruneEntry implements Component {
 			const more = hidden.length - shown.length;
 			if (more > 0) lines.push(INDENT + theme.fg("dim", `and ${more} more`));
 		}
-		return lines.map((line) => truncateToWidth(line, width, "\u2026"));
+		return lines.map((line) => truncateToWidth(line, width, "..."));
 	}
 }
 
 function row(head: string, detail: string, stats: string, width: number, theme: Theme): string {
 	const room = width - visibleWidth(head) - visibleWidth(stats) - 1;
-	const shown = truncateToWidth(detail, Math.max(8, room), "\u2026");
+	const shown = truncateToWidth(detail, Math.max(8, room), "...");
 	const gap = Math.max(1, width - visibleWidth(head) - visibleWidth(shown) - visibleWidth(stats));
 	return head + shown + " ".repeat(gap) + theme.fg("dim", stats);
 }

package/src/server.ts

@@ -0,0 +1,45 @@
+// On Anthropic models, Anthropic clears old tool output on its side with clear_tool_uses. Its
+// clearing never drops the agent's thinking, where an edit to the context drops the thinking of
+// every later turn: platform.claude.com/docs/en/build-with-claude/context-editing
+// The calls stay: with their parameters cleared too, an agent in a test took its own earlier
+// reports for invented.
+import { isObject } from "@adeildo/pi-kit";
+
+import { clearAtLeast, KEPT_TOOLS } from "./prune.ts";
+
+export const KEEP_TOOL_USES = 10;
+const BETA = "context-management-2025-06-27";
+
+/** Anthropic's own API only: other endpoints that speak it may refuse the beta. */
+export function clearsOnServer(model: { provider: string; api: string } | undefined): boolean {
+	return model?.provider === "anthropic" && model.api === "anthropic-messages";
+}
+
+/** Undefined leaves the payload as it is, like one another extension already manages. */
+export function withServerClearing(payload: unknown, above: number): unknown {
+	if (!isObject(payload) || payload.context_management !== undefined) return undefined;
+	const betas = Array.isArray(payload.betas) ? payload.betas : [];
+	return {
+		...payload,
+		betas: betas.includes(BETA) ? betas : [...betas, BETA],
+		context_management: {
+			edits: [
+				{
+					type: "clear_tool_uses_20250919",
+					trigger: { type: "input_tokens", value: above },
+					keep: { type: "tool_uses", value: KEEP_TOOL_USES },
+					clear_at_least: { type: "input_tokens", value: clearAtLeast(above) },
+					exclude_tools: KEPT_TOOLS,
+				},
+			],
+		},
+	};
+}
+
+/**
+ * pi does not pass on what the server cleared, so a request whose context shrank by half the
+ * clearing minimum counts as cleared. A turn adds far less than that.
+ */
+export function serverCleared(previous: number, prompt: number, above: number): boolean {
+	return previous - prompt >= clearAtLeast(above) / 2;
+}

package/src/settings.ts

@@ -15,6 +15,18 @@ export const prune = setting({
 	},
 });
 
+export const onServer = setting({
+	id: "compact.server",
+	default: true,
+	decoder: boolean,
+	ui: {
+		section: PRUNE_SECTION,
+		label: "On Anthropic's side",
+		description:
+			"On Anthropic models, Anthropic clears old tool output itself and keeps the last 10 calls whole, so the agent keeps its thinking. Off, the prune edits the context there too, which drops the thinking of every later turn.",
+	},
+});
+
 export const pruneAbove = setting({
 	id: "compact.pruneAbove",
 	default: 150_000,
@@ -53,4 +65,4 @@ export const model = setting({
 	},
 });
 
-export const COMPACT_SETTINGS = [prune, pruneAbove, summary, model];
+export const COMPACT_SETTINGS = [prune, onServer, pruneAbove, summary, model];

package/src/summary.ts

@@ -77,7 +77,7 @@ function yourWords(messages: readonly AgentMessage[]): string[] {
 			.replace(/\s+/g, " ")
 			.trim();
 		if (text === "") return [];
-		return [text.length <= MAX_ASK_CHARS ? text : `${text.slice(0, MAX_ASK_CHARS - 1)}\u2026`];
+		return [text.length <= MAX_ASK_CHARS ? text : `${text.slice(0, MAX_ASK_CHARS - 3)}...`];
 	});
 	return words.slice(-MAX_ASKS);
 }