@linxiraos/pi-agent-core 1.1.20 → 1.1.23

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

@@ -9,13 +9,13 @@
 
 import type { Api, CodexCompactionContext, FetchImpl, Model, ProviderSessionState } from "@linxiraos/pi-ai";
 import * as AIError from "@linxiraos/pi-ai/error";
+import { createOpenAICodexCompactionRequestContext } from "@linxiraos/pi-ai/providers/openai-codex-compaction";
 import { applyCodexResponsesLiteShape } from "@linxiraos/pi-ai/providers/openai-codex/request-transformer";
 import {
-	createOpenAICodexCompactionRequestContext,
 	createOpenAICodexCompatibilityMetadata,
+	openCodexCompactionEventStream,
 	type OpenAICodexCompactionBody,
 	type OpenAICodexCompatibilityMetadata,
-	openCodexCompactionEventStream,
 } from "@linxiraos/pi-ai/providers/openai-codex-responses";
 import {
 	getOpenAIPromptCacheKey,
@@ -597,6 +597,14 @@ function handleCompactionV2Event(
 	if (type === "response.failed" || type === "response.incomplete") {
 		throw new Error(formatCompactionV2Failure(event, type));
 	}
+
+	// A standalone `error` event terminates the stream. Keep its status so a
+	// deterministic 4xx (e.g. context_too_large) is not retried as a dropped stream.
+	if (type === "error") {
+		const message = formatCompactionV2Failure(event, type);
+		const status = numberField(event, "status");
+		throw status === undefined ? new Error(message) : new AIError.ProviderHttpError(message, status);
+	}
 }
 
 function parseCompactionV2Usage(event: Record<string, unknown>): CompactionV2Usage | undefined {
@@ -629,8 +637,9 @@ function formatCompactionV2Failure(event: Record<string, unknown>, type: string)
 		: response && isRecord(response.error)
 			? response.error
 			: undefined;
-	const message = error ? stringField(error, "message") : undefined;
-	const code = error ? (stringField(error, "code") ?? stringField(error, "type")) : undefined;
+	// Responses `error` events carry code/message at the top level.
+	const message = stringField(error ?? event, "message");
+	const code = error ? (stringField(error, "code") ?? stringField(error, "type")) : stringField(event, "code");
 	return `V2 compaction stream ${type}${code ? ` (${code})` : ""}${message ? `: ${message}` : ""}`;
 }
 

package/src/compaction/compaction.ts

@@ -25,10 +25,10 @@ import {
 } from "@linxiraos/pi-ai";
 import type { Dialect } from "@linxiraos/pi-ai/dialect";
 import * as AIError from "@linxiraos/pi-ai/error";
+import { createOpenAICodexCompactionRequestContext } from "@linxiraos/pi-ai/providers/openai-codex-compaction";
 import type { InputItem as CodexInputItem } from "@linxiraos/pi-ai/providers/openai-codex/request-transformer";
 import {
 	buildTransformedCodexRequestBody,
-	createOpenAICodexCompactionRequestContext,
 	type OpenAICodexCompactionBody,
 } from "@linxiraos/pi-ai/providers/openai-codex-responses";
 import { convertTools } from "@linxiraos/pi-ai/providers/openai-responses";
@@ -43,9 +43,8 @@ import { ThinkingLevel } from "../thinking";
 import { Tokenizer } from "../tokenizer";
 import type { AgentMessage } from "../types";
 import {
-	ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS,
 	buildAnthropicCompactionInstructions,
-	describeRetainedTail,
+	findAnthropicCompactionCut,
 	getPreservedAnthropicCompactionData,
 	requestAnthropicNativeCompaction,
 	shouldUseAnthropicNativeCompaction,
@@ -70,6 +69,7 @@ import {
 	defaultConvertToLlm,
 } from "./messages";
 import {
+	assertRemoteCompactionInputFits,
 	buildOpenAiNativeHistory,
 	getPreservedOpenAiRemoteCompactionData,
 	isOpenAiRemoteCompactionApi,
@@ -679,7 +679,7 @@ export interface SummaryOptions {
 	/**
 	 * Optional telemetry handle. When provided, every LLM call emitted during
 	 * compaction is wrapped in an OTEL chat span tagged with
-	 * `pi.gen_ai.oneshot.kind` (`compaction_summary`, `compaction_short_summary`,
+	 * `omp.gen_ai.oneshot.kind` (`compaction_summary`, `compaction_short_summary`,
 	 * or `compaction_turn_prefix`). `undefined` keeps the call paths zero-cost.
 	 */
 	telemetry?: AgentTelemetry;
@@ -1042,7 +1042,7 @@ export interface HandoffOptions {
 	metadata?: Record<string, unknown>;
 	/**
 	 * Optional telemetry handle. When provided, the handoff LLM call is
-	 * wrapped in an OTEL chat span tagged with `pi.gen_ai.oneshot.kind = "handoff"`.
+	 * wrapped in an OTEL chat span tagged with `omp.gen_ai.oneshot.kind = "handoff"`.
 	 */
 	telemetry?: AgentTelemetry;
 	/**
@@ -1252,6 +1252,8 @@ export interface CompactionPreparation {
 	turnPrefixMessages: AgentMessage[];
 	/** Messages kept in full after compaction (recent history) */
 	recentMessages: AgentMessage[];
+	/** Entry IDs parallel to recentMessages, for an Anthropic-safe keep-tail boundary. */
+	recentEntryIds?: string[];
 	/** Whether this is a split turn (cut point in middle of turn) */
 	isSplitTurn: boolean;
 	tokensBefore: number;
@@ -1380,16 +1382,22 @@ export function prepareCompaction(
 			}
 		}
 	} else if (previousCompaction) {
-		// 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.
+		// Local and Anthropic summaries exclude the retained tail, whose
+		// original entries precede the compaction record.
 		for (let i = resetBoundaryIndex + 1; i < prevCompactionIndex; i++) {
 			if (pathEntries[i].id === previousCompaction.firstKeptEntryId) {
 				boundaryStart = i;
 				break;
 			}
 		}
+		if (previousCompaction.firstKeptEntryId === "" && previousCompaction.providerReplayThroughEntryId) {
+			// An empty snapshot tail can still have turns appended during
+			// background compaction; those start after the summarized snapshot.
+			const snapshotIdx = pathEntries.findIndex(
+				entry => entry.id === previousCompaction.providerReplayThroughEntryId,
+			);
+			if (snapshotIdx >= 0 && snapshotIdx < prevCompactionIndex) boundaryStart = snapshotIdx + 1;
+		}
 	}
 
 	// Keep original IDs beside the converted messages so estimation, cutting,
@@ -1437,6 +1445,11 @@ export function prepareCompaction(
 		return undefined;
 	}
 
+	const recentEntryIds: string[] = [];
+	for (let i = cutPoint.firstKeptEntryIndex; i < compactionEntries.length; i++) {
+		recentEntryIds.push(compactionEntries[i].id);
+	}
+
 	// Extract file operations from messages and previous compaction
 	const fileOps = extractFileOperations(messagesToSummarize, pathEntries, prevCompactionIndex);
 
@@ -1452,6 +1465,7 @@ export function prepareCompaction(
 		messagesToSummarize,
 		turnPrefixMessages,
 		recentMessages,
+		recentEntryIds,
 		isSplitTurn: cutPoint.isSplitTurn,
 		tokensBefore,
 		previousSummary: previousCompaction?.summary,
@@ -1579,6 +1593,7 @@ export async function compact(
 		messagesToSummarize,
 		turnPrefixMessages,
 		recentMessages,
+		recentEntryIds,
 		isSplitTurn,
 		tokensBefore,
 		previousSummary,
@@ -1734,6 +1749,7 @@ export async function compact(
 						contextWindow: model.contextWindow,
 					});
 				}
+				assertRemoteCompactionInputFits(trimmed, model);
 				const requestOptions = {
 					sessionId: summaryOptions.sessionId,
 					promptCacheKey: summaryOptions.promptCacheKey,
@@ -1826,35 +1842,19 @@ 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.
+	// On-demand compaction summarizes only the prefix; the tail is never sent
+	// to this request and is replayed after the returned signed block.
 	let nativeSummary: string | undefined;
-	let nativeEncryptedContent: string | undefined;
+	let nativeSignature: string | undefined;
+	let nativeFirstKeptEntryId = firstKeptEntryId;
 	let nativeUsedTokens: number | undefined;
-	if (
-		!usedRemoteCompaction &&
-		settings.remoteEnabled !== false &&
-		shouldUseAnthropicNativeCompaction(model) &&
-		tokensBefore >= ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS
-	) {
+	if (!usedRemoteCompaction && settings.remoteEnabled !== false && shouldUseAnthropicNativeCompaction(model)) {
 		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.
+		// Lead with the previous summary as the live context renders it:
+		// natively when this provider wrote it, as text otherwise.
+		// A prior snapcompact archive is already merged into that summary
+		// text. Predate the rewrite marker before all replayed messages so
+		// retained thinking stays bound to the original prefix.
 		const firstReplayed = messagesToSummarize[0] ?? turnPrefixMessages[0] ?? recentMessages[0];
 		const previousSummaryAt =
 			firstReplayed !== undefined ? new Date(firstReplayed.timestamp - 1).toISOString() : new Date().toISOString();
@@ -1866,6 +1866,7 @@ export async function compact(
 									type: "anthropicCompaction",
 									provider: previousNative.provider,
 									content: previousNative.content,
+									...(previousNative.signature ? { signature: previousNative.signature } : {}),
 									...(previousNative.encryptedContent
 										? { encryptedContent: previousNative.encryptedContent }
 										: {}),
@@ -1874,29 +1875,40 @@ export async function compact(
 							: undefined,
 				})
 			: undefined;
-		const convertToLlm = summaryOptions.convertToLlm ?? defaultConvertToLlm;
-		const retainedTail = convertToLlm(recentMessages);
-		const messages = [
-			...convertToLlm([
-				...(previousSummaryMessage ? [previousSummaryMessage] : []),
-				...messagesToSummarize,
-				...turnPrefixMessages,
-			]),
-			...retainedTail,
-		];
+		const allMessages = [...messagesToSummarize, ...turnPrefixMessages, ...recentMessages];
+		const originalCut = messagesToSummarize.length + turnPrefixMessages.length;
+		const nativeCut = findAnthropicCompactionCut(allMessages, originalCut);
+		// Hand-built preparations lacking entry IDs cannot move their persisted
+		// boundary into the tail. Summarizing all is still safe.
+		const safeCut =
+			nativeCut > originalCut && nativeCut < allMessages.length && !recentEntryIds?.[nativeCut - originalCut]
+				? allMessages.length
+				: nativeCut;
+		nativeFirstKeptEntryId =
+			safeCut === allMessages.length
+				? ""
+				: safeCut === originalCut
+					? firstKeptEntryId
+					: (recentEntryIds?.[safeCut - originalCut] ?? "");
+		for (let i = originalCut; i < safeCut; i++) extractFileOpsFromMessage(allMessages[i], fileOps);
+		const messages = (summaryOptions.convertToLlm ?? defaultConvertToLlm)([
+			...(previousSummaryMessage ? [previousSummaryMessage] : []),
+			...allMessages.slice(0, safeCut),
+		]);
 		try {
 			const remote = await requestAnthropicNativeCompaction(
 				model,
 				apiKey,
 				{
-					systemPrompt: summaryOptions.remoteSystemPrompt ?? [SUMMARIZATION_SYSTEM_PROMPT],
+					// The live prompt, not the local summarizer's synthetic system
+					// prompt: kept thinking remains valid only under identical controls.
+					systemPrompt: summaryOptions.remoteSystemPrompt ?? [],
 					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),
@@ -1915,7 +1927,7 @@ export async function compact(
 				},
 			);
 			nativeSummary = remote.content;
-			nativeEncryptedContent = remote.encryptedContent;
+			nativeSignature = remote.signature;
 			nativeUsedTokens = calculatePromptTokens(remote.usage);
 			usedRemoteCompaction = true;
 		} catch (err) {
@@ -2004,7 +2016,7 @@ export async function compact(
 	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
+		// matches its signature. 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.
@@ -2012,7 +2024,7 @@ export async function compact(
 		preserveData = withAnthropicCompactionPreserveData(preserveData, {
 			provider: model.provider,
 			content: nativeSummary,
-			...(nativeEncryptedContent ? { encryptedContent: nativeEncryptedContent } : {}),
+			...(nativeSignature ? { signature: nativeSignature } : {}),
 			...(filesText ? { filesText } : {}),
 			model: model.id,
 			usedTokens: nativeUsedTokens,
@@ -2034,7 +2046,7 @@ export async function compact(
 	return {
 		summary,
 		shortSummary,
-		firstKeptEntryId,
+		firstKeptEntryId: nativeSummary !== undefined ? nativeFirstKeptEntryId : firstKeptEntryId,
 		tokensBefore,
 		details: { readFiles, modifiedFiles } as CompactionDetails,
 		preserveData: finalPreserveData,

package/src/compaction/messages.ts

@@ -64,6 +64,13 @@ export interface CompactionSummaryMessage {
 	images?: ImageContent[];
 	/** Post-pass dead-end warning attached to this compaction (progress guard). */
 	warning?: string;
+	/**
+	 * Thinking-binding rewrite marker when it must differ from `timestamp`: a
+	 * natively replayed summary predates it before the retained tail so that
+	 * tail's bound thinking stays valid. `timestamp` remains the commit time,
+	 * which is what invalidates the tail's pre-compaction usage reports.
+	 */
+	historyRewriteAt?: number;
 	timestamp: number;
 }
 
@@ -135,6 +142,8 @@ export interface CompactionSummaryMessageOptions {
 	method?: string;
 	/** Estimated context tokens after the rewrite, for display alongside `tokensBefore`. */
 	tokensAfter?: number;
+	/** See {@link CompactionSummaryMessage.historyRewriteAt}. */
+	historyRewriteAt?: number;
 }
 
 export function createCompactionSummaryMessage(
@@ -143,7 +152,7 @@ export function createCompactionSummaryMessage(
 	timestamp: string,
 	options: CompactionSummaryMessageOptions = {},
 ): CompactionSummaryMessage {
-	const { shortSummary, providerPayload, images, blocks, warning, method, tokensAfter } = options;
+	const { shortSummary, providerPayload, images, blocks, warning, method, tokensAfter, historyRewriteAt } = options;
 	const imageBlocks =
 		blocks?.filter((block): block is ImageContent => block.type === "image") ??
 		(images && images.length > 0 ? images : undefined);
@@ -158,6 +167,7 @@ export function createCompactionSummaryMessage(
 		blocks: blocks && blocks.length > 0 ? blocks : undefined,
 		images: imageBlocks && imageBlocks.length > 0 ? imageBlocks : undefined,
 		warning,
+		historyRewriteAt,
 		timestamp: new Date(timestamp).getTime(),
 	};
 }
@@ -246,7 +256,7 @@ export function convertMessageToLlm(message: AgentMessage): Message | undefined
 									...(message.images ?? []),
 								],
 					attribution: "agent",
-					historyRewriteAt: message.timestamp,
+					historyRewriteAt: message.historyRewriteAt ?? message.timestamp,
 					providerPayload: message.providerPayload,
 					timestamp: message.timestamp,
 				};

package/src/compaction/openai.ts

@@ -15,13 +15,11 @@
  *   with `{ summary, shortSummary? }`.
  */
 
-import { ProviderHttpError } from "@linxiraos/pi-ai/error";
+import { attach, create, Flag, ProviderHttpError } from "@linxiraos/pi-ai/error";
+import { getCodexAttestationHeader } from "@linxiraos/pi-ai/providers/openai-codex-attestation";
+import { createOpenAICodexCompactionRequestContext } from "@linxiraos/pi-ai/providers/openai-codex-compaction";
 import { applyCodexResponsesLiteShape } from "@linxiraos/pi-ai/providers/openai-codex/request-transformer";
-import {
-	createOpenAICodexCompactionRequestContext,
-	createOpenAICodexCompatibilityMetadata,
-	getCodexAttestationHeader,
-} from "@linxiraos/pi-ai/providers/openai-codex-responses";
+import { createOpenAICodexCompatibilityMetadata } from "@linxiraos/pi-ai/providers/openai-codex-responses";
 import {
 	encodeResponsesToolResultOutput,
 	hoistInterleavedResponsesToolBatchMessages,
@@ -112,6 +110,10 @@ function normalizeRemoteCompactionEstimateValue(value: unknown): NormalizedEstim
 	const normalized: Record<string, unknown> = {};
 	let imageTokens = 0;
 	for (const [key, item] of Object.entries(record)) {
+		// Opaque encrypted reasoning/compaction state: its local base64 size far
+		// exceeds what the provider bills, so it stays out of the fit estimate
+		// (same policy as `MessageCountOptions.excludeEncryptedReasoning`).
+		if (key === "encrypted_content" && typeof item === "string") continue;
 		const result = normalizeRemoteCompactionEstimateValue(item);
 		normalized[key] = result.value;
 		imageTokens += result.imageTokens;
@@ -124,6 +126,8 @@ export interface TrimRemoteCompactionInputResult {
 	rewrittenOutputs: number;
 	estimatedTokensBefore: number;
 	estimatedTokensAfter: number;
+	/** Whether `input` fits the model window; false means it must not be sent. */
+	fits: boolean;
 }
 
 /** Verdict for one remote-compaction request measured against the model window. */
@@ -137,9 +141,10 @@ interface RemoteCompactionBudgetProbe {
 /**
  * Cheap-first sizing of a remote-compaction request. Images and the request
  * frame are charged flat, so they come off the budget rather than through the
- * tokenizer; the serialized transcript is then probed with
- * {@link Tokenizer.checkTokenBudget}, which only pays for an exact count when
- * the byte bound cannot already prove the request fits.
+ * tokenizer; opaque `encrypted_content` payloads are excluded. The serialized
+ * transcript is then probed with {@link Tokenizer.checkTokenBudget}, which only
+ * pays for an exact count when the byte bound cannot already prove the request
+ * fits.
  */
 function probeRemoteCompactionInputBudget(
 	input: Array<Record<string, unknown>>,
@@ -201,6 +206,7 @@ export function trimRemoteCompactionInputToContextWindow(
 			rewrittenOutputs: 0,
 			estimatedTokensBefore: before.tokens,
 			estimatedTokensAfter: before.tokens,
+			fits: true,
 		};
 	}
 
@@ -224,6 +230,7 @@ export function trimRemoteCompactionInputToContextWindow(
 			rewrittenOutputs: 0,
 			estimatedTokensBefore: before.tokens,
 			estimatedTokensAfter: before.tokens,
+			fits: false,
 		};
 	}
 
@@ -232,9 +239,29 @@ export function trimRemoteCompactionInputToContextWindow(
 		rewrittenOutputs,
 		estimatedTokensBefore: before.tokens,
 		estimatedTokensAfter: after.tokens,
+		fits: true,
 	};
 }
 
+/**
+ * Refuse a native compaction request whose prepared input cannot fit the model
+ * window, before any network I/O. Re-expanded history behind an unreadable
+ * native boundary can exceed the window even when live context does not.
+ *
+ * @throws Error flagged `ContextOverflow` when `trimmed.fits` is false, so
+ *   compaction callers skip retries and advance to the next method.
+ */
+export function assertRemoteCompactionInputFits(trimmed: TrimRemoteCompactionInputResult, model: Model): void {
+	if (trimmed.fits) return;
+	throw attach(
+		new Error(
+			`Remote compaction input exceeds the context window of ${model.provider}/${model.id}: ` +
+				`estimated ${trimmed.estimatedTokensAfter} tokens > ${model.contextWindow}`,
+		),
+		create(Flag.ContextOverflow),
+	);
+}
+
 /** Race the caller's signal against the request timeout; `timeoutMs <= 0` disables the watchdog. */
 function withRequestTimeout(signal: AbortSignal | undefined, timeoutMs: number): AbortSignal | undefined {
 	if (timeoutMs <= 0) return signal;
@@ -796,6 +823,7 @@ export async function requestOpenAiRemoteCompaction(
 			contextWindow: model.contextWindow,
 		});
 	}
+	assertRemoteCompactionInputFits(trimmed, model);
 	const request: OpenAiRemoteCompactionRequest = {
 		model: requestModel,
 		// Preserve the native transcript. Only oversized trailing tool outputs are

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

@@ -1,8 +1,4 @@
-{{#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}}
+The conversation above is the complete history to summarize. The API replaces every message in this request with your summary; no message you leave out survives.
 
 {{#if extraContext}}
 {{extraContext}}
@@ -14,4 +10,4 @@ SCOPE: The conversation above is the transcript to summarize. The API replaces e
 Additional focus: {{customInstructions}}
 {{/if}}
 
-You MUST NOT call any tools while writing the summary; respond with the summary text only.
+You MUST NOT call any tools while writing the summary; respond with the summary text only.

package/src/compaction/pruning.ts

@@ -120,7 +120,7 @@ function createPrunedNotice(tokens: number): string {
  * own rules: useless already drops no-savings candidates, superseded prunes for
  * correctness regardless of size.
  */
-const MIN_PRUNE_TOKENS = 50;
+export const MIN_PRUNE_TOKENS = 50;
 
 function getToolResultMessage(entry: SessionEntry): ToolResultMessage | undefined {
 	if (entry.type !== "message") return undefined;

package/src/compaction/transcript-tokens.ts

@@ -18,7 +18,7 @@
  * - `hasContextTokenUsage(usage)`: the report must carry usable context numbers.
  */
 
-import type { AssistantMessage } from "@linxiraos/pi-ai";
+import type { AssistantMessage, Message } from "@linxiraos/pi-ai";
 import type { MessageCountOptions, Tokenizer } from "../tokenizer";
 import type { AgentMessage } from "../types";
 import { calculateContextTokens, hasContextTokenUsage } from "./compaction";
@@ -47,6 +47,31 @@ export function isTranscriptUsageAnchor(message: AgentMessage): message is Assis
 	return assistant.usage !== undefined && hasContextTokenUsage(assistant.usage);
 }
 
+/**
+ * Newest `prunedAt` in `messages`, or `-Infinity` when nothing was pruned.
+ *
+ * A pruned tool result was rewritten in place, so every usage report made at
+ * or before this time still counts the removed bytes.
+ */
+function newestPrunedAt(messages: readonly AgentMessage[]): number {
+	let rewriteAt = Number.NEGATIVE_INFINITY;
+	for (const message of messages) {
+		if (message.role === "toolResult" && message.prunedAt !== undefined) {
+			rewriteAt = Math.max(rewriteAt, message.prunedAt);
+		}
+	}
+	return rewriteAt;
+}
+
+/** Options for {@link findTranscriptUsageAnchor}. */
+export interface TranscriptUsageAnchorOptions {
+	/**
+	 * Also treat usage reported at or before the newest `prunedAt` as stale,
+	 * the same rule {@link findRequestUsageAnchor} applies to request contexts.
+	 */
+	skipPrunedAnchors?: boolean;
+}
+
 /**
  * Newest assistant turn in `messages[fromIndex..]` whose usage can anchor the
  * transcript, or `undefined` when none qualifies (fresh context, or every
@@ -58,15 +83,47 @@ export function isTranscriptUsageAnchor(message: AgentMessage): message is Assis
 export function findTranscriptUsageAnchor(
 	messages: readonly AgentMessage[],
 	fromIndex = 0,
+	options?: TranscriptUsageAnchorOptions,
 ): TranscriptUsageAnchor | undefined {
+	const rewriteAt = options?.skipPrunedAnchors === true ? newestPrunedAt(messages) : Number.NEGATIVE_INFINITY;
 	for (let index = messages.length - 1; index >= fromIndex; index--) {
 		const message = messages[index];
-		if (!isTranscriptUsageAnchor(message)) continue;
+		if (!isTranscriptUsageAnchor(message) || message.timestamp <= rewriteAt) continue;
 		return { index, message, tokens: calculateContextTokens(message.usage) };
 	}
 	return undefined;
 }
 
+/**
+ * Newest assistant turn in a provider request's `messages` whose usage still
+ * describes the prefix it sits on, or `undefined` when none does.
+ *
+ * Request contexts carry no compaction index, so staleness is read from the
+ * rewrite markers themselves: a compaction/branch summary or pruned tool result
+ * (`prunedAt`) replaced text that every report made at or before the rewrite
+ * already counted. A summary's rewrite time is its `timestamp` (commit time);
+ * its `historyRewriteAt` may be predated before a natively replayed retained
+ * tail so that tail's bound thinking survives, but the tail's usage still
+ * counted the summarized prefix.
+ */
+export function findRequestUsageAnchor(messages: readonly Message[]): TranscriptUsageAnchor | undefined {
+	let rewriteAt = Number.NEGATIVE_INFINITY;
+	let anchorIndex = -1;
+	let anchor: AssistantMessage | undefined;
+	for (let index = 0; index < messages.length; index++) {
+		const message = messages[index];
+		if (message.role === "user" && message.historyRewriteAt !== undefined) {
+			rewriteAt = Math.max(rewriteAt, message.historyRewriteAt, message.timestamp);
+		} else if (message.role === "toolResult" && message.prunedAt !== undefined) {
+			rewriteAt = Math.max(rewriteAt, message.prunedAt);
+		} else if (isTranscriptUsageAnchor(message) && message.timestamp > rewriteAt) {
+			anchorIndex = index;
+			anchor = message;
+		}
+	}
+	return anchor && { index: anchorIndex, message: anchor, tokens: calculateContextTokens(anchor.usage) };
+}
+
 /** Options for {@link estimateTranscriptTokens}. */
 export interface TranscriptTokenOptions {
 	/**
@@ -75,6 +132,8 @@ export interface TranscriptTokenOptions {
 	 * accounting is governed separately by {@link countFromIndex}.
 	 */
 	anchorFromIndex?: number;
+	/** Forwarded to {@link findTranscriptUsageAnchor}. */
+	skipPrunedAnchors?: boolean;
 	/**
 	 * First message whose content is counted locally when no anchor is found.
 	 * Defaults to 0 (count the whole transcript), which is what a floor
@@ -102,7 +161,9 @@ export function estimateTranscriptTokens(
 ): number {
 	const estimateOptions: MessageCountOptions | undefined =
 		options?.excludeEncryptedReasoning === true ? { excludeEncryptedReasoning: true } : undefined;
-	const anchor = findTranscriptUsageAnchor(messages, options?.anchorFromIndex ?? 0);
+	const anchor = findTranscriptUsageAnchor(messages, options?.anchorFromIndex ?? 0, {
+		skipPrunedAnchors: options?.skipPrunedAnchors,
+	});
 	let total = anchor?.tokens ?? 0;
 	for (let index = anchor ? anchor.index + 1 : (options?.countFromIndex ?? 0); index < messages.length; index++) {
 		total += tokenizer.countMessage(messages[index], estimateOptions);

package/src/index.ts

@@ -6,6 +6,8 @@ export * from "./agent-loop";
 export * from "./append-only-context";
 // Compaction
 export * from "./compaction";
+// Output cap sized to the remaining context window
+export * from "./output-budget";
 // Process-global pause gate
 export * from "./pause";
 // Proxy utilities
@@ -14,12 +16,16 @@ export * from "./proxy";
 export * from "./replay-policy";
 // Run-level telemetry collector + aggregators
 export * from "./run-collector";
+// Tool definitions remembered for Anthropic inactive-tool re-declaration
+export * from "./sent-tool-definitions";
 // Speculative execution coordinator
 export * from "./speculative-execution";
 // Telemetry
 export * from "./telemetry";
 // Thinking selectors
 export * from "./thinking";
+// Tool-context augmentation
+export * from "./tool-context";
 // Tokenizer choice
 export * from "./tokenizer";
 // Types