@oh-my-pi/pi-agent-core 17.3.8 → 17.4.1

package/src/compaction/compaction.ts

@@ -31,11 +31,11 @@ import { buildResponsesInput, resolveOpenAICompatPolicy } from "@oh-my-pi/pi-ai/
 import { stripOpenAIResponsesOutputOnlyStatusesForReplay } from "@oh-my-pi/pi-ai/utils";
 import { preferredDialect } from "@oh-my-pi/pi-catalog/identity";
 import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
-import { isRecord, logger, prompt, stringifyJson } from "@oh-my-pi/pi-utils";
+import { isRecord, logger, prompt } from "@oh-my-pi/pi-utils";
 import * as snapcompact from "@oh-my-pi/snapcompact";
 import { type AgentTelemetry, instrumentedCompleteSimple } from "../telemetry";
 import { ThinkingLevel } from "../thinking";
-import { countTokens } from "../tokenizer";
+import { Tokenizer } from "../tokenizer";
 import type { AgentMessage } from "../types";
 import {
 	buildCompactionV2Request,
@@ -47,7 +47,6 @@ import {
 } from "./compaction-v2-streaming";
 import type { CompactionEntry, SessionEntry } from "./entries";
 import { NativeCompactionError } from "./errors";
-import { isEstimateCacheable, readEstimateCache, writeEstimateCache } from "./message-cache";
 import { type ConvertToLlm, createBranchSummaryMessage, createCustomMessage, defaultConvertToLlm } from "./messages";
 import {
 	buildOpenAiNativeHistory,
@@ -390,144 +389,17 @@ export function resolveThresholdTokens(contextWindow: number, settings: Compacti
 // Cut point detection
 // ============================================================================
 
-/**
- * Image content has no tokenizer representation; charge a fixed estimate
- * matching what providers typically bill for inline images.
- */
-const IMAGE_TOKEN_ESTIMATE = 1200;
-
-/**
- * Estimate token count for a message using cl100k_base via the native
- * tokenizer. This is not Claude's first-party tokenizer (Anthropic doesn't
- * publish one) but is within ~5–10% across English/code text.
- *
- * `excludeEncryptedReasoning` drops opaque provider reasoning payloads
- * (`thinkingSignature`, `redactedThinking`) from the estimate. Those are billed
- * by the provider on replay, so the default counts them — but their *local*
- * byte size can diverge wildly from what the provider charges, so the
- * compaction floor (which only needs the reliably-countable, on-wire-compressible
- * content) excludes them to avoid false triggers on thinking-heavy turns.
- */
-export function estimateTokens(message: AgentMessage, options?: { excludeEncryptedReasoning?: boolean }): number {
-	// Settled historical messages are counted once and reused until an owner
-	// (prune/shake/strip-images) invalidates them; streaming assistants bypass
-	// the cache entirely (see message-cache.ts settle-gate invariant).
-	const cacheable = isEstimateCacheable(message);
-	const excludeEncryptedReasoning = options?.excludeEncryptedReasoning === true;
-	if (cacheable) {
-		const cached = readEstimateCache(message, excludeEncryptedReasoning);
-		if (cached !== undefined) return cached;
-	}
-	const result = computeMessageTokens(message, options);
-	if (cacheable) writeEstimateCache(message, excludeEncryptedReasoning, result);
-	return result;
-}
-
-function computeMessageTokens(message: AgentMessage, options?: { excludeEncryptedReasoning?: boolean }): number {
-	const fragments: string[] = [];
-	let extra = 0;
-	if ((message as { role?: string }).role === "bashExecution") {
-		const bash = message as { command?: unknown; output?: unknown };
-		if (typeof bash.command === "string") fragments.push(bash.command);
-		if (typeof bash.output === "string") fragments.push(bash.output);
-		return fragments.length === 0 ? 0 : countTokens(fragments);
-	}
-
-	switch (message.role) {
-		case "user": {
-			const content = (message as { content: string | Array<{ type: string; text?: string }> }).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);
-					}
-				}
-			}
-			break;
-		}
-		case "assistant": {
-			const assistant = message as AssistantMessage;
-			for (const block of assistant.content) {
-				if (block.type === "text") {
-					fragments.push(block.text);
-				} else if (block.type === "thinking") {
-					fragments.push(block.thinking);
-					// Providers charge for the opaque signature/reasoning payload that
-					// rides alongside the thinking text (OpenAI Responses encrypted
-					// reasoning items, Anthropic signed thinking blocks, etc.). Without
-					// counting it, this estimator can read ~half of the provider-reported
-					// usage on thinking-heavy turns — see #2275 for the resulting
-					// compaction-trigger / post-check metric divergence. The compaction
-					// floor excludes it (its local byte size diverges from provider billing).
-					if (block.thinkingSignature && !options?.excludeEncryptedReasoning) {
-						fragments.push(block.thinkingSignature);
-					}
-				} else if (block.type === "toolCall") {
-					fragments.push(block.name);
-					fragments.push(stringifyJson(block.arguments) ?? "null");
-				} else if (block.type === "redactedThinking") {
-					// Encrypted reasoning blob the provider still bills for on replay;
-					// excluded from the compaction floor for the same reason as above.
-					if (!options?.excludeEncryptedReasoning) fragments.push(block.data);
-				} else if (block.type === "anthropicServerTool") {
-					// Native Anthropic server-tool call/result replayed verbatim on the
-					// wire (server_tool_use input and opaque result content). This opaque
-					// provider-replay state the provider still
-					// bills for on same-provider replay; excluded from the compaction
-					// floor like other encrypted reasoning because its local byte size
-					// diverges from provider billing.
-					if (!options?.excludeEncryptedReasoning) fragments.push(stringifyJson(block.block) ?? "null");
-				}
-			}
-			break;
-		}
-		case "hookMessage":
-		case "toolResult": {
-			if (typeof message.content === "string") {
-				fragments.push(message.content);
-			} else {
-				for (const block of message.content) {
-					if (block.type === "text" && block.text) {
-						fragments.push(block.text);
-					} else if (block.type === "image") {
-						extra += IMAGE_TOKEN_ESTIMATE;
-					}
-				}
-			}
-			break;
-		}
-		case "branchSummary":
-		case "compactionSummary": {
-			fragments.push(message.summary);
-			if (message.role === "compactionSummary") {
-				if (message.blocks) {
-					for (const block of message.blocks) {
-						if (block.type === "text") fragments.push(block.text);
-						else extra += snapcompact.FRAME_TOKEN_ESTIMATE;
-					}
-				} else if (message.images) {
-					// Snapcompact frames render at ≥1568px; providers bill the downscaled cap.
-					extra += message.images.length * snapcompact.FRAME_TOKEN_ESTIMATE;
-				}
-			}
-			break;
-		}
-		default:
-			return 0;
-	}
-
-	if (fragments.length === 0) return extra;
-	return extra + countTokens(fragments);
-}
-
-function estimateEntriesTokens(entries: SessionEntry[], startIndex: number, endIndex: number): number {
+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 += estimateTokens(msg);
+			total += tokenizer.countMessage(msg);
 		}
 	}
 	return total;
@@ -626,6 +498,7 @@ export interface CutPointResult {
  */
 export function findCutPoint(
 	entries: SessionEntry[],
+	tokenizer: Tokenizer,
 	startIndex: number,
 	endIndex: number,
 	keepRecentTokens: number,
@@ -645,7 +518,7 @@ export function findCutPoint(
 		if (entry.type !== "message") continue;
 
 		// Estimate this message's size
-		const messageTokens = estimateTokens(entry.message);
+		const messageTokens = tokenizer.countMessage(entry.message);
 		accumulatedTokens += messageTokens;
 
 		// Check if we've exceeded the budget
@@ -948,12 +821,17 @@ interface SummaryWindow {
  * on message boundaries. Only called when the whole conversation does not fit —
  * the common single-window path never pays this per-message sizing pass.
  */
-function planSummaryWindows(messages: Message[], dialect: Dialect | undefined, budgetTokens: number): Message[][] {
+function planSummaryWindows(
+	messages: Message[],
+	tokenizer: Tokenizer,
+	dialect: Dialect | undefined,
+	budgetTokens: number,
+): Message[][] {
 	const windows: Message[][] = [];
 	let current: Message[] = [];
 	let currentTokens = 0;
 	for (const message of messages) {
-		const tokens = countTokens(serializeConversationForSummary([message], dialect));
+		const tokens = tokenizer.countTokens(serializeConversationForSummary([message], dialect));
 		if (currentTokens > 0 && currentTokens + tokens > budgetTokens) {
 			windows.push(current);
 			current = [];
@@ -982,6 +860,7 @@ export async function generateSummary(
 	// Convert to LLM messages first (handles custom app messages when caller provides a transformer).
 	const llmMessages = (options?.convertToLlm ?? defaultConvertToLlm)(currentMessages);
 	const dialect = preferredDialect(model.id);
+	const tokenizer = new Tokenizer(model);
 	const wholeConversation = serializeConversationForSummary(llmMessages, dialect);
 	const budgetTokens = summaryInputBudgetTokens(model, maxTokens);
 	// A span that outgrew the summarizer's window is summarized as a fold: each
@@ -991,19 +870,21 @@ export async function generateSummary(
 	// retry can shrink — the state a cross-provider compaction boundary
 	// (see `prepareCompaction`) puts a long session into. One window is the
 	// common case and costs exactly the one call it always did.
-	const pending: SummaryWindow[] =
-		countTokens(wholeConversation) <= budgetTokens
-			? [{ messages: llmMessages, budgetTokens, text: wholeConversation }]
-			: planSummaryWindows(llmMessages, dialect, budgetTokens).map(messages => ({ messages, budgetTokens }));
+	const pending: SummaryWindow[] = tokenizer.checkTokenBudget(wholeConversation, budgetTokens).fits
+		? [{ messages: llmMessages, budgetTokens, text: wholeConversation }]
+		: planSummaryWindows(llmMessages, tokenizer, dialect, budgetTokens).map(messages => ({ messages, budgetTokens }));
 
 	let carriedSummary = previousSummary;
 	while (pending.length > 0) {
 		const window = pending[0];
 		const text = window.text ?? serializeConversationForSummary(window.messages, dialect);
-		const windowTokens = countTokens(text);
+		// A budget probe, not a raw count: a window whose bytes already fit needs
+		// neither an exact count nor the clamp, and the bust path hands back the
+		// exact count the proportional clamp needs as its denominator.
+		const budget = tokenizer.checkTokenBudget(text, window.budgetTokens);
 		try {
 			carriedSummary = await summarizeConversationWindow(
-				clampConversationToBudget(text, window.budgetTokens, windowTokens),
+				budget.fits ? text : clampConversationToBudget(text, window.budgetTokens, budget.tokens),
 				carriedSummary,
 				model,
 				maxTokens,
@@ -1020,8 +901,11 @@ export async function generateSummary(
 			// window size only the provider can tell us is wrong.
 			// Halve what was actually SENT, not the budget it was planned against:
 			// the rejection proves the plan was fiction, so converging on the real
-			// cap must not spend a call per level of an imaginary ladder.
-			const halved = Math.floor(Math.min(window.budgetTokens, windowTokens) / 2);
+			// cap must not spend a call per level of an imaginary ladder. The cheap
+			// fit path never counted this window, so pay for the exact size here —
+			// one tokenization is nothing against the provider round trip already lost.
+			const sentTokens = budget.exact ? budget.tokens : tokenizer.countTokens(text, "strict");
+			const halved = Math.floor(Math.min(window.budgetTokens, sentTokens) / 2);
 			if (
 				!AIError.is(AIError.classify(error), AIError.Flag.ContextOverflow) ||
 				halved < minSummaryInputTokens(model)
@@ -1031,7 +915,7 @@ export async function generateSummary(
 			pending.splice(
 				0,
 				1,
-				...planSummaryWindows(window.messages, dialect, halved).map(messages => ({
+				...planSummaryWindows(window.messages, tokenizer, dialect, halved).map(messages => ({
 					messages,
 					budgetTokens: halved,
 				})),
@@ -1384,7 +1268,7 @@ export interface CompactionPreparation {
  * let the active model replay it, so keying reuse on "any candidate shares the
  * provider" left a provider-switched session permanently context-less (#6343).
  */
-function remotePreserveReusable(
+export function remotePreserveReusable(
 	preserveData: Record<string, unknown> | undefined,
 	activeModel: Model,
 	settings: CompactionSettings,
@@ -1423,10 +1307,16 @@ export function findReadableCompactionIndex(
 	return -1;
 }
 
+/**
+ * Pass the caller's warm `tokenizer` (the Agent's for the active model) so the
+ * full-branch estimate walk hits its memo; the cold default is for one-shot
+ * callers that have no live agent.
+ */
 export function prepareCompaction(
 	pathEntries: SessionEntry[],
 	settings: CompactionSettings,
 	activeModel?: Model,
+	tokenizer: Tokenizer = new Tokenizer(activeModel),
 ): CompactionPreparation | undefined {
 	if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction") {
 		return undefined;
@@ -1459,7 +1349,7 @@ export function prepareCompaction(
 	const tokensBefore = lastUsage ? calculateContextTokens(lastUsage) : 0;
 	let keepRecentTokens = settings.keepRecentTokens;
 	if (lastUsage) {
-		const estimatedTokens = estimateEntriesTokens(pathEntries, boundaryStart, boundaryEnd);
+		const estimatedTokens = estimateEntriesTokens(pathEntries, tokenizer, boundaryStart, boundaryEnd);
 		const promptTokens = calculatePromptTokens(lastUsage);
 		const ratio = estimatedTokens > 0 ? promptTokens / estimatedTokens : 0;
 		if (Number.isFinite(ratio) && ratio > 1) {
@@ -1467,7 +1357,7 @@ export function prepareCompaction(
 		}
 	}
 
-	const cutPoint = findCutPoint(pathEntries, boundaryStart, boundaryEnd, keepRecentTokens);
+	const cutPoint = findCutPoint(pathEntries, tokenizer, boundaryStart, boundaryEnd, keepRecentTokens);
 
 	// Get ID of first kept entry
 	const firstKeptEntry = pathEntries[cutPoint.firstKeptEntryIndex];
@@ -1706,6 +1596,7 @@ export async function compact(
 					: undefined;
 				const trimmed = trimRemoteCompactionInputToContextWindow(
 					remoteHistory,
+					new Tokenizer(model),
 					model.contextWindow,
 					instructions,
 					tools,

package/src/compaction/index.ts

@@ -11,4 +11,5 @@ export * from "./messages";
 export * from "./openai";
 export * from "./pruning";
 export * from "./shake";
+export * from "./transcript-tokens";
 export * from "./utils";

package/src/compaction/message-cache.ts

@@ -1,13 +1,12 @@
 /**
- * Per-message memoization for the two hot history walks: token estimation
- * ({@link estimateTokens}) and LLM conversion (the coding-agent's `convertToLlm`).
+ * Cache-coherence seams for the two hot history walks: token estimation
+ * ({@link Tokenizer.countMessage}) and LLM conversion (the coding-agent's
+ * `convertToLlm`).
  *
  * Long sessions re-walk a settled `AgentMessage[]` every turn, re-tokenizing and
- * re-converting historical objects that only the newest suffix can change. These
- * caches key on message *identity* so a settled message is counted/converted once
- * and reused until an owner rewrites it.
- *
- * Correctness rests on two invariants:
+ * re-converting historical objects that only the newest suffix can change. Each
+ * `Tokenizer` memoizes estimates per message identity; this module owns the two
+ * invariants that keep those memos (and the cross-package convert memo) honest:
  *
  * 1. **Settle gate.** A streaming assistant is mutated under one identity while
  *    its `usage`/`stopReason` are provisional (the seed carries zeroed usage and
@@ -19,9 +18,11 @@
  * 2. **Owner invalidation.** `pruneToolOutputs` / `pruneSupersededToolResults`,
  *    `applyShakeRegion`, and `stripImagesFromMessage` rewrite message content in
  *    place under a stable identity. Each MUST call {@link invalidateMessageCache}
- *    on the mutated message before the next convert/estimate pass so both caches
- *    drop the stale entry. The convert cache lives in another package, so it
- *    subscribes via {@link registerMessageCacheInvalidator}.
+ *    on the mutated message before the next convert/estimate pass. Invalidation
+ *    bumps a symbol-keyed version tag on the message itself, so every live
+ *    `Tokenizer` memo drops its stale entry at once without registering
+ *    anywhere; the convert cache lives in another package and subscribes via
+ *    {@link registerMessageCacheInvalidator}.
  */
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import type { AgentMessage } from "../types";
@@ -41,18 +42,26 @@ export function registerMessageCacheInvalidator(invalidate: (message: AgentMessa
 	};
 }
 
-// Dual option-split estimate caches: the compaction floor passes
-// `excludeEncryptedReasoning` (dropping opaque provider reasoning), so a message
-// has two distinct estimates that must not collide in one map.
-//
-// These are WeakMaps, not symbol-tagged properties, deliberately: callers spread
-// messages to derive throwaway variants for counting — `estimateBranchSummaryTokens`
-// does `estimateTokens({ ...message, content: truncated })`. A symbol-keyed cache
-// value rides along an object spread, so the truncated clone would inherit (and
-// return) the full-content estimate. Keying strictly on identity keeps the cache
-// off spread copies, which get their own fresh count.
-const estimateCacheDefault = new WeakMap<AgentMessage, number>();
-const estimateCacheFloored = new WeakMap<AgentMessage, number>();
+/**
+ * Estimate-version tag riding on the message itself. Symbol-keyed, so JSON
+ * session persistence and default iteration never see it. Object spread copies
+ * the tag onto derived clones — harmless, because estimate memos key on message
+ * *identity* and a fresh clone starts with no memo entries anywhere.
+ */
+const kEstimateVersion = Symbol("omp.messageEstimateVersion");
+
+interface VersionedMessage {
+	[kEstimateVersion]?: number;
+}
+
+/**
+ * Current estimate version of `message` (0 until first invalidation). A
+ * `Tokenizer` memo entry stamped with an older version is stale and must be
+ * recounted.
+ */
+export function messageEstimateVersion(message: AgentMessage): number {
+	return (message as VersionedMessage)[kEstimateVersion] ?? 0;
+}
 
 /**
  * True when this message's estimate is safe to cache by identity. Non-assistants
@@ -70,23 +79,13 @@ export function isEstimateCacheable(message: AgentMessage): boolean {
 	);
 }
 
-/** Read a cached estimate for the given option split, or `undefined` on miss. */
-export function readEstimateCache(message: AgentMessage, excludeEncryptedReasoning: boolean): number | undefined {
-	return (excludeEncryptedReasoning ? estimateCacheFloored : estimateCacheDefault).get(message);
-}
-
-/** Store an estimate for the given option split. */
-export function writeEstimateCache(message: AgentMessage, excludeEncryptedReasoning: boolean, value: number): void {
-	(excludeEncryptedReasoning ? estimateCacheFloored : estimateCacheDefault).set(message, value);
-}
-
 /**
  * Drop every cached derivation of `message` after an in-place rewrite. Owners of
  * mutation (prune, shake, strip-images) call this at the mutation seam so the
  * next convert/estimate pass recomputes from the new content.
  */
 export function invalidateMessageCache(message: AgentMessage): void {
-	estimateCacheDefault.delete(message);
-	estimateCacheFloored.delete(message);
+	const versioned = message as VersionedMessage;
+	versioned[kEstimateVersion] = ((versioned[kEstimateVersion] ?? 0) + 1) | 0;
 	for (const invalidate of externalInvalidators) invalidate(message);
 }

package/src/compaction/messages.ts

@@ -49,6 +49,10 @@ export interface CompactionSummaryMessage {
 	summary: string;
 	shortSummary?: string;
 	tokensBefore: number;
+	/** Estimated context tokens after the rewrite (display metadata). */
+	tokensAfter?: number;
+	/** Harness compaction method that produced this summary (display metadata). */
+	method?: string;
 	providerPayload?: ProviderPayload;
 	/** Runtime-only ordered archive blocks for snapcompact: old text region,
 	 *  imaged middle, then new text region. When present, `summary` is already
@@ -99,16 +103,26 @@ export function createBranchSummaryMessage(summary: string, fromId: string, time
 	};
 }
 
+/** Optional metadata for {@link createCompactionSummaryMessage}. */
+export interface CompactionSummaryMessageOptions {
+	shortSummary?: string;
+	providerPayload?: ProviderPayload;
+	images?: ImageContent[];
+	blocks?: (TextContent | ImageContent)[];
+	warning?: string;
+	/** Harness compaction method that produced this summary (e.g. "remote", "soft", "handoff"). */
+	method?: string;
+	/** Estimated context tokens after the rewrite, for display alongside `tokensBefore`. */
+	tokensAfter?: number;
+}
+
 export function createCompactionSummaryMessage(
 	summary: string,
 	tokensBefore: number,
 	timestamp: string,
-	shortSummary?: string,
-	providerPayload?: ProviderPayload,
-	images?: ImageContent[],
-	blocks?: (TextContent | ImageContent)[],
-	warning?: string,
+	options: CompactionSummaryMessageOptions = {},
 ): CompactionSummaryMessage {
+	const { shortSummary, providerPayload, images, blocks, warning, method, tokensAfter } = options;
 	const imageBlocks =
 		blocks?.filter((block): block is ImageContent => block.type === "image") ??
 		(images && images.length > 0 ? images : undefined);
@@ -117,6 +131,8 @@ export function createCompactionSummaryMessage(
 		summary,
 		shortSummary,
 		tokensBefore,
+		tokensAfter,
+		method,
 		providerPayload,
 		blocks: blocks && blocks.length > 0 ? blocks : undefined,
 		images: imageBlocks && imageBlocks.length > 0 ? imageBlocks : undefined,

package/src/compaction/openai.ts

@@ -45,13 +45,14 @@ import {
 } from "@oh-my-pi/pi-ai/utils";
 import { captureOpenAIHttpError } from "@oh-my-pi/pi-ai/utils/openai-http";
 import {
+	applyCodexResidencyHeader,
 	CODEX_BASE_URL,
 	getCodexAccountId,
 	OPENAI_HEADER_VALUES,
 	OPENAI_HEADERS,
 } from "@oh-my-pi/pi-catalog/wire/codex";
 import { $env, isRecord, logger, prompt, stringifyJson, structuredCloneJSON } from "@oh-my-pi/pi-utils";
-import { countTokensConservatively } from "../tokenizer";
+import { Tokenizer } from "../tokenizer";
 import contextWindowTruncatedOutputPrompt from "./prompts/context-window-truncated-output.md" with { type: "text" };
 
 export * from "./compaction-v2-streaming";
@@ -123,14 +124,36 @@ export interface TrimRemoteCompactionInputResult {
 	estimatedTokensAfter: number;
 }
 
-function estimateRemoteCompactionInputTokens(
+/** Verdict for one remote-compaction request measured against the model window. */
+interface RemoteCompactionBudgetProbe {
+	/** Estimated request tokens; the text part is exact when the cheap bound busted. */
+	tokens: number;
+	/** Whether the request fits the window. Always true when no window is known. */
+	fits: boolean;
+}
+
+/**
+ * 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.
+ */
+function probeRemoteCompactionInputBudget(
 	input: Array<Record<string, unknown>>,
+	tokenizer: Tokenizer,
 	instructions: string,
-	tools?: unknown[],
-): number {
+	tools: unknown[] | undefined,
+	contextWindow: number | null | undefined,
+): RemoteCompactionBudgetProbe {
 	const normalized = normalizeRemoteCompactionEstimateValue({ instructions, input, ...(tools ? { tools } : {}) });
 	const serialized = stringifyJson(normalized.value) ?? "";
-	return countTokensConservatively(serialized) + normalized.imageTokens + REMOTE_COMPACTION_REQUEST_OVERHEAD_TOKENS;
+	const flatTokens = normalized.imageTokens + REMOTE_COMPACTION_REQUEST_OVERHEAD_TOKENS;
+	if (!contextWindow || contextWindow <= 0) {
+		return { tokens: tokenizer.countTokens(serialized, "upperbound") + flatTokens, fits: true };
+	}
+	const budget = tokenizer.checkTokenBudget(serialized, Math.max(0, contextWindow - flatTokens));
+	return { tokens: budget.tokens + flatTokens, fits: budget.fits };
 }
 
 function rewriteToolOutputForContextWindow(item: Record<string, unknown>): Record<string, unknown> | undefined {
@@ -164,24 +187,25 @@ function isToolResultImageAttachment(item: Record<string, unknown>): boolean {
  */
 export function trimRemoteCompactionInputToContextWindow(
 	input: Array<Record<string, unknown>>,
+	tokenizer: Tokenizer,
 	contextWindow: number | null | undefined,
 	instructions: string,
 	tools?: unknown[],
 ): TrimRemoteCompactionInputResult {
-	const estimatedTokensBefore = estimateRemoteCompactionInputTokens(input, instructions, tools);
-	if (!contextWindow || contextWindow <= 0 || estimatedTokensBefore <= contextWindow) {
+	const before = probeRemoteCompactionInputBudget(input, tokenizer, instructions, tools, contextWindow);
+	if (before.fits) {
 		return {
 			input,
 			rewrittenOutputs: 0,
-			estimatedTokensBefore,
-			estimatedTokensAfter: estimatedTokensBefore,
+			estimatedTokensBefore: before.tokens,
+			estimatedTokensAfter: before.tokens,
 		};
 	}
 
 	let rewrittenInput: Array<Record<string, unknown>> | undefined;
-	let estimatedTokensAfter = estimatedTokensBefore;
+	let after = before;
 	let rewrittenOutputs = 0;
-	for (let index = input.length - 1; index >= 0 && estimatedTokensAfter > contextWindow; index--) {
+	for (let index = input.length - 1; index >= 0 && !after.fits; index--) {
 		const item = input[index];
 		if (isToolResultImageAttachment(item)) continue;
 		const rewritten = rewriteToolOutputForContextWindow(item);
@@ -189,23 +213,23 @@ export function trimRemoteCompactionInputToContextWindow(
 		rewrittenInput ??= input.slice();
 		rewrittenInput[index] = rewritten;
 		rewrittenOutputs++;
-		estimatedTokensAfter = estimateRemoteCompactionInputTokens(rewrittenInput, instructions, tools);
+		after = probeRemoteCompactionInputBudget(rewrittenInput, tokenizer, instructions, tools, contextWindow);
 	}
 
-	if (!rewrittenInput || estimatedTokensAfter > contextWindow) {
+	if (!rewrittenInput || !after.fits) {
 		return {
 			input,
 			rewrittenOutputs: 0,
-			estimatedTokensBefore,
-			estimatedTokensAfter: estimatedTokensBefore,
+			estimatedTokensBefore: before.tokens,
+			estimatedTokensAfter: before.tokens,
 		};
 	}
 
 	return {
 		input: rewrittenInput,
 		rewrittenOutputs,
-		estimatedTokensBefore,
-		estimatedTokensAfter,
+		estimatedTokensBefore: before.tokens,
+		estimatedTokensAfter: after.tokens,
 	};
 }
 
@@ -766,7 +790,12 @@ export async function requestOpenAiRemoteCompaction(
 ): Promise<OpenAiRemoteCompactionResponse> {
 	const endpoint = resolveOpenAiCompactEndpoint(model);
 	const requestModel = resolveOpenAiCompactModel(model);
-	const trimmed = trimRemoteCompactionInputToContextWindow(compactInput, model.contextWindow, instructions);
+	const trimmed = trimRemoteCompactionInputToContextWindow(
+		compactInput,
+		new Tokenizer(model),
+		model.contextWindow,
+		instructions,
+	);
 	if (trimmed.rewrittenOutputs > 0) {
 		logger.info("Rewrote trailing tool outputs before OpenAI remote compaction", {
 			model: model.id,
@@ -806,6 +835,7 @@ export async function requestOpenAiRemoteCompaction(
 		if (accountId) {
 			headers[OPENAI_HEADERS.ACCOUNT_ID] = accountId;
 		}
+		applyCodexResidencyHeader(headers, apiKey);
 		const attestation = await getCodexAttestationHeader(accountId);
 		if (attestation) {
 			headers[OPENAI_HEADERS.ATTESTATION] = attestation;