@gajae-code/coding-agent 0.10.0 → 0.10.2

package/src/session/agent-session.ts

@@ -28,6 +28,7 @@ import {
 	type AgentTool,
 	assertImagePlaceholdersHavePayload,
 	canContinuePersistedHistory,
+	type ResolvedThinkingLevel,
 	resolveTelemetry,
 	type StablePrefixSnapshot,
 	ThinkingLevel,
@@ -279,6 +280,7 @@ import { buildWorkflowIntentDiff, WORKFLOW_INTENT_DIFF_CUSTOM_TYPE } from "../wo
 import { buildWorkspaceTree, type WorkspaceTree } from "../workspace-tree";
 import type { AuthStorage } from "./auth-storage";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome } from "./client-bridge";
+import { computeNonMessageTokens } from "./context-estimation";
 import {
 	type ContributionPrepOptions,
 	type ContributionPrepResult,
@@ -531,6 +533,12 @@ export interface RoleModelCycleResult {
 	role: string;
 }
 
+export interface DefaultModelSelectionResult {
+	readonly provider: string;
+	readonly modelId: string;
+	readonly thinkingLevel: ResolvedThinkingLevel;
+}
+
 /** Session statistics for /session command */
 export interface SessionStats {
 	sessionFile: string | undefined;
@@ -1181,6 +1189,7 @@ export class AgentSession {
 	#scopedModels: ScopedModelSelection[];
 	#thinkingLevel: ThinkingLevel | undefined;
 	#activeModelProfile: string | undefined;
+	#defaultModelSelectionTail: Promise<void> = Promise.resolve();
 	#promptTemplates: PromptTemplate[];
 	#slashCommands: FileSlashCommand[];
 
@@ -1233,6 +1242,11 @@ export class AgentSession {
 	#resourceSampler: () => EmergencyCompactionSample = () => this.#defaultResourceSample();
 	#retainedMemorySampler: (() => RetainedMemorySample) | undefined;
 	#prePromptContextCheckPromise: Promise<void> | undefined = undefined;
+	/** Display-only context snapshot; pre-prompt compaction estimates deliberately remain uncached. */
+	#contextUsageCache: { key: string; value: ContextUsage } | undefined;
+	#contextUsageMessageIds = new WeakMap<AgentMessage, number>();
+	#nextContextUsageMessageId = 0;
+	#contextUsageEstimateCount = 0;
 
 	// Branch summarization state
 	#branchSummaryAbortController: AbortController | undefined = undefined;
@@ -2210,6 +2224,7 @@ export class AgentSession {
 			(this.#planCompactAbortPending || this.#silentAbortPending)
 		) {
 			(event.message as AssistantMessage).errorMessage = SILENT_ABORT_MARKER;
+			this.agent.touchContext();
 			this.#planCompactAbortPending = false;
 			this.#silentAbortPending = false;
 		}
@@ -5921,7 +5936,7 @@ export class AgentSession {
 			reload: async () => {
 				await this.reload();
 			},
-			getSystemPrompt: () => this.systemPrompt,
+			getSystemPrompt: () => [...this.systemPrompt],
 		};
 	}
 
@@ -6986,6 +7001,94 @@ export class AgentSession {
 		await this.#syncEditToolModeAfterModelChange(previousEditMode);
 	}
 
+	async setDefaultModelSelection(
+		model: Model,
+		thinkingLevel: ThinkingLevel | undefined,
+	): Promise<DefaultModelSelectionResult> {
+		const predecessor = this.#defaultModelSelectionTail;
+		const transaction = Promise.withResolvers<void>();
+		this.#defaultModelSelectionTail = transaction.promise;
+		try {
+			await predecessor;
+			if (thinkingLevel === ThinkingLevel.Inherit) {
+				throw new Error("Default model selection cannot inherit a thinking level");
+			}
+			const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
+			if (!apiKey) {
+				throw new Error(`No API key for ${model.provider}/${model.id}`);
+			}
+			const resolvedLevel = resolveThinkingLevelForModel(model, thinkingLevel);
+			const effectiveLevel =
+				resolvedLevel ??
+				resolveThinkingLevelForModel(model, model.thinking?.defaultLevel ?? this.thinkingLevel) ??
+				ThinkingLevel.Off;
+			await this.waitForIdle();
+			const previousDefaultModelRole = this.settings.getGlobal("modelRoles")?.default;
+			await this.sessionManager.flush();
+			const previousSessionState = this.sessionManager.captureState();
+			const previousModel = this.model;
+			const previousThinkingLevel = this.thinkingLevel;
+			const previousActiveRetryFallback = this.#activeRetryFallback ? { ...this.#activeRetryFallback } : undefined;
+			await this.settings.setGlobalModelRoleAndFlush(
+				"default",
+				formatModelSelectorValue(`${model.provider}/${model.id}`, effectiveLevel),
+			);
+			try {
+				await this.setModelTemporary(model, effectiveLevel);
+				if (this.thinkingLevel === previousThinkingLevel) {
+					this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
+				}
+				this.sessionManager.appendModelChange(`${model.provider}/${model.id}`, "default");
+			} catch (error) {
+				await this.settings.setGlobalModelRoleAndFlush("default", previousDefaultModelRole).catch(rollbackError => {
+					logger.warn("Failed to restore durable default model selection after live apply failure", {
+						error: String(rollbackError),
+					});
+				});
+				let restoredLiveState = false;
+				try {
+					const failedEditMode = this.#resolveActiveEditMode();
+					const currentModel = this.model;
+					const hasCompatibleModelTransport =
+						currentModel !== undefined &&
+						previousModel !== undefined &&
+						currentModel.provider === previousModel.provider &&
+						currentModel.id === previousModel.id &&
+						currentModel.api === previousModel.api;
+					if (hasCompatibleModelTransport) {
+						this.agent.setModel(previousModel);
+						this.#syncAppendOnlyContext(previousModel);
+					} else {
+						this.#setModelWithProviderSessionReset(previousModel);
+					}
+					this.#thinkingLevel = previousThinkingLevel;
+					this.agent.setThinkingLevel(toReasoningEffort(previousThinkingLevel));
+					await this.#syncEditToolModeAfterModelChange(failedEditMode);
+					restoredLiveState = true;
+				} catch (rollbackError) {
+					logger.warn("Failed to restore live default model selection after live apply failure", {
+						error: String(rollbackError),
+					});
+				}
+				if (restoredLiveState) {
+					this.#activeRetryFallback = previousActiveRetryFallback;
+				}
+				try {
+					this.sessionManager.restoreState(previousSessionState);
+					await this.sessionManager.rewriteEntries();
+				} catch (rollbackError) {
+					logger.warn("Failed to restore session state after live default model selection failure", {
+						error: String(rollbackError),
+					});
+				}
+				throw error;
+			}
+			return { provider: model.provider, modelId: model.id, thinkingLevel: effectiveLevel };
+		} finally {
+			transaction.resolve();
+		}
+	}
+
 	/**
 	 * Cycle to next/previous model.
 	 * Uses scoped models (from --models flag) if available, otherwise all available models.
@@ -8346,7 +8449,7 @@ export class AgentSession {
 		return candidate;
 	}
 
-	#setModelWithProviderSessionReset(model: Model): void {
+	#setModelWithProviderSessionReset(model: Model | undefined): void {
 		const currentModel = this.model;
 		if (currentModel) {
 			this.#closeProviderSessionsForModelSwitch(currentModel, model);
@@ -8386,15 +8489,15 @@ export class AgentSession {
 		}
 	}
 
-	#closeProviderSessionsForModelSwitch(currentModel: Model, nextModel: Model): void {
+	#closeProviderSessionsForModelSwitch(currentModel: Model, nextModel: Model | undefined): void {
 		const providerKeys = new Set<string>();
-		if (currentModel.api === "openai-codex-responses" || nextModel.api === "openai-codex-responses") {
+		if (currentModel.api === "openai-codex-responses" || nextModel?.api === "openai-codex-responses") {
 			providerKeys.add("openai-codex-responses");
 		}
 		if (currentModel.api === "openai-responses") {
 			providerKeys.add(`openai-responses:${currentModel.provider}`);
 		}
-		if (nextModel.api === "openai-responses") {
+		if (nextModel?.api === "openai-responses") {
 			providerKeys.add(`openai-responses:${nextModel.provider}`);
 		}
 
@@ -10369,18 +10472,24 @@ export class AgentSession {
 			attribution: "agent",
 			timestamp: incomingTimestamp,
 		};
-		void this.#emitSessionEvent({ type: "irc_message", message: incomingRecord });
-		this.#forwardIrcRelayToMain({
-			observationId: incomingObservationId,
-			from: args.from,
-			to: this.#agentId ?? "?",
-			body: args.message,
-			kind: "message",
-			timestamp: incomingTimestamp,
-		});
+		const announceIncoming = () => {
+			this.#emitIrcObservation(incomingRecord);
+			this.#forwardIrcRelayToMain({
+				observationId: incomingObservationId,
+				from: args.from,
+				to: this.#agentId ?? "?",
+				body: args.message,
+				kind: "message",
+				timestamp: incomingTimestamp,
+			});
+		};
 
 		if (!awaitReply) {
+			args.signal?.throwIfAborted();
+			// Volatile session acceptance happens before any recipient or main-UI
+			// observation, and before this delivery reports success to its sender.
 			this.#queueBackgroundExchangeInjection([incomingRecord]);
+			announceIncoming();
 			return { replyText: null };
 		}
 
@@ -10388,33 +10497,47 @@ export class AgentSession {
 			from: args.from,
 			message: args.message,
 		});
-		const { replyText } = await this.runEphemeralTurn({
+		// Generate the reply before accepting or surfacing the exchange. Provider
+		// failures and sender aborts therefore leave no accepted IRC batch or UI
+		// observation. The deferred roster claim is committed only after the pair
+		// below is accepted.
+		const { replyText, commitRosterClaim, releaseRosterClaim } = await this.runEphemeralTurn({
 			promptText: incomingPrompt,
 			signal: args.signal,
+			deferRosterCommit: true,
 		});
+		try {
+			const replyObservationId = crypto.randomUUID();
+			const replyRecord: CustomMessage = {
+				role: "custom",
+				customType: "irc:autoreply",
+				content: `[IRC you → \`${args.from}\` (auto)]\n\n${replyText}`,
+				display: true,
+				details: { observationId: replyObservationId, to: args.from, reply: replyText },
+				attribution: "agent",
+				timestamp: Date.now(),
+			};
+			// Accept the ordered pair as one volatile batch before committing its
+			// roster claim, notifying either UI, or resolving the sender delivery.
+			args.signal?.throwIfAborted();
+			this.#queueBackgroundExchangeInjection([incomingRecord, replyRecord], { deferFlush: true });
+			commitRosterClaim?.();
+			this.#flushOrSchedulePendingBackgroundExchanges();
+			announceIncoming();
+			this.#emitIrcObservation(replyRecord);
+			this.#forwardIrcRelayToMain({
+				observationId: replyObservationId,
+				from: this.#agentId ?? "?",
+				to: args.from,
+				body: replyText,
+				kind: "reply",
+				timestamp: replyRecord.timestamp,
+			});
 
-		const replyObservationId = crypto.randomUUID();
-		const replyRecord: CustomMessage = {
-			role: "custom",
-			customType: "irc:autoreply",
-			content: `[IRC you → \`${args.from}\` (auto)]\n\n${replyText}`,
-			display: true,
-			details: { observationId: replyObservationId, to: args.from, reply: replyText },
-			attribution: "agent",
-			timestamp: Date.now(),
-		};
-		void this.#emitSessionEvent({ type: "irc_message", message: replyRecord });
-		this.#forwardIrcRelayToMain({
-			observationId: replyObservationId,
-			from: this.#agentId ?? "?",
-			to: args.from,
-			body: replyText,
-			kind: "reply",
-			timestamp: replyRecord.timestamp,
-		});
-		this.#queueBackgroundExchangeInjection([incomingRecord, replyRecord]);
-
-		return { replyText };
+			return { replyText };
+		} finally {
+			releaseRosterClaim?.();
+		}
 	}
 
 	/**
@@ -10454,7 +10577,17 @@ export class AgentSession {
 			attribution: "agent",
 			timestamp: args.timestamp,
 		};
-		mainSession.emitIrcRelayObservation(relayRecord);
+		try {
+			mainSession.emitIrcRelayObservation(relayRecord);
+		} catch (error) {
+			logger.warn("Failed to forward IRC relay observation", { error: String(error) });
+		}
+	}
+
+	#emitIrcObservation(message: CustomMessage): void {
+		void this.#emitSessionEvent({ type: "irc_message", message }).catch(error => {
+			logger.warn("Failed to emit IRC observation", { error: String(error) });
+		});
 	}
 
 	/**
@@ -10462,7 +10595,7 @@ export class AgentSession {
 	 * Does not persist the record to history. Public so other sessions can forward.
 	 */
 	emitIrcRelayObservation(record: CustomMessage): void {
-		void this.#emitSessionEvent({ type: "irc_message", message: record });
+		this.#emitIrcObservation(record);
 	}
 
 	emitSubagentSteerObservation(args: { from: string; to: string; body: string; timestamp?: number }): void {
@@ -10592,8 +10725,16 @@ export class AgentSession {
 		promptText: string;
 		onTextDelta?: (delta: string) => void;
 		signal?: AbortSignal;
-	}): Promise<{ replyText: string; assistantMessage: AssistantMessage }> {
+		/** Defer the successful roster-claim commit until the caller accepts its exchange. */
+		deferRosterCommit?: boolean;
+	}): Promise<{
+		replyText: string;
+		assistantMessage: AssistantMessage;
+		commitRosterClaim?: () => void;
+		releaseRosterClaim?: () => void;
+	}> {
 		const rosterClaim = this.#claimIrcRosterCandidate();
+		let rosterClaimDeferred = false;
 		try {
 			const model = this.model;
 			if (!model) {
@@ -10662,12 +10803,31 @@ export class AgentSession {
 			if (!assistantMessage) {
 				throw new Error("Ephemeral turn ended without a final message");
 			}
+			if (rosterClaim && args.deferRosterCommit) {
+				rosterClaimDeferred = true;
+				let rosterClaimSettled = false;
+				const settleRosterClaim = (commit: boolean) => {
+					if (rosterClaimSettled) return;
+					rosterClaimSettled = true;
+					if (commit) {
+						this.#commitIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
+					} else {
+						this.#releaseIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
+					}
+				};
+				return {
+					replyText: dedupeIrcReply(replyText.trim()),
+					assistantMessage,
+					commitRosterClaim: () => settleRosterClaim(true),
+					releaseRosterClaim: () => settleRosterClaim(false),
+				};
+			}
 			if (rosterClaim) {
 				this.#commitIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
 			}
 			return { replyText: dedupeIrcReply(replyText.trim()), assistantMessage };
 		} finally {
-			if (rosterClaim) {
+			if (rosterClaim && !rosterClaimDeferred) {
 				this.#releaseIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
 			}
 		}
@@ -10720,8 +10880,12 @@ export class AgentSession {
 		return messages;
 	}
 
-	#queueBackgroundExchangeInjection(messages: CustomMessage[]): void {
+	#queueBackgroundExchangeInjection(messages: CustomMessage[], options?: { deferFlush?: boolean }): void {
 		this.#pendingBackgroundExchanges.push(messages);
+		if (!options?.deferFlush) this.#flushOrSchedulePendingBackgroundExchanges();
+	}
+
+	#flushOrSchedulePendingBackgroundExchanges(): void {
 		if (!this.isStreaming) {
 			this.#flushPendingBackgroundExchanges();
 			return;
@@ -11408,43 +11572,92 @@ export class AgentSession {
 		const contextWindow = model.contextWindow ?? 0;
 		if (contextWindow <= 0) return undefined;
 
+		const cacheKey = this.#contextUsageCacheKey(model, contextWindow);
+		if (this.#contextUsageCache?.key === cacheKey) return { ...this.#contextUsageCache.value };
+		this.#contextUsageEstimateCount++;
+
 		// After compaction, the last assistant usage reflects pre-compaction context size.
 		// We can only trust usage from an assistant that responded after the latest compaction.
 		// If no such assistant exists, context token count is unknown until the next LLM response.
 		const branchEntries = this.sessionManager.getBranch();
 		const latestCompaction = getLatestCompactionEntry(branchEntries);
+		const boundaryTs = latestCompaction ? new Date(latestCompaction.timestamp).getTime() : 0;
+		const anchor = this.#findAnchorableUsageIndex(this.messages, boundaryTs);
+		let value: ContextUsage;
+		if (latestCompaction && !anchor) {
+			value = { tokens: null, contextWindow, percent: null, source: "unknown" };
+		} else {
+			const estimate = this.#estimateContextTokens(boundaryTs, anchor);
+			value = {
+				tokens: estimate.tokens,
+				contextWindow,
+				percent: (estimate.tokens / contextWindow) * 100,
+				source: estimate.anchored ? "provider_anchor" : "heuristic",
+			};
+		}
 
-		if (latestCompaction) {
-			// Check if there's a valid assistant usage after the compaction boundary
-			const compactionIndex = branchEntries.lastIndexOf(latestCompaction);
-			let hasPostCompactionUsage = false;
-			for (let i = branchEntries.length - 1; i > compactionIndex; i--) {
-				const entry = branchEntries[i];
-				if (entry.type === "message" && entry.message.role === "assistant") {
-					const assistant = entry.message;
-					if (assistant.stopReason !== "aborted" && assistant.stopReason !== "error") {
-						const contextTokens = calculateContextTokens(assistant.usage);
-						if (contextTokens > 0) {
-							hasPostCompactionUsage = true;
-						}
-						break;
-					}
-				}
-			}
+		this.#contextUsageCache = { key: cacheKey, value };
+		return { ...value };
+	}
+
+	getContextUsageObservabilityForTests(): { estimateCount: number } {
+		return { estimateCount: this.#contextUsageEstimateCount };
+	}
+
+	#contextUsageCacheKey(model: Model, contextWindow: number): string {
+		const messages = this.messages;
+		const lastMessage = messages[messages.length - 1];
+		// Entry and leaf revisions change whenever the active branch changes, avoiding getBranch() on warm reads.
+		const revision = this.sessionManager.revisionSnapshot();
+		return `${this.agent.contextRevision}|${model.id}|${contextWindow}|${messages.length}|${this.#contextUsageMessageFingerprint(lastMessage)}|${revision.entry}:${revision.leaf}|${this.#computeContextUsageNonMessageInputsKey()}`;
+	}
+
+	#contextUsageMessageFingerprint(message: AgentMessage | undefined): string {
+		if (!message) return "";
+		let messageId = this.#contextUsageMessageIds.get(message);
+		if (messageId === undefined) {
+			messageId = ++this.#nextContextUsageMessageId;
+			this.#contextUsageMessageIds.set(message, messageId);
+		}
+
+		const role = message.role;
+		const timestamp = typeof message.timestamp === "number" ? message.timestamp : "";
+		let contentLength = 0;
+		let blockCount = 0;
+		const record = message as {
+			content?: unknown;
+			command?: unknown;
+			output?: unknown;
+			summary?: unknown;
+			stopReason?: unknown;
+			usage?: Usage;
+		};
 
-			if (!hasPostCompactionUsage) {
-				return { tokens: null, contextWindow, percent: null };
+		if (typeof record.command === "string") contentLength += record.command.length;
+		if (typeof record.output === "string") contentLength += record.output.length;
+		if (typeof record.summary === "string") contentLength += record.summary.length;
+		if (typeof record.content === "string") {
+			contentLength += record.content.length;
+		} else if (Array.isArray(record.content)) {
+			blockCount = record.content.length;
+			for (const block of record.content) {
+				if (!block || typeof block !== "object") continue;
+				const content = block as { text?: unknown; thinking?: unknown; name?: unknown };
+				if (typeof content.text === "string") contentLength += content.text.length;
+				if (typeof content.thinking === "string") contentLength += content.thinking.length;
+				if (typeof content.name === "string") contentLength += content.name.length;
 			}
 		}
+		const stopReason = typeof record.stopReason === "string" ? record.stopReason : "";
+		const usageTokens = record.usage ? calculateContextTokens(record.usage) : 0;
+		return `${messageId}:${role}:${timestamp}:${contentLength}:${blockCount}:${stopReason}:${usageTokens}`;
+	}
 
-		const estimate = this.#estimateContextTokens();
-		const percent = (estimate.tokens / contextWindow) * 100;
-
-		return {
-			tokens: estimate.tokens,
-			contextWindow,
-			percent,
-		};
+	#computeContextUsageNonMessageInputsKey(): string {
+		const systemPrompt = this.systemPrompt;
+		let systemPromptLengths = "";
+		for (const part of systemPrompt) systemPromptLengths += `${part.length},`;
+		return `${systemPrompt.length}:${systemPromptLengths}|${this.agent.state.tools.length}|${this.skills.length}`;
 	}
 
 	async fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null> {
@@ -11459,10 +11672,19 @@ export class AgentSession {
 	/**
 	 * Estimate context tokens from messages, using the last assistant usage when available.
 	 */
-	#estimateContextTokens(): {
+	#estimateContextTokens(
+		boundaryTs: number,
+		anchor: { index: number; usage: Usage } | undefined,
+	): {
 		tokens: number;
+		anchored: boolean;
 	} {
-		return this.#estimateContextTokensWith(message => this.#estimateMessageDisplayTokens(message));
+		return this.#estimateContextTokensWith(
+			message => this.#estimateMessageDisplayTokens(message),
+			false,
+			boundaryTs,
+			anchor,
+		);
 	}
 
 	/** Count inline image blocks in a message (for bucketing the fixed image token estimate). */
@@ -11493,6 +11715,24 @@ export class AgentSession {
 		return usage;
 	}
 
+	/** Find the newest positive successful usage anchor after a compaction boundary. */
+	#findAnchorableUsageIndex(
+		messages: readonly AgentMessage[],
+		boundaryTs: number,
+	): { index: number; usage: Usage } | undefined {
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const message = messages[i];
+			const usage = this.#anchorableAssistantUsage(message);
+			if (!usage) continue;
+			if (boundaryTs > 0) {
+				const timestamp = message.timestamp;
+				if (typeof timestamp !== "number" || !Number.isFinite(timestamp) || timestamp <= boundaryTs) continue;
+			}
+			return { index: i, usage };
+		}
+		return undefined;
+	}
+
 	/**
 	 * Observed heuristic→actual token correction for the compaction keep window
 	 * (Finding 7). Compares the provider's real prompt tokens against the chars/4
@@ -11537,39 +11777,45 @@ export class AgentSession {
 
 	#estimateContextTokensForCompaction(pendingMessages: readonly AgentMessage[]): {
 		tokens: number;
+		anchored: boolean;
 	} {
-		const estimate = this.#estimateContextTokensWith(message => this.#estimateMessageCompactionDeltaTokens(message));
+		const estimate = this.#estimateContextTokensWith(
+			message => this.#estimateMessageCompactionDeltaTokens(message),
+			true,
+		);
 		return {
 			tokens: estimate.tokens + this.#estimateMessagesCompactionDeltaTokens(pendingMessages),
+			anchored: estimate.anchored,
 		};
 	}
 
-	#estimateContextTokensWith(estimateMessage: (message: AgentMessage) => number): {
+	#estimateContextTokensWith(
+		estimateMessage: (message: AgentMessage) => number,
+		inflateFixed = false,
+		boundaryTs?: number,
+		knownAnchor?: { index: number; usage: Usage } | undefined,
+	): {
 		tokens: number;
+		anchored: boolean;
 	} {
 		const messages = this.messages;
-
-		// Find the last successful assistant message with positive usage.
-		// Error/aborted turns are estimated as trailing context instead.
-		let lastUsageIndex: number | null = null;
-		let lastUsage: Usage | undefined;
-		for (let i = messages.length - 1; i >= 0; i--) {
-			const usage = this.#anchorableAssistantUsage(messages[i]);
-			if (usage) {
-				lastUsage = usage;
-				lastUsageIndex = i;
-				break;
-			}
+		let anchor = knownAnchor;
+		if (boundaryTs === undefined) {
+			const latestCompaction = getLatestCompactionEntry(this.sessionManager.getBranch());
+			boundaryTs = latestCompaction ? new Date(latestCompaction.timestamp).getTime() : 0;
+			anchor = this.#findAnchorableUsageIndex(messages, boundaryTs);
 		}
 
-		if (!lastUsage || lastUsageIndex === null) {
-			// No usage data - estimate all messages
-			let estimated = 0;
+		if (!anchor) {
+			// No usage data - estimate the full provider request.
+			const fixedTokens = computeNonMessageTokens(this);
+			let estimated = inflateFixed ? Math.ceil(fixedTokens * this.#compactionDeltaInflation) : fixedTokens;
 			for (const message of messages) {
 				estimated += estimateMessage(message);
 			}
 			return {
 				tokens: estimated,
+				anchored: false,
 			};
 		}
 
@@ -11577,14 +11823,15 @@ export class AgentSession {
 		// tokens: the next request replays the anchor assistant's own output
 		// (text/reasoning/tool calls), so dropping it undercounts the very tokens
 		// a large-reasoning turn just added (Sol xhigh emits tens of thousands).
-		const usageTokens = calculateContextTokens(lastUsage);
+		const usageTokens = calculateContextTokens(anchor.usage);
 		let trailingTokens = 0;
-		for (let i = lastUsageIndex + 1; i < messages.length; i++) {
+		for (let i = anchor.index + 1; i < messages.length; i++) {
 			trailingTokens += estimateMessage(messages[i]);
 		}
 
 		return {
 			tokens: usageTokens + trailingTokens,
+			anchored: true,
 		};
 	}