@oh-my-pi/pi-agent-core 18.1.16 → 18.1.18

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [18.1.18] - 2026-09-11
+
+### Added
+
+- Anthropic server-side compaction as a `remote` compaction backend: model lines the beta supports (`compat.supportsServerCompaction`, rule-owned in the catalog: Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5) on the official endpoint, resolved the way the provider routes requests, plus Anthropic-compatible routes with `remoteCompaction.enabled`, compact by re-issuing the live turn's own request — same system prompt, tools, and history, so it reads the prompt cache the last turn wrote — with the `compact_20260112` edit paused after the summary and the harness summary prompt as `instructions`. The instructions name where the retained tail begins so the summary covers only the history the rebuilt context drops. The API's summary is stored as the entry text and as `preserveData.anthropicCompaction`, replayed natively on later Anthropic requests and read as plain text by every other provider; the retained tail comes from session entries as with a local summary. Contexts below 55k tokens (the API trigger floor plus margin) keep summarizing locally, and a response without a summary is a native failure, like the OpenAI lanes. An aborted compaction response is the abort (a cancellation, never a native failure) and an error response keeps its HTTP status, so auth and timeout classification match the OpenAI lanes; the block's opaque `encrypted_content` is persisted as `preserveData.anthropicCompaction.encryptedContent` and replayed verbatim.
+
+### Fixed
+
+- `compact()` now forwards the caller's `oneshotRetry` opt-out to every summarization oneshot; auto-compaction's outer retry loop no longer multiplies with the inner transient-failure retries.
+
+## [18.1.17] - 2026-09-10
+
+### Changed
+
+- `Tool <name> not found` now names a plausible intended target when the advertised set contains one, e.g. `Tool mcp__abc123__xyz789_read not found. Did you mean read?`. A model that mis-transcribes a long opaque tool name reliably keeps the trailing segment, which is the only part carrying meaning, so the miss becomes recoverable in the same turn instead of costing a round trip. Purely advisory — the suggestion is only ever a string in the error, never a dispatch target, so an unrecognized name still fails ([#10109](https://github.com/can1357/oh-my-pi/issues/10109) by [@oldschoola](https://github.com/oldschoola)).
+
+### Fixed
+
+- Fixed the token estimator counting developer messages as free and ignoring images in user content, which let context budgeting, pruning and the compaction trigger read a transcript as far smaller than the one sent to the provider.
+- Fixed repeated local compaction omitting messages retained before the previous compaction record, while preserving original entry IDs and `/clear` boundaries.
+- Raised remote compaction request timeout from 3 minutes to 5 minutes so long Codex/gpt-6-astra compact streams can finish before the watchdog aborts them.
+- Fixed proxy responses dropping the cost the server reported; recorded costs are kept instead of being recomputed.
+
 ## [18.1.10] - 2026-09-04
 
 ### Fixed

package/dist/types/compaction/anthropic.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Anthropic server-side compaction (`compact-2026-01-12` beta).
+ *
+ * The compaction request is the live turn's own request shape — same system
+ * prompt, tools, and message history — plus the `compact_20260112` edit with
+ * `pause_after_compaction`. The API summarizes the prompt from the already
+ * cached prefix and stops; the summary arrives as a `compaction` block that
+ * the provider surfaces as an `anthropicCompaction` payload. The summary is
+ * plain text, so it doubles as the compaction entry's readable summary for
+ * every other provider, while the Anthropic provider replays it as a native
+ * block (the API drops everything that precedes it). The retained tail after
+ * the cut point is replayed from session entries exactly like a local summary.
+ */
+import type { AnthropicCompactionPayload, ApiKey, Effort, Message, Model, SimpleStreamOptions, Tool, Usage } from "@oh-my-pi/pi-ai";
+import { type InstrumentedChatSpanOptions } from "../telemetry.js";
+export declare const ANTHROPIC_COMPACTION_PRESERVE_KEY = "anthropicCompaction";
+/** The API rejects a `compact_20260112` trigger below this many input tokens. */
+export declare const ANTHROPIC_COMPACTION_MIN_TRIGGER_TOKENS = 50000;
+/**
+ * Smallest context the native lane accepts. The trigger sits at the API
+ * floor, so a prompt that lands below it is answered instead of compacted;
+ * the margin over the floor absorbs the difference between the last reported
+ * context size and the compaction request's own input.
+ */
+export declare const ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS = 55000;
+/** Summary persisted under {@link ANTHROPIC_COMPACTION_PRESERVE_KEY}. */
+export interface AnthropicCompactionPreserveData {
+    provider: string;
+    content: string;
+    /** Opaque provider state the API attached to the block; replayed verbatim. */
+    encryptedContent?: string;
+    /** Harness file metadata (`<files>` section) replayed after the native block. */
+    filesText?: string;
+    /** Model that wrote the summary. */
+    model?: string;
+    /** Prompt tokens the compaction request processed, for display. */
+    usedTokens?: number;
+}
+/**
+ * Whether a model compacts through the Anthropic compaction beta. Model
+ * eligibility is catalog policy (`compat.supportsServerCompaction`, the
+ * lineage the beta documents); endpoint eligibility is resolved the way the
+ * provider routes requests, so a Foundry or `ANTHROPIC_BASE_URL` reroute of a
+ * first-party model is excluded unless the route opted in with
+ * `remoteCompaction.enabled`.
+ */
+export declare function shouldUseAnthropicNativeCompaction(model: Model): model is Model<"anthropic-messages">;
+export declare function getPreservedAnthropicCompactionData(preserveData: Record<string, unknown> | undefined): AnthropicCompactionPreserveData | undefined;
+/** Set or strip the Anthropic compaction slot; a new compaction never inherits a stale summary. */
+export declare function withAnthropicCompactionPreserveData(preserveData: Record<string, unknown> | undefined, compaction: AnthropicCompactionPreserveData | undefined): Record<string, unknown> | undefined;
+/** Replay payload for a compaction summary the active model produced natively. */
+export declare function getAnthropicCompactionPayload(preserveData: Record<string, unknown> | undefined): AnthropicCompactionPayload | undefined;
+/**
+ * The retained tail as the model will see it, for the summarization
+ * instructions: how many of the conversation's final wire messages stay in
+ * context verbatim, and the role of the first. The compaction request carries
+ * the whole conversation so the prompt cache the live turn wrote is read, but
+ * the summary must cover only the history before that tail — the local
+ * summarizer never sees the tail, and the rebuilt context replays it after the
+ * summary. Counting mirrors the provider's message conversion (consecutive
+ * tool results collapse into one user message; developer messages are user
+ * messages). Structured for the prompt template, which renders the
+ * singular/plural wording; the description quotes no content: quoting the
+ * tail would hand the summarizer the very facts it must leave to the tail.
+ */
+export interface RetainedTailScope {
+    count: number;
+    role: "assistant" | "user";
+}
+export declare function describeRetainedTail(messages: readonly Message[]): RetainedTailScope | undefined;
+/**
+ * Summarization prompt sent as the edit's `instructions`, which replace the
+ * API default entirely. The template lays out the retained-tail boundary
+ * first, so the summary covers only the history the rebuilt context drops,
+ * then the caller's extra context, the same structure prompt as the local
+ * summarizer, the caller's focus, and the tool-abstention clause the API
+ * recommends when tools are defined (a summarization pass that calls a tool
+ * yields no summary).
+ */
+export declare function buildAnthropicCompactionInstructions(basePrompt: string, customInstructions: string | undefined, extraContext: string | undefined, retainedTail: RetainedTailScope | undefined): string;
+export interface AnthropicNativeCompactionRequest {
+    systemPrompt: string[];
+    messages: Message[];
+    tools?: Tool[];
+    instructions: string;
+    maxTokens: number;
+    reasoning?: Effort;
+}
+export interface AnthropicNativeCompactionResponse {
+    content: string;
+    encryptedContent?: string;
+    usage: Usage;
+    model: string;
+}
+export interface AnthropicNativeCompactionOptions extends Pick<SimpleStreamOptions, "initiatorOverride" | "metadata" | "fetch" | "sessionId" | "promptCacheKey" | "providerSessionState" | "maxInFlightRequests">, Pick<InstrumentedChatSpanOptions, "completeImpl" | "telemetry" | "retry"> {
+}
+/**
+ * Run one compaction request and return the summary the API wrote, with the
+ * opaque `encrypted_content` the API attached for the replay. `completeSimple`
+ * resolves terminal failures as messages, so their classification is restored
+ * here: an aborted response is an `AbortError` (a cancellation, never a native
+ * failure) and an error response keeps its HTTP status, so auth and timeout
+ * handling downstream classify it the same way as the OpenAI lanes. A response
+ * without a summary is a native failure — the API answers the prompt instead
+ * when its input never reached the trigger, and returns an empty block when
+ * the model called a tool during summarization.
+ */
+export declare function requestAnthropicNativeCompaction(model: Model<"anthropic-messages">, apiKey: ApiKey, request: AnthropicNativeCompactionRequest, signal: AbortSignal | undefined, options: AnthropicNativeCompactionOptions): Promise<AnthropicNativeCompactionResponse>;

package/dist/types/compaction/compaction-v2-streaming.d.ts

@@ -12,8 +12,8 @@ import { type OpenAICodexCompactionBody } from "@oh-my-pi/pi-ai/providers/openai
 export declare const V2_RETAINED_MESSAGE_TOKEN_BUDGET = 64000;
 /** Max retries for V2 streaming compaction on transient stream errors. */
 export declare const V2_COMPACTION_MAX_RETRIES = 2;
-/** Timeout for V2 streaming compaction (3 minutes, same as V1). */
-export declare const V2_COMPACTION_TIMEOUT_MS = 180000;
+/** Timeout for V2 streaming compaction (5 minutes, same as V1). */
+export declare const V2_COMPACTION_TIMEOUT_MS = 300000;
 /** Token usage reported by the streamed V2 Responses completion. */
 export interface CompactionV2Usage {
     inputTokens: number;

package/dist/types/compaction/compaction.d.ts

@@ -65,7 +65,11 @@ export declare const DEFAULT_RESERVE_TOKENS = 16384;
  */
 export declare const MAX_SUMMARY_TOKENS = 16384;
 export declare const DEFAULT_COMPACTION_SETTINGS: CompactionSettings;
-/** Whether a compaction candidate preserves provider-native transport under the effective settings. */
+/**
+ * Whether a compaction candidate preserves provider-native transport under the
+ * effective settings: an OpenAI Responses compact route (V1 or streamed V2) or
+ * the Anthropic compaction beta.
+ */
 export declare function shouldUseProviderNativeCompaction(model: Model, settings: Pick<CompactionSettings, "remoteEnabled" | "remoteStreamingV2Enabled">): boolean;
 /**
  * Calculate total context tokens from usage.
@@ -290,6 +294,8 @@ export interface CompactionPreparation {
     tokensBefore: number;
     /** Summary from previous compaction, for iterative update */
     previousSummary?: string;
+    /** ISO timestamp of the previous compaction entry, for iterative update */
+    previousSummaryTimestamp?: string;
     /** Preserved opaque compaction payload from the previous compaction, if any. */
     previousPreserveData?: Record<string, unknown>;
     /** File operations extracted from messagesToSummarize */

package/dist/types/compaction/index.d.ts

@@ -1,6 +1,7 @@
 /**
  * Compaction and summarization utilities.
  */
+export * from "./anthropic.js";
 export * from "./branch-summarization.js";
 export * from "./compaction.js";
 export * from "./entries.js";

package/dist/types/compaction/openai.d.ts

@@ -19,14 +19,14 @@ import { Tokenizer } from "../tokenizer.js";
 export * from "./compaction-v2-streaming.js";
 export declare const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
 /**
- * Hard ceiling on remote compaction HTTP requests. Unlike every provider
- * stream (guarded by first-event/idle watchdogs in pi-ai), these are raw
- * fetches awaiting one non-streamed JSON body — a connection silently dropped
- * by a middlebox would otherwise hang the whole compaction pipeline forever
- * (frozen "Auto context-full maintenance…" spinner, manual /compact queueing
- * behind it). On timeout the caller falls back to local summarization.
+ * Hard ceiling on remote compaction HTTP requests (5 minutes). Unlike every
+ * provider stream (guarded by first-event/idle watchdogs in pi-ai), these are
+ * raw fetches awaiting one non-streamed JSON body — a connection silently
+ * dropped by a middlebox would otherwise hang the whole compaction pipeline
+ * forever (frozen "Auto context-full maintenance…" spinner, manual /compact
+ * queueing behind it). On timeout the caller falls back to local summarization.
  */
-export declare const REMOTE_COMPACTION_TIMEOUT_MS = 180000;
+export declare const REMOTE_COMPACTION_TIMEOUT_MS = 300000;
 export declare const CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE: string;
 export interface TrimRemoteCompactionInputResult {
     input: Array<Record<string, unknown>>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.1.16",
+	"version": "18.1.18",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -35,16 +35,16 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.1.16",
-		"@oh-my-pi/pi-catalog": "18.1.16",
-		"@oh-my-pi/pi-natives": "18.1.16",
-		"@oh-my-pi/pi-utils": "18.1.16",
-		"@oh-my-pi/pi-wire": "18.1.16",
-		"@oh-my-pi/snapcompact": "18.1.16",
+		"@oh-my-pi/pi-ai": "18.1.18",
+		"@oh-my-pi/pi-catalog": "18.1.18",
+		"@oh-my-pi/pi-natives": "18.1.18",
+		"@oh-my-pi/pi-utils": "18.1.18",
+		"@oh-my-pi/pi-wire": "18.1.18",
+		"@oh-my-pi/snapcompact": "18.1.18",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.1.16",
+		"@oh-my-pi/omptype": "18.1.18",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "^1.3.14"

package/src/agent-loop.ts

@@ -2269,6 +2269,68 @@ function resolveToolForCall(
 	);
 }
 
+/** Shortest suggestable segment; below this the match is noise (`id`, `to`). */
+const MIN_TOOL_NAME_SUGGESTION_SEGMENT = 3;
+/** Cap on names listed for an ambiguous miss, so the error stays readable. */
+const MAX_TOOL_NAME_SUGGESTIONS = 3;
+
+/**
+ * Advertised tool names sharing a trailing `_`-delimited segment with `name`.
+ *
+ * A model that mis-transcribes a long opaque tool name reliably keeps the
+ * trailing verb — that segment is the only part carrying meaning, while any
+ * leading id segments are high-entropy and mnemonic-free. Matching on it turns
+ * an otherwise dead `not found` into a self-correcting one.
+ *
+ * Both the last `__` and last `_` boundary are tried, so a name that lost only
+ * its separator (`…__resolve_library_id`) and one that lost a whole id segment
+ * (`…__read`) both recover. Purely advisory: this only builds an error string
+ * and never selects a tool, so dispatch semantics are unchanged.
+ */
+function suggestToolNames(
+	name: string,
+	tools: ReadonlyArray<Pick<AgentTool, "name" | "customWireName">> | undefined,
+): string[] {
+	if (!tools || tools.length === 0) return [];
+	const segments: string[] = [];
+	for (const boundary of ["__", "_"]) {
+		const idx = name.lastIndexOf(boundary);
+		if (idx < 0) continue;
+		const segment = name.slice(idx + boundary.length);
+		if (segment.length >= MIN_TOOL_NAME_SUGGESTION_SEGMENT && !segments.includes(segment)) segments.push(segment);
+	}
+	if (segments.length === 0) return [];
+	// Longest tail first. A distinctive `__` tail (`resolve_library_get`) is a
+	// far stronger signal than the generic `_` tail it contains (`get`), and the
+	// caller truncates the list — so the strongest match has to sort ahead of
+	// however many tools happen to share the weak one.
+	segments.sort((a, b) => b.length - a.length);
+	const matches: string[] = [];
+	for (const segment of segments) {
+		for (const tool of tools) {
+			for (const candidate of [tool.name, tool.customWireName]) {
+				if (candidate === undefined || candidate === name || matches.includes(candidate)) continue;
+				if (candidate === segment || candidate.endsWith(`_${segment}`)) matches.push(candidate);
+			}
+		}
+	}
+	return matches;
+}
+
+/**
+ * `Tool <name> not found`, plus a suggestion when the advertised set contains a
+ * plausible intended target. Exact wording is not a contract; the model reads it.
+ */
+function formatToolNotFoundMessage(
+	name: string,
+	tools: ReadonlyArray<Pick<AgentTool, "name" | "customWireName">> | undefined,
+): string {
+	const suggestions = suggestToolNames(name, tools);
+	if (suggestions.length === 0) return `Tool ${name} not found`;
+	if (suggestions.length === 1) return `Tool ${name} not found. Did you mean ${suggestions[0]}?`;
+	return `Tool ${name} not found. Closest available: ${suggestions.slice(0, MAX_TOOL_NAME_SUGGESTIONS).join(", ")}`;
+}
+
 /**
  * Pre-dispatch phase for every pending tool call on `assistantMessage`, run in
  * call order: intent extraction, argument validation, and the `beforeToolCall`
@@ -2312,7 +2374,7 @@ async function prepareToolCallDispatch(
 		}
 		const validate = (args: Record<string, unknown>): Record<string, unknown> | undefined => {
 			try {
-				if (!tool) throw new Error(`Tool ${toolCall.name} not found`);
+				if (!tool) throw new Error(formatToolNotFoundMessage(toolCall.name, context.tools));
 				return validateToolArguments(tool, { ...toolCall, arguments: args });
 			} catch (validationError) {
 				if (tool?.lenientArgValidation) {
@@ -2637,7 +2699,7 @@ async function executeToolCalls(
 
 		await runInActiveSpan(toolSpan, async () => {
 			try {
-				if (!tool) throw new Error(`Tool ${toolCall.name} not found`);
+				if (!tool) throw new Error(formatToolNotFoundMessage(toolCall.name, tools));
 				if (record.signal.aborted) {
 					result = createToolSignalAbortedResult(record.signal);
 					isError = true;

package/src/compaction/anthropic.ts

@@ -0,0 +1,310 @@
+/**
+ * Anthropic server-side compaction (`compact-2026-01-12` beta).
+ *
+ * The compaction request is the live turn's own request shape — same system
+ * prompt, tools, and message history — plus the `compact_20260112` edit with
+ * `pause_after_compaction`. The API summarizes the prompt from the already
+ * cached prefix and stops; the summary arrives as a `compaction` block that
+ * the provider surfaces as an `anthropicCompaction` payload. The summary is
+ * plain text, so it doubles as the compaction entry's readable summary for
+ * every other provider, while the Anthropic provider replays it as a native
+ * block (the API drops everything that precedes it). The retained tail after
+ * the cut point is replayed from session entries exactly like a local summary.
+ */
+
+import type {
+	AnthropicCompactionPayload,
+	ApiKey,
+	AssistantMessage,
+	Effort,
+	Message,
+	Model,
+	SimpleStreamOptions,
+	Tool,
+	Usage,
+} from "@oh-my-pi/pi-ai";
+import * as AIError from "@oh-my-pi/pi-ai/error";
+import { supportsAnthropicCompaction } from "@oh-my-pi/pi-ai/providers/anthropic";
+import { isRecord, prompt } from "@oh-my-pi/pi-utils";
+import { type InstrumentedChatSpanOptions, instrumentedCompleteSimple } from "../telemetry";
+import anthropicCompactionInstructionsPrompt from "./prompts/anthropic-compaction-instructions.md" with { type: "text" };
+
+export const ANTHROPIC_COMPACTION_PRESERVE_KEY = "anthropicCompaction";
+
+/** The API rejects a `compact_20260112` trigger below this many input tokens. */
+export const ANTHROPIC_COMPACTION_MIN_TRIGGER_TOKENS = 50_000;
+
+/**
+ * Smallest context the native lane accepts. The trigger sits at the API
+ * floor, so a prompt that lands below it is answered instead of compacted;
+ * the margin over the floor absorbs the difference between the last reported
+ * context size and the compaction request's own input.
+ */
+export const ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS = 55_000;
+
+/** Summary persisted under {@link ANTHROPIC_COMPACTION_PRESERVE_KEY}. */
+export interface AnthropicCompactionPreserveData {
+	provider: string;
+	content: string;
+	/** Opaque provider state the API attached to the block; replayed verbatim. */
+	encryptedContent?: string;
+	/** Harness file metadata (`<files>` section) replayed after the native block. */
+	filesText?: string;
+	/** Model that wrote the summary. */
+	model?: string;
+	/** Prompt tokens the compaction request processed, for display. */
+	usedTokens?: number;
+}
+
+function isAnthropicMessagesModel(model: Model): model is Model<"anthropic-messages"> {
+	return model.api === "anthropic-messages";
+}
+
+/**
+ * Whether a model compacts through the Anthropic compaction beta. Model
+ * eligibility is catalog policy (`compat.supportsServerCompaction`, the
+ * lineage the beta documents); endpoint eligibility is resolved the way the
+ * provider routes requests, so a Foundry or `ANTHROPIC_BASE_URL` reroute of a
+ * first-party model is excluded unless the route opted in with
+ * `remoteCompaction.enabled`.
+ */
+export function shouldUseAnthropicNativeCompaction(model: Model): model is Model<"anthropic-messages"> {
+	return isAnthropicMessagesModel(model) && supportsAnthropicCompaction(model);
+}
+
+export function getPreservedAnthropicCompactionData(
+	preserveData: Record<string, unknown> | undefined,
+): AnthropicCompactionPreserveData | undefined {
+	const candidate = preserveData?.[ANTHROPIC_COMPACTION_PRESERVE_KEY];
+	if (!isRecord(candidate)) return undefined;
+	if (typeof candidate.provider !== "string" || candidate.provider.length === 0) return undefined;
+	if (typeof candidate.content !== "string" || candidate.content.length === 0) return undefined;
+	return {
+		provider: candidate.provider,
+		content: candidate.content,
+		...(typeof candidate.encryptedContent === "string" && candidate.encryptedContent.length > 0
+			? { encryptedContent: candidate.encryptedContent }
+			: {}),
+		...(typeof candidate.filesText === "string" && candidate.filesText.length > 0
+			? { filesText: candidate.filesText }
+			: {}),
+		...(typeof candidate.model === "string" ? { model: candidate.model } : {}),
+		...(typeof candidate.usedTokens === "number" ? { usedTokens: candidate.usedTokens } : {}),
+	};
+}
+
+/** Set or strip the Anthropic compaction slot; a new compaction never inherits a stale summary. */
+export function withAnthropicCompactionPreserveData(
+	preserveData: Record<string, unknown> | undefined,
+	compaction: AnthropicCompactionPreserveData | undefined,
+): Record<string, unknown> | undefined {
+	if (compaction) {
+		return { ...preserveData, [ANTHROPIC_COMPACTION_PRESERVE_KEY]: compaction };
+	}
+	if (!preserveData || !(ANTHROPIC_COMPACTION_PRESERVE_KEY in preserveData)) {
+		return preserveData;
+	}
+	const { [ANTHROPIC_COMPACTION_PRESERVE_KEY]: _removed, ...rest } = preserveData;
+	return Object.keys(rest).length > 0 ? rest : undefined;
+}
+
+/** Replay payload for a compaction summary the active model produced natively. */
+export function getAnthropicCompactionPayload(
+	preserveData: Record<string, unknown> | undefined,
+): AnthropicCompactionPayload | undefined {
+	const preserved = getPreservedAnthropicCompactionData(preserveData);
+	if (!preserved) return undefined;
+	return {
+		type: "anthropicCompaction",
+		provider: preserved.provider,
+		content: preserved.content,
+		...(preserved.encryptedContent ? { encryptedContent: preserved.encryptedContent } : {}),
+		...(preserved.filesText ? { filesText: preserved.filesText } : {}),
+	};
+}
+
+/**
+ * The retained tail as the model will see it, for the summarization
+ * instructions: how many of the conversation's final wire messages stay in
+ * context verbatim, and the role of the first. The compaction request carries
+ * the whole conversation so the prompt cache the live turn wrote is read, but
+ * the summary must cover only the history before that tail — the local
+ * summarizer never sees the tail, and the rebuilt context replays it after the
+ * summary. Counting mirrors the provider's message conversion (consecutive
+ * tool results collapse into one user message; developer messages are user
+ * messages). Structured for the prompt template, which renders the
+ * singular/plural wording; the description quotes no content: quoting the
+ * tail would hand the summarizer the very facts it must leave to the tail.
+ */
+export interface RetainedTailScope {
+	count: number;
+	role: "assistant" | "user";
+}
+
+export function describeRetainedTail(messages: readonly Message[]): RetainedTailScope | undefined {
+	const first = messages[0];
+	if (!first) return undefined;
+	let count = 0;
+	let previousWasToolResult = false;
+	for (const message of messages) {
+		const isToolResult = message.role === "toolResult";
+		if (!(isToolResult && previousWasToolResult)) count += 1;
+		previousWasToolResult = isToolResult;
+	}
+	// Mirror the provider's trailing-assistant prefill: a tail ending in a
+	// live assistant turn gains a synthetic trailing user message on the
+	// wire, which stays verbatim too. Only blocks the converter emits count —
+	// blank text never serializes, and images, redacted thinking, and fallback
+	// markers need target context this scope lacks, so a turn of only those
+	// emits nothing and draws no pad. Without the pad in
+	// the scope, the summary could duplicate the tail head.
+	const last = messages[messages.length - 1];
+	if (last?.role === "assistant" && last.content.some(emitsWireBlock)) {
+		count += 1;
+	}
+	return { count, role: first.role === "assistant" ? "assistant" : "user" };
+}
+
+/**
+ * Whether an assistant content block reaches the wire. Server-tool blocks
+ * serialize unconditionally; blank text never does. Redacted thinking and
+ * fallback markers replay only for specific deployments, which the scope
+ * cannot see, so a turn of only those conservatively draws no pad.
+ */
+function emitsWireBlock(block: AssistantMessage["content"][number]): boolean {
+	switch (block.type) {
+		case "text":
+			return block.text.trim().length > 0;
+		case "toolCall":
+		case "anthropicServerTool":
+			return true;
+		case "thinking":
+			return block.thinking.trim().length > 0 || (block.thinkingSignature ?? "").trim().length > 0;
+		default:
+			return false;
+	}
+}
+
+/**
+ * Summarization prompt sent as the edit's `instructions`, which replace the
+ * API default entirely. The template lays out the retained-tail boundary
+ * first, so the summary covers only the history the rebuilt context drops,
+ * then the caller's extra context, the same structure prompt as the local
+ * summarizer, the caller's focus, and the tool-abstention clause the API
+ * recommends when tools are defined (a summarization pass that calls a tool
+ * yields no summary).
+ */
+export function buildAnthropicCompactionInstructions(
+	basePrompt: string,
+	customInstructions: string | undefined,
+	extraContext: string | undefined,
+	retainedTail: RetainedTailScope | undefined,
+): string {
+	return prompt.render(anthropicCompactionInstructionsPrompt, {
+		basePrompt,
+		customInstructions,
+		extraContext,
+		retainedTail,
+	});
+}
+
+export interface AnthropicNativeCompactionRequest {
+	systemPrompt: string[];
+	messages: Message[];
+	tools?: Tool[];
+	instructions: string;
+	maxTokens: number;
+	reasoning?: Effort;
+}
+
+export interface AnthropicNativeCompactionResponse {
+	content: string;
+	encryptedContent?: string;
+	usage: Usage;
+	model: string;
+}
+
+export interface AnthropicNativeCompactionOptions
+	extends
+		Pick<
+			SimpleStreamOptions,
+			| "initiatorOverride"
+			| "metadata"
+			| "fetch"
+			| "sessionId"
+			| "promptCacheKey"
+			| "providerSessionState"
+			| "maxInFlightRequests"
+		>,
+		Pick<InstrumentedChatSpanOptions, "completeImpl" | "telemetry" | "retry"> {}
+
+/**
+ * Run one compaction request and return the summary the API wrote, with the
+ * opaque `encrypted_content` the API attached for the replay. `completeSimple`
+ * resolves terminal failures as messages, so their classification is restored
+ * here: an aborted response is an `AbortError` (a cancellation, never a native
+ * failure) and an error response keeps its HTTP status, so auth and timeout
+ * handling downstream classify it the same way as the OpenAI lanes. A response
+ * without a summary is a native failure — the API answers the prompt instead
+ * when its input never reached the trigger, and returns an empty block when
+ * the model called a tool during summarization.
+ */
+export async function requestAnthropicNativeCompaction(
+	model: Model<"anthropic-messages">,
+	apiKey: ApiKey,
+	request: AnthropicNativeCompactionRequest,
+	signal: AbortSignal | undefined,
+	options: AnthropicNativeCompactionOptions,
+): Promise<AnthropicNativeCompactionResponse> {
+	const response = await instrumentedCompleteSimple(
+		model,
+		{ systemPrompt: request.systemPrompt, messages: request.messages, tools: request.tools },
+		{
+			apiKey,
+			signal,
+			maxTokens: request.maxTokens,
+			reasoning: request.reasoning,
+			initiatorOverride: options.initiatorOverride,
+			metadata: options.metadata,
+			fetch: options.fetch,
+			sessionId: options.sessionId,
+			promptCacheKey: options.promptCacheKey,
+			providerSessionState: options.providerSessionState,
+			maxInFlightRequests: options.maxInFlightRequests,
+			anthropicCompaction: {
+				triggerInputTokens: ANTHROPIC_COMPACTION_MIN_TRIGGER_TOKENS,
+				pauseAfterCompaction: true,
+				instructions: request.instructions,
+			},
+		},
+		{
+			telemetry: options.telemetry,
+			oneshotKind: "compaction_native",
+			completeImpl: options.completeImpl,
+			retry: options.retry,
+		},
+	);
+	if (response.stopReason === "aborted") {
+		throw new AIError.AbortError("Anthropic compaction aborted", { cause: signal?.reason });
+	}
+	if (response.stopReason === "error") {
+		const message = `Anthropic compaction failed: ${response.errorMessage ?? "unknown error"}`;
+		throw response.errorStatus === undefined
+			? new Error(message)
+			: new AIError.ProviderHttpError(message, response.errorStatus);
+	}
+	const payload = response.providerPayload;
+	if (payload?.type !== "anthropicCompaction" || payload.content.length === 0) {
+		throw new Error(
+			response.stopDetails?.type === "compaction"
+				? "Anthropic compaction returned no summary"
+				: "Anthropic compaction response carried no compaction block",
+		);
+	}
+	return {
+		content: payload.content,
+		encryptedContent: payload.encryptedContent,
+		usage: response.usage,
+		model: response.model,
+	};
+}

package/src/compaction/compaction-v2-streaming.ts

@@ -44,8 +44,8 @@ export const V2_RETAINED_MESSAGE_TOKEN_BUDGET = 64_000;
 /** Max retries for V2 streaming compaction on transient stream errors. */
 export const V2_COMPACTION_MAX_RETRIES = 2;
 
-/** Timeout for V2 streaming compaction (3 minutes, same as V1). */
-export const V2_COMPACTION_TIMEOUT_MS = 180_000;
+/** Timeout for V2 streaming compaction (5 minutes, same as V1). */
+export const V2_COMPACTION_TIMEOUT_MS = 300_000;
 
 const DEFAULT_AZURE_API_VERSION = "v1";
 const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";

package/src/compaction/compaction.ts

@@ -42,6 +42,15 @@ import { type AgentTelemetry, instrumentedCompleteSimple } from "../telemetry";
 import { ThinkingLevel } from "../thinking";
 import { Tokenizer } from "../tokenizer";
 import type { AgentMessage } from "../types";
+import {
+	ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS,
+	buildAnthropicCompactionInstructions,
+	describeRetainedTail,
+	getPreservedAnthropicCompactionData,
+	requestAnthropicNativeCompaction,
+	shouldUseAnthropicNativeCompaction,
+	withAnthropicCompactionPreserveData,
+} from "./anthropic";
 import {
 	buildCompactionV2Request,
 	buildCompactionV2RequestFromBody,
@@ -53,7 +62,13 @@ import {
 } from "./compaction-v2-streaming";
 import type { CompactionEntry, SessionEntry } from "./entries";
 import { NativeCompactionError } from "./errors";
-import { type ConvertToLlm, createBranchSummaryMessage, createCustomMessage, defaultConvertToLlm } from "./messages";
+import {
+	type ConvertToLlm,
+	createBranchSummaryMessage,
+	createCompactionSummaryMessage,
+	createCustomMessage,
+	defaultConvertToLlm,
+} from "./messages";
 import {
 	buildOpenAiNativeHistory,
 	getPreservedOpenAiRemoteCompactionData,
@@ -224,7 +239,11 @@ export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
 	v2RetainedMessageBudget: V2_RETAINED_MESSAGE_TOKEN_BUDGET,
 };
 
-/** Whether a compaction candidate preserves provider-native transport under the effective settings. */
+/**
+ * Whether a compaction candidate preserves provider-native transport under the
+ * effective settings: an OpenAI Responses compact route (V1 or streamed V2) or
+ * the Anthropic compaction beta.
+ */
 export function shouldUseProviderNativeCompaction(
 	model: Model,
 	settings: Pick<CompactionSettings, "remoteEnabled" | "remoteStreamingV2Enabled">,
@@ -232,7 +251,8 @@ export function shouldUseProviderNativeCompaction(
 	if (settings.remoteEnabled === false) return false;
 	return (
 		shouldUseOpenAiRemoteCompaction(model) ||
-		(settings.remoteStreamingV2Enabled !== false && shouldUseCompactionV2Streaming(model))
+		(settings.remoteStreamingV2Enabled !== false && shouldUseCompactionV2Streaming(model)) ||
+		shouldUseAnthropicNativeCompaction(model)
 	);
 }
 
@@ -395,22 +415,6 @@ export function resolveThresholdTokens(contextWindow: number, settings: Compacti
 // Cut point detection
 // ============================================================================
 
-function estimateEntriesTokens(
-	entries: SessionEntry[],
-	tokenizer: Tokenizer,
-	startIndex: number,
-	endIndex: number,
-): number {
-	let total = 0;
-	for (let i = startIndex; i < endIndex; i++) {
-		const msg = getMessageFromEntry(entries[i]);
-		if (msg) {
-			total += tokenizer.countMessage(msg);
-		}
-	}
-	return total;
-}
-
 /**
  * Find valid cut points: indices of user, assistant, custom, or bashExecution messages.
  * Never cut at tool results (they must follow their tool call).
@@ -1252,6 +1256,8 @@ export interface CompactionPreparation {
 	tokensBefore: number;
 	/** Summary from previous compaction, for iterative update */
 	previousSummary?: string;
+	/** ISO timestamp of the previous compaction entry, for iterative update */
+	previousSummaryTimestamp?: string;
 	/** Preserved opaque compaction payload from the previous compaction, if any. */
 	previousPreserveData?: Record<string, unknown>;
 	/** File operations extracted from messagesToSummarize */
@@ -1331,16 +1337,10 @@ export function prepareCompaction(
 
 	let prevCompactionIndex = findReadableCompactionIndex(pathEntries, settings, activeModel);
 
-	// Honor the latest `/clear` reset boundary. `/clear` records a
-	// `reset_boundary` marker and reports the model context empty, so compaction
-	// must not resurrect the dropped pre-clear turns into its summary — matching
-	// how buildSessionContext starts the model-context rebuild after the boundary.
-	// A boundary after the last reusable compaction supersedes it: the pre-reset
-	// summary was cleared too, so drop the previous-compaction reuse and start
-	// fresh after the boundary. A boundary at or before that compaction is already
-	// superseded by it, so only scan newer entries.
+	// A reset after the reusable compaction clears its summary too. An older
+	// reset still bounds how far we may recover that compaction's kept messages.
 	let resetBoundaryIndex = -1;
-	for (let i = pathEntries.length - 1; i > prevCompactionIndex; i--) {
+	for (let i = pathEntries.length - 1; i >= 0; i--) {
 		if (pathEntries[i].type === "reset_boundary") {
 			resetBoundaryIndex = i;
 			break;
@@ -1349,14 +1349,43 @@ export function prepareCompaction(
 	if (resetBoundaryIndex > prevCompactionIndex) {
 		prevCompactionIndex = -1;
 	}
-	const boundaryStart = Math.max(prevCompactionIndex, resetBoundaryIndex) + 1;
-	const boundaryEnd = pathEntries.length;
+	const previousCompaction =
+		prevCompactionIndex >= 0 ? (pathEntries[prevCompactionIndex] as CompactionEntry) : undefined;
+	let boundaryStart = Math.max(prevCompactionIndex, resetBoundaryIndex) + 1;
+	if (
+		previousCompaction &&
+		!getCompactionV2PreserveData(previousCompaction.preserveData) &&
+		!getPreservedOpenAiRemoteCompactionData(previousCompaction.preserveData)
+	) {
+		// Local summaries exclude the retained tail, whose original entries precede
+		// the compaction record. Native replay already carries that tail. Only look
+		// backwards: advisor snapshots put all retained messages after the summary
+		// and may carry a keep ID from their previous, differently indexed snapshot.
+		for (let i = resetBoundaryIndex + 1; i < prevCompactionIndex; i++) {
+			if (pathEntries[i].id === previousCompaction.firstKeptEntryId) {
+				boundaryStart = i;
+				break;
+			}
+		}
+	}
+
+	// Keep original IDs beside the converted messages so estimation, cutting,
+	// and all three output regions share one sequence without journal metadata.
+	const compactionEntries: SessionEntry[] = [];
+	const compactionMessages: AgentMessage[] = [];
+	for (let i = boundaryStart; i < pathEntries.length; i++) {
+		const entry = pathEntries[i];
+		const message = getMessageFromEntry(entry);
+		if (!message) continue;
+		compactionEntries.push(entry);
+		compactionMessages.push(message);
+	}
 
 	const lastUsage = getLastAssistantUsage(pathEntries);
 	const tokensBefore = lastUsage ? calculateContextTokens(lastUsage) : 0;
 	let keepRecentTokens = settings.keepRecentTokens;
 	if (lastUsage) {
-		const estimatedTokens = estimateEntriesTokens(pathEntries, tokenizer, boundaryStart, boundaryEnd);
+		const estimatedTokens = tokenizer.countMessages(compactionMessages);
 		const promptTokens = calculatePromptTokens(lastUsage);
 		const ratio = estimatedTokens > 0 ? promptTokens / estimatedTokens : 0;
 		if (Number.isFinite(ratio) && ratio > 1) {
@@ -1364,10 +1393,10 @@ export function prepareCompaction(
 		}
 	}
 
-	const cutPoint = findCutPoint(pathEntries, tokenizer, boundaryStart, boundaryEnd, keepRecentTokens);
+	const cutPoint = findCutPoint(compactionEntries, tokenizer, 0, compactionEntries.length, keepRecentTokens);
 
 	// Get ID of first kept entry
-	const firstKeptEntry = pathEntries[cutPoint.firstKeptEntryIndex];
+	const firstKeptEntry = compactionEntries[cutPoint.firstKeptEntryIndex];
 	if (!firstKeptEntry?.id) {
 		return undefined; // Session needs migration
 	}
@@ -1375,42 +1404,16 @@ export function prepareCompaction(
 
 	const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptEntryIndex;
 
-	// Messages to summarize (will be discarded after summary)
-	const messagesToSummarize: AgentMessage[] = [];
-	for (let i = boundaryStart; i < historyEnd; i++) {
-		const msg = getMessageFromEntry(pathEntries[i]);
-		if (msg) messagesToSummarize.push(msg);
-	}
-
-	// Messages for turn prefix summary (if splitting a turn)
-	const turnPrefixMessages: AgentMessage[] = [];
-	if (cutPoint.isSplitTurn) {
-		for (let i = cutPoint.turnStartIndex; i < cutPoint.firstKeptEntryIndex; i++) {
-			const msg = getMessageFromEntry(pathEntries[i]);
-			if (msg) turnPrefixMessages.push(msg);
-		}
-	}
-
-	// Messages kept after compaction (recent history)
-	const recentMessages: AgentMessage[] = [];
-	for (let i = cutPoint.firstKeptEntryIndex; i < boundaryEnd; i++) {
-		const msg = getMessageFromEntry(pathEntries[i]);
-		if (msg) recentMessages.push(msg);
-	}
+	const messagesToSummarize = compactionMessages.slice(0, historyEnd);
+	const turnPrefixMessages = cutPoint.isSplitTurn
+		? compactionMessages.slice(cutPoint.turnStartIndex, cutPoint.firstKeptEntryIndex)
+		: [];
+	const recentMessages = compactionMessages.slice(cutPoint.firstKeptEntryIndex);
 	// Nothing to summarize means compaction would be a no-op.
 	if (messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) {
 		return undefined;
 	}
 
-	// Get previous summary and preserved data for iterative updates
-	let previousSummary: string | undefined;
-	let previousPreserveData: Record<string, unknown> | undefined;
-	if (prevCompactionIndex >= 0) {
-		const prevCompaction = pathEntries[prevCompactionIndex] as CompactionEntry;
-		previousSummary = prevCompaction.summary;
-		previousPreserveData = prevCompaction.preserveData;
-	}
-
 	// Extract file operations from messages and previous compaction
 	const fileOps = extractFileOperations(messagesToSummarize, pathEntries, prevCompactionIndex);
 
@@ -1428,8 +1431,9 @@ export function prepareCompaction(
 		recentMessages,
 		isSplitTurn: cutPoint.isSplitTurn,
 		tokensBefore,
-		previousSummary,
-		previousPreserveData,
+		previousSummary: previousCompaction?.summary,
+		previousSummaryTimestamp: previousCompaction?.timestamp,
+		previousPreserveData: previousCompaction?.preserveData,
 		fileOps,
 		settings,
 	};
@@ -1585,6 +1589,9 @@ export async function compact(
 		tools: options?.tools,
 		fetch: options?.fetch,
 		completeImpl: options?.completeImpl,
+		// The caller's opt-out must reach every summarization oneshot, otherwise
+		// an outer retry loop multiplies with the inner one (see SummaryOptions).
+		oneshotRetry: options?.oneshotRetry,
 	};
 
 	const previousSnapcompactArchive = snapcompact.getPreservedArchive(previousPreserveData);
@@ -1599,7 +1606,10 @@ export async function compact(
 		? createSnapcompactArchiveMigrationMessage(previousSnapcompactArchiveText)
 		: undefined;
 
-	let preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined);
+	let preserveData = withAnthropicCompactionPreserveData(
+		withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined),
+		undefined,
+	);
 	const remoteMessages: AgentMessage[] = [
 		...(snapcompactArchiveMigrationMessage ? [snapcompactArchiveMigrationMessage] : []),
 		...messagesToSummarize,
@@ -1784,6 +1794,112 @@ export async function compact(
 		}
 	}
 
+	// Anthropic server-side compaction: the live turn's request shape plus the
+	// compact edit, so the API summarizes from its cached prefix. The summary is
+	// real text, persisted both as the entry summary and as the native replay
+	// payload. A context below the API's trigger floor cannot compact remotely
+	// and takes the local summarizer instead — an eligibility boundary, not a
+	// failure.
+	let nativeSummary: string | undefined;
+	let nativeEncryptedContent: string | undefined;
+	let nativeUsedTokens: number | undefined;
+	if (
+		!usedRemoteCompaction &&
+		settings.remoteEnabled !== false &&
+		shouldUseAnthropicNativeCompaction(model) &&
+		tokensBefore >= ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS
+	) {
+		const previousNative = getPreservedAnthropicCompactionData(previousPreserveData);
+		// Lead with the previous summary exactly as the live context renders it:
+		// natively when this provider wrote it, as text otherwise. The request
+		// then shares the live turn's prefix byte-for-byte. A prior snapcompact
+		// archive is already merged into that summary text, so the archive
+		// migration message the OpenAI lanes carry is omitted here.
+		// The rewrite marker must precede every message this request replays —
+		// summarized history and retained tail alike — exactly like the live
+		// context rebuild predates its tail. A previous compaction's commit
+		// timestamp is newer than re-retained or re-summarized turns, so
+		// reusing it would strip their bound thinking only in this request,
+		// diverging from the cached live prefix (and possibly dropping below
+		// the trigger). Manually built preparations with no input at all fall
+		// back to the current time.
+		const firstReplayed = messagesToSummarize[0] ?? turnPrefixMessages[0] ?? recentMessages[0];
+		const previousSummaryAt =
+			firstReplayed !== undefined ? new Date(firstReplayed.timestamp - 1).toISOString() : new Date().toISOString();
+		const previousSummaryMessage = previousSummaryForCompaction
+			? createCompactionSummaryMessage(previousSummaryForCompaction, tokensBefore, previousSummaryAt, {
+					providerPayload:
+						previousNative?.provider === model.provider
+							? {
+									type: "anthropicCompaction",
+									provider: previousNative.provider,
+									content: previousNative.content,
+									...(previousNative.encryptedContent
+										? { encryptedContent: previousNative.encryptedContent }
+										: {}),
+									...(previousNative.filesText ? { filesText: previousNative.filesText } : {}),
+								}
+							: undefined,
+				})
+			: undefined;
+		const convertToLlm = summaryOptions.convertToLlm ?? defaultConvertToLlm;
+		const retainedTail = convertToLlm(recentMessages);
+		const messages = [
+			...convertToLlm([
+				...(previousSummaryMessage ? [previousSummaryMessage] : []),
+				...messagesToSummarize,
+				...turnPrefixMessages,
+			]),
+			...retainedTail,
+		];
+		try {
+			const remote = await requestAnthropicNativeCompaction(
+				model,
+				apiKey,
+				{
+					systemPrompt: summaryOptions.remoteSystemPrompt ?? [SUMMARIZATION_SYSTEM_PROMPT],
+					messages,
+					tools: summaryOptions.tools,
+					instructions: buildAnthropicCompactionInstructions(
+						summaryOptions.promptOverride ?? SUMMARIZATION_PROMPT,
+						customInstructions,
+						formatAdditionalContext(summaryOptions.extraContext).trim() || undefined,
+						describeRetainedTail(retainedTail),
+					),
+					maxTokens: Math.min(Math.floor(0.8 * reserveTokens), MAX_SUMMARY_TOKENS),
+					reasoning: resolveCompactionEffort(model, summaryOptions.thinkingLevel),
+				},
+				signal,
+				{
+					initiatorOverride: summaryOptions.initiatorOverride,
+					metadata: summaryOptions.metadata,
+					fetch: summaryOptions.fetch,
+					sessionId: summaryOptions.sessionId,
+					promptCacheKey: summaryOptions.promptCacheKey,
+					providerSessionState: summaryOptions.providerSessionState,
+					completeImpl: summaryOptions.completeImpl,
+					telemetry: summaryOptions.telemetry,
+					retry: summaryOneshotRetry(summaryOptions),
+				},
+			);
+			nativeSummary = remote.content;
+			nativeEncryptedContent = remote.encryptedContent;
+			nativeUsedTokens = calculatePromptTokens(remote.usage);
+			usedRemoteCompaction = true;
+		} catch (err) {
+			// A user/session abort is a cancellation, not a remote failure —
+			// swallowing it here would downgrade Esc into "fall back to local
+			// summarization" and keep compaction running on an aborted signal.
+			if (signal?.aborted) throw err;
+			nativeCompactionError = selectNativeCompactionError(nativeCompactionError, err);
+			logger.warn("Anthropic server-side compaction failed", {
+				error: err instanceof Error ? err.message : String(err),
+				model: model.id,
+				provider: model.provider,
+			});
+		}
+	}
+
 	if (!usedRemoteCompaction && nativeCompactionError !== undefined && !summaryOptions.remoteEndpoint) {
 		throw new NativeCompactionError(nativeCompactionError);
 	}
@@ -1791,7 +1907,11 @@ export async function compact(
 	// Generate summaries (can be parallel if both needed) and merge into one
 	let summary: string;
 
-	if (usedRemoteCompaction) {
+	if (nativeSummary !== undefined) {
+		// The API wrote a real summary; it is the entry text. The replayed
+		// block below stays verbatim so it matches the opaque state.
+		summary = nativeSummary;
+	} else if (usedRemoteCompaction) {
 		// Remote compaction (V2 or V1) already compacted remotely; the durable
 		// history lives in the provider replay payload (preserveData). Skip local
 		// summarization so a successful remote compaction never pays for a second,
@@ -1850,6 +1970,22 @@ export async function compact(
 	// Compute file lists and append to summary
 	const { readFiles, modifiedFiles } = computeFileLists(fileOps);
 	summary = upsertFileOperations(summary, readFiles, modifiedFiles, fileOps.read);
+	if (nativeSummary !== undefined) {
+		// The replayed block stays byte-identical to the API's summary so it
+		// matches `encryptedContent`. The harness file lists above travel
+		// separately: the converter replaces the summary message with the
+		// block and skips its text, so they would otherwise be invisible to
+		// this provider. Every other provider keeps reading the entry text.
+		const filesText = upsertFileOperations("", readFiles, modifiedFiles, fileOps.read) || undefined;
+		preserveData = withAnthropicCompactionPreserveData(preserveData, {
+			provider: model.provider,
+			content: nativeSummary,
+			...(nativeEncryptedContent ? { encryptedContent: nativeEncryptedContent } : {}),
+			...(filesText ? { filesText } : {}),
+			model: model.id,
+			usedTokens: nativeUsedTokens,
+		});
+	}
 
 	if (!firstKeptEntryId) {
 		throw new Error("First kept entry has no ID - session may need migration");

package/src/compaction/index.ts

@@ -2,6 +2,7 @@
  * Compaction and summarization utilities.
  */
 
+export * from "./anthropic";
 export * from "./branch-summarization";
 export * from "./compaction";
 export * from "./entries";

package/src/compaction/openai.ts

@@ -66,14 +66,14 @@ export * from "./compaction-v2-streaming";
 export const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
 
 /**
- * Hard ceiling on remote compaction HTTP requests. Unlike every provider
- * stream (guarded by first-event/idle watchdogs in pi-ai), these are raw
- * fetches awaiting one non-streamed JSON body — a connection silently dropped
- * by a middlebox would otherwise hang the whole compaction pipeline forever
- * (frozen "Auto context-full maintenance…" spinner, manual /compact queueing
- * behind it). On timeout the caller falls back to local summarization.
+ * Hard ceiling on remote compaction HTTP requests (5 minutes). Unlike every
+ * provider stream (guarded by first-event/idle watchdogs in pi-ai), these are
+ * raw fetches awaiting one non-streamed JSON body — a connection silently
+ * dropped by a middlebox would otherwise hang the whole compaction pipeline
+ * forever (frozen "Auto context-full maintenance…" spinner, manual /compact
+ * queueing behind it). On timeout the caller falls back to local summarization.
  */
-export const REMOTE_COMPACTION_TIMEOUT_MS = 180_000;
+export const REMOTE_COMPACTION_TIMEOUT_MS = 300_000;
 
 const DEFAULT_AZURE_API_VERSION = "v1";
 

package/src/compaction/prompts/anthropic-compaction-instructions.md

@@ -0,0 +1,17 @@
+{{#if retainedTail}}
+SCOPE: The conversation's final {{#when retainedTail.count "==" 1}}{{retainedTail.role}} message stays{{else}}{{retainedTail.count}} messages, starting with a {{retainedTail.role}} message, stay{{/when}} in context verbatim after your summary. Summarize ONLY the history before those messages. You MUST NOT restate anything from those final messages — the reader sees them right after the summary — and you MUST treat them as the most recent state when describing progress and next steps.
+{{else}}
+SCOPE: The conversation above is the transcript to summarize. The API replaces everything before your summary with it, so nothing you leave out survives into the next context window.
+{{/if}}
+
+{{#if extraContext}}
+{{extraContext}}
+
+{{/if}}
+{{basePrompt}}
+{{#if customInstructions}}
+
+Additional focus: {{customInstructions}}
+{{/if}}
+
+You MUST NOT call any tools while writing the summary; respond with the summary text only.

package/src/proxy.ts

@@ -20,7 +20,6 @@ import {
 	type StreamingPartialJsonCarrier,
 	setStreamingPartialJson,
 } from "@oh-my-pi/pi-ai/utils/block-symbols";
-import { calculateCost } from "@oh-my-pi/pi-catalog/models";
 import { parseStreamingJson, readSseJson } from "@oh-my-pi/pi-utils";
 
 // Event stream adapter for proxy SSE events
@@ -171,7 +170,7 @@ export function streamProxy(model: Model, context: Context, options: ProxyStream
 				response.body as ReadableStream<Uint8Array>,
 				options.signal,
 			)) {
-				const parsedEvent = processProxyEvent(model, event, partial, partialJsonByIndex);
+				const parsedEvent = processProxyEvent(event, partial, partialJsonByIndex);
 				if (parsedEvent) {
 					if (parsedEvent.type === "done" || parsedEvent.type === "error") {
 						sawTerminalEvent = true;
@@ -233,7 +232,6 @@ function scrubPartialJson(partial: AssistantMessage): void {
  * reads as still-streaming.
  */
 function processProxyEvent(
-	model: Model,
 	proxyEvent: ProxyAssistantMessageEvent,
 	partial: AssistantMessage,
 	partialJsonByIndex: Map<number, string>,
@@ -375,7 +373,6 @@ function processProxyEvent(
 			partial.stopReason = proxyEvent.reason;
 			partial.usage = proxyEvent.usage;
 			if (proxyEvent.content !== undefined) partial.content = proxyEvent.content;
-			calculateCost(model, partial.usage);
 			scrubPartialJson(partial);
 			return { type: "done", reason: proxyEvent.reason, message: partial };
 
@@ -384,7 +381,6 @@ function processProxyEvent(
 			partial.errorMessage = proxyEvent.errorMessage;
 			partial.usage = proxyEvent.usage;
 			if (proxyEvent.content !== undefined) partial.content = proxyEvent.content;
-			calculateCost(model, partial.usage);
 			scrubPartialJson(partial);
 			return { type: "error", reason: proxyEvent.reason, error: partial };
 	}

package/src/tokenizer.ts

@@ -219,14 +219,22 @@ export class Tokenizer {
 		}
 
 		switch (message.role) {
-			case "user": {
-				const content: string | Array<{ type: string; text?: string }> = message.content;
+			case "user":
+			case "developer": {
+				// Both roles carry `string | (TextContent | ImageContent)[]` and both are
+				// sent to the provider -- convertMessageToLlm handles developer alongside
+				// user -- so they are counted alike. Without the developer case the switch
+				// fell through to `default: return 0`, and the old annotation narrowed the
+				// blocks to text-only, hiding the image charge the toolResult arm applies.
+				const content = message.content;
 				if (typeof content === "string") {
 					fragments.push(content);
 				} else if (Array.isArray(content)) {
 					for (const block of content) {
 						if (block.type === "text" && block.text) {
 							fragments.push(block.text);
+						} else if (block.type === "image") {
+							extra += IMAGE_TOKEN_ESTIMATE;
 						}
 					}
 				}