@sayknow-cli/coding-agent 0.3.12 → 0.3.15

package/src/session/agent-session.ts

@@ -27,6 +27,8 @@ import {
 	type AgentState,
 	type AgentTool,
 	assertImagePlaceholdersHavePayload,
+	canContinuePersistedHistory,
+	type ResolvedThinkingLevel,
 	resolveTelemetry,
 	type StablePrefixSnapshot,
 	ThinkingLevel,
@@ -205,6 +207,7 @@ import type { PlanModeState } from "../plan-mode/state";
 import autoContinuePrompt from "../prompts/system/auto-continue.md" with { type: "text" };
 import eagerTodoPrompt from "../prompts/system/eager-todo.md" with { type: "text" };
 import ircIncomingTemplate from "../prompts/system/irc-incoming.md" with { type: "text" };
+import ircPeerRosterTemplate from "../prompts/system/irc-peer-roster.md" with { type: "text" };
 import planModeActivePrompt from "../prompts/system/plan-mode-active.md" with { type: "text" };
 import planModeReferencePrompt from "../prompts/system/plan-mode-reference.md" with { type: "text" };
 import planModeToolDecisionReminderPrompt from "../prompts/system/plan-mode-tool-decision-reminder.md" with {
@@ -254,7 +257,10 @@ import {
 } from "../tool-discovery/tool-index";
 import type { AskAnswerSource, ToolSession } from "../tools";
 import { AskTool } from "../tools/ask";
-import { getAskAnswerSource as getAskAnswerSourceFromRegistry } from "../tools/ask-answer-registry";
+import {
+	getAskAnswerSource as getAskAnswerSourceFromRegistry,
+	notifyWorkflowGateEmitterChanged,
+} from "../tools/ask-answer-registry";
 import { assertEditableFile } from "../tools/auto-generated-guard";
 import { releaseTabsForOwner } from "../tools/browser/tab-supervisor";
 import type { CheckpointState } from "../tools/checkpoint";
@@ -274,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,
@@ -291,6 +298,7 @@ import {
 	SILENT_ABORT_MARKER,
 	SKILL_PROMPT_MESSAGE_TYPE,
 } from "./messages";
+import { isLegacyProviderSafetyStopMessage } from "./provider-safety-stop";
 import { formatSessionDumpText } from "./session-dump-format";
 import type {
 	BranchSummaryEntry,
@@ -298,8 +306,13 @@ import type {
 	NewSessionOptions,
 	SessionContext,
 	SessionManager,
+	SessionManagerCloseOutcome,
+} from "./session-manager";
+import {
+	getLatestCompactionEntry,
+	getSessionMessageObservationId,
+	transferSessionMessageIdentity,
 } from "./session-manager";
-import { getLatestCompactionEntry } from "./session-manager";
 import { ToolChoiceQueue } from "./tool-choice-queue";
 import { YieldQueue } from "./yield-queue";
 
@@ -520,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;
@@ -538,6 +557,7 @@ export interface SessionStats {
 	};
 	premiumRequests: number;
 	cost: number;
+	costBreakdown?: Usage["cost"];
 }
 
 /** Internal marker for hook messages queued through the agent loop */
@@ -1169,6 +1189,7 @@ export class AgentSession {
 	#scopedModels: ScopedModelSelection[];
 	#thinkingLevel: ThinkingLevel | undefined;
 	#activeModelProfile: string | undefined;
+	#defaultModelSelectionTail: Promise<void> = Promise.resolve();
 	#promptTemplates: PromptTemplate[];
 	#slashCommands: FileSlashCommand[];
 
@@ -1221,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;
@@ -1270,6 +1296,9 @@ export class AgentSession {
 	// Agent identity + registry for IRC relay forwarding to the main session UI.
 	#agentId: string | undefined;
 	#agentRegistry: AgentRegistry | undefined;
+	#lastDeliveredIrcRosterSignature: string | null = null;
+	#ircRosterEpoch = 0;
+	#ircRosterClaim: { token: symbol; signature: string; epoch: number } | null = null;
 	#providerSessionId: string | undefined;
 	#providerCacheSessionId: string | undefined;
 	#isDisposed = false;
@@ -2086,6 +2115,16 @@ export class AgentSession {
 		return queued;
 	}
 
+	#persistRuntimeStateInBackground(event: AgentSessionEvent): void {
+		void persistCoordinatorRuntimeStateFromEvent(event, {
+			sessionId: this.sessionId,
+			cwd: this.sessionManager.getCwd(),
+			sessionFile: this.sessionManager.getSessionFile(),
+		}).catch(() => {
+			logger.warn("Failed to persist coordinator runtime state", { event: event.type });
+		});
+	}
+
 	async #emitSessionEvent(event: AgentSessionEvent): Promise<void> {
 		if (event.type === "message_update") {
 			// Fast path: message_update maps to no sidecar state, so we must not
@@ -2097,12 +2136,7 @@ export class AgentSession {
 			}
 			return;
 		}
-		const persistRuntimeState = () =>
-			persistCoordinatorRuntimeStateFromEvent(event, {
-				sessionId: this.sessionId,
-				cwd: this.sessionManager.getCwd(),
-				sessionFile: this.sessionManager.getSessionFile(),
-			});
+		const persistRuntimeState = () => this.#persistRuntimeStateInBackground(event);
 		// Hold the wire-level agent_end until in-flight prompts unwind. Subscribers
 		// (rpc-mode, ACP, Cursor) treat agent_end as the "session is idle" signal;
 		// emitting while #promptInFlightCount > 0 lets a client fire its next
@@ -2190,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;
 		}
@@ -2205,7 +2240,9 @@ export class AgentSession {
 			const message = event.message;
 			const deobfuscatedContent = obfuscator.deobfuscateObject(message.content);
 			if (deobfuscatedContent !== message.content) {
-				displayEvent = { ...event, message: { ...message, content: deobfuscatedContent } };
+				const displayMessage = { ...message, content: deobfuscatedContent };
+				transferSessionMessageIdentity([message], [displayMessage]);
+				displayEvent = { ...event, message: displayMessage };
 			}
 		}
 
@@ -2220,6 +2257,15 @@ export class AgentSession {
 		}
 
 		await this.#emitSessionEvent(displayEvent);
+		if (
+			displayEvent !== event &&
+			displayEvent.type === "message_end" &&
+			displayEvent.message.role === "assistant" &&
+			event.type === "message_end" &&
+			event.message.role === "assistant"
+		) {
+			transferSessionMessageIdentity([displayEvent.message], [event.message]);
+		}
 
 		if (event.type === "turn_start") {
 			this.#resetStreamingEditState();
@@ -2389,14 +2435,20 @@ export class AgentSession {
 		if (event.type === "message_end") {
 			// Check if this is a hook/custom message
 			if (event.message.role === "hookMessage" || event.message.role === "custom") {
-				// Persist as CustomMessageEntry
-				this.sessionManager.appendCustomMessageEntry(
-					event.message.customType,
-					event.message.content,
-					event.message.display,
-					event.message.details,
-					event.message.attribution ?? "agent",
-				);
+				// Roster reminders are request-context-only: never persist them, or a
+				// reload would resurrect stale rosters into agent history.
+				const isRosterReminder = event.message.role === "custom" && event.message.customType === "irc-peer-roster";
+				if (!isRosterReminder) {
+					// Persist as CustomMessageEntry
+					this.sessionManager.appendCustomMessageEntry(
+						event.message.customType,
+						event.message.content,
+						event.message.display,
+						event.message.details,
+						event.message.attribution ?? "agent",
+						getSessionMessageObservationId(event.message),
+					);
+				}
 				if (event.message.role === "custom" && event.message.customType === "ttsr-injection") {
 					this.#markTtsrInjected(this.#extractTtsrRuleNames(event.message.details));
 				}
@@ -2761,8 +2813,7 @@ export class AgentSession {
 	}
 
 	#isResumableAgentTail(): boolean {
-		const lastMsg = this.agent.state.messages.at(-1);
-		return lastMsg !== undefined && lastMsg.role !== "assistant";
+		return canContinuePersistedHistory(this.agent.state.messages);
 	}
 
 	#stripOverflowFailedTurnForRetry(): void {
@@ -3765,6 +3816,8 @@ export class AgentSession {
 		} catch (error) {
 			logger.warn("Failed to emit session_shutdown event", { error: String(error) });
 		}
+		this.#workflowGateEmitter = undefined;
+		notifyWorkflowGateEmitterChanged(this.sessionId, undefined);
 		await this.#flushWorkerIntegrationAttempt();
 		await this.#cancelPostPromptTasks();
 		// Cancel jobs this agent registered so a subagent's teardown doesn't
@@ -3828,6 +3881,18 @@ export class AgentSession {
 		this.#eventListeners = [];
 		this.#rebuildEventListenerSnapshot();
 	}
+	/**
+	 * Strict writer close for ACP session delete. On the first attempt it flushes
+	 * pending writes, then returns the certainty-aware close outcome so the caller
+	 * can block destructive mutation on a non-`closed` result. When the manager
+	 * retains a retryable writer (a prior `close_failed_retryable`), the flush is
+	 * NOT repeated: the underlying writer rejects flushes while in the retryable
+	 * state, and `SessionManager.closeStrict()` owns the flush/close sequencing so
+	 * a second call can return `closed` once the OS close lands.
+	 */
+	async closeWriterStrict(): Promise<SessionManagerCloseOutcome> {
+		return this.sessionManager.flushAndCloseStrict();
+	}
 
 	/**
 	 * Bounded, best-effort teardown of the subprocess-spawning resources this session
@@ -3928,6 +3993,20 @@ export class AgentSession {
 		}
 	}
 
+	/**
+	 * Owner-scoped async-delivery snapshot used by the strict ACP delete
+	 * quiescence barrier to PROVE quiescence after a best-effort drain. Unlike
+	 * {@link drainAsyncJobDeliveriesForAcp}'s boolean return (which conflates
+	 * "nothing to drain" with "timed out"), this reads the live state directly so
+	 * any remaining queued/delivering work is observable and can block mutation.
+	 */
+	getAsyncDeliveryStateForAcp(): { queued: number; delivering: boolean } {
+		const manager = AsyncJobManager.instance();
+		if (!manager) return { queued: 0, delivering: false };
+		const ownerFilter = this.#agentId ? { ownerId: this.#agentId } : undefined;
+		return manager.getDeliveryState(ownerFilter);
+	}
+
 	/** Most recent assistant message in agent state. */
 	getLastAssistantMessage(): AssistantMessage | undefined {
 		return this.#findLastAssistantMessage();
@@ -4895,6 +4974,14 @@ export class AgentSession {
 		return this.agent.state.messages;
 	}
 
+	/** Main startup calls this exactly once, after a strict open returned `kind: "opened"`. */
+	async continuePersistedHistory(): Promise<void> {
+		if (!canContinuePersistedHistory(this.agent.state.messages)) {
+			throw new Error("Cannot continue from persisted message history");
+		}
+		await this.agent.continue();
+	}
+
 	buildDisplaySessionContext(): SessionContext {
 		return deobfuscateSessionContext(this.sessionManager.buildSessionContext(), this.#obfuscator);
 	}
@@ -5029,6 +5116,7 @@ export class AgentSession {
 
 	setWorkflowGateEmitter(emitter: WorkflowGateEmitter | undefined): void {
 		this.#workflowGateEmitter = emitter;
+		notifyWorkflowGateEmitterChanged(this.sessionId, emitter);
 		if (emitter) {
 			this.#ensureWorkflowGateAskTool();
 		}
@@ -5576,6 +5664,7 @@ export class AgentSession {
 	): Promise<void> {
 		this.#beginInFlight();
 		const generation = this.#promptGeneration;
+		const rosterClaim = this.#claimIrcRosterCandidate();
 		try {
 			// Flush any pending bash messages before the new prompt
 			this.#flushPendingBashMessages();
@@ -5627,6 +5716,11 @@ export class AgentSession {
 			}
 			const volatileProjectContextMessage = await this.#buildVolatileProjectContextMessage();
 			messages.push(volatileProjectContextMessage);
+			if (rosterClaim && this.#isCurrentIrcRosterClaim(rosterClaim.token, rosterClaim.epoch)) {
+				messages.push(rosterClaim.message);
+			} else if (rosterClaim) {
+				this.#releaseIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
+			}
 			if (options?.prependMessages) {
 				messages.push(...options.prependMessages);
 			}
@@ -5731,10 +5825,27 @@ export class AgentSession {
 
 			const agentPromptOptions = options?.toolChoice ? { toolChoice: options.toolChoice } : undefined;
 			await this.#promptAgentWithIdleRetry(messages, agentPromptOptions);
+			const terminalAssistant = this.#findLastAssistantMessage();
+			if (
+				rosterClaim &&
+				terminalAssistant &&
+				terminalAssistant.stopReason !== "error" &&
+				terminalAssistant.stopReason !== "aborted"
+			) {
+				this.#commitIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
+			}
 			if (!options?.skipPostPromptRecoveryWait) {
 				await this.#waitForPostPromptRecovery();
 			}
 		} finally {
+			if (rosterClaim) {
+				this.agent.replaceMessages(
+					this.agent.state.messages.filter(
+						candidate => !(candidate.role === "custom" && candidate.customType === "irc-peer-roster"),
+					),
+				);
+				this.#releaseIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
+			}
 			this.#endInFlight();
 		}
 	}
@@ -5825,7 +5936,7 @@ export class AgentSession {
 			reload: async () => {
 				await this.reload();
 			},
-			getSystemPrompt: () => this.systemPrompt,
+			getSystemPrompt: () => [...this.systemPrompt],
 		};
 	}
 
@@ -6162,6 +6273,7 @@ export class AgentSession {
 				message.display,
 				message.details,
 				message.attribution ?? "agent",
+				getSessionMessageObservationId(appMessage),
 			);
 			return;
 		}
@@ -6189,6 +6301,7 @@ export class AgentSession {
 			message.display,
 			message.details,
 			message.attribution ?? "agent",
+			getSessionMessageObservationId(appMessage),
 		);
 	}
 
@@ -6662,6 +6775,8 @@ export class AgentSession {
 		this.#planReferencePath = "local://PLAN.md";
 		this.#reconnectToAgent();
 
+		this.#resetIrcRosterDeliveryState();
+
 		// Emit session_switch event with reason "new" to hooks
 		if (this.#extensionRunner) {
 			await this.#extensionRunner.emit({
@@ -6769,6 +6884,8 @@ export class AgentSession {
 		this.#syncAgentSessionId();
 		this.#rekeyHindsightMemoryForCurrentSessionId();
 
+		this.#resetIrcRosterDeliveryState();
+
 		// Emit session_switch event with reason "fork" to hooks
 		if (this.#extensionRunner) {
 			await this.#extensionRunner.emit({
@@ -6884,6 +7001,54 @@ 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.settings.setGlobalModelRoleAndFlush(
+				"default",
+				formatModelSelectorValue(`${model.provider}/${model.id}`, effectiveLevel),
+			);
+			try {
+				const previousThinkingLevel = this.thinkingLevel;
+				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),
+					});
+				});
+				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.
@@ -7708,6 +7873,8 @@ export class AgentSession {
 			this.#resetInjectedContextSignatures();
 			this.#syncTodoPhasesFromBranch();
 
+			this.#resetIrcRosterDeliveryState();
+
 			return { document: handoffText, savedPath };
 		} catch (error) {
 			if (handoffSignal.aborted || (error instanceof Error && error.name === "AbortError")) {
@@ -7746,6 +7913,14 @@ export class AgentSession {
 	 * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
 	 */
 	async #checkCompaction(assistantMessage: AssistantMessage, skipAbortedCheck = true): Promise<void> {
+		// Safety stops are terminal and must not trigger context maintenance.
+		if (
+			assistantMessage.errorKind === "provider_safety_stop" ||
+			(assistantMessage.errorMessage !== undefined &&
+				isLegacyProviderSafetyStopMessage(assistantMessage.errorMessage))
+		) {
+			return;
+		}
 		// Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
 		if (skipAbortedCheck && assistantMessage.stopReason === "aborted") return;
 		const contextWindow = this.model?.contextWindow ?? 0;
@@ -9266,16 +9441,6 @@ export class AgentSession {
 		);
 	}
 
-	#isRefusalErrorMessage(errorMessage: string): boolean {
-		// Provider safety-refusal stops. Matches the engine-generated Anthropic
-		// labels from packages/ai ("Refusal (<category>): …", "Refusal (no
-		// details provided)", "Content flagged by safety filters") plus generic
-		// usage-policy refusal copy.
-		return /^refusal(\s*\(|:|$)|content flagged by safety filters|blocked under .{0,40}usage policy/i.test(
-			errorMessage,
-		);
-	}
-
 	#extractExplicitHttpStatusFromErrorMessage(errorMessage: string): number | undefined {
 		// Parse only explicit HTTP/status wording. Do not treat generic
 		// `error: 400` as an HTTP status because rate-limit copy can say
@@ -9287,14 +9452,15 @@ export class AgentSession {
 	}
 
 	/**
-	 * Ordered retry classification: overflow (compaction) -> terminal (surface)
-	 * -> usage_limit (rotation) -> first_event_timeout (bounded retry) ->
-	 * transient (retry) -> unknown (retry).
+	 * Ordered retry classification: typed safety stop (surface) -> legacy safety stop
+	 * (surface) -> overflow (compaction) -> terminal (surface) -> usage_limit
+	 * (rotation) -> first_event_timeout (bounded retry) -> transient (retry) ->
+	 * unknown (retry).
 	 */
 	#classifyErrorForRetry(message: AssistantMessage): RetryErrorClassification {
-		if (message.stopReason !== "error" || !message.errorMessage) return "none";
-		const contextWindow = this.model?.contextWindow ?? 0;
-		if (isContextOverflow(message, contextWindow)) return "overflow";
+		if (message.stopReason !== "error") return "none";
+		if (message.errorKind === "provider_safety_stop") return "terminal";
+		if (!message.errorMessage) return "none";
 		const err = message.errorMessage;
 		// Provider safety refusals (e.g. Anthropic stop_reason "refusal" /
 		// "sensitive") are deterministic for the submitted context: replaying
@@ -9302,7 +9468,9 @@ export class AgentSession {
 		// auto-retry loop can never succeed and only re-bills the full context
 		// on every attempt (#1655). Surface immediately instead of joining the
 		// unbounded "unknown" retry class.
-		if (this.#isRefusalErrorMessage(err)) return "terminal";
+		if (isLegacyProviderSafetyStopMessage(err)) return "terminal";
+		const contextWindow = this.model?.contextWindow ?? 0;
+		if (isContextOverflow(message, contextWindow)) return "overflow";
 		if (isLocalModelEndpoint(this.model) && this.#isLocalProviderAvailabilityErrorMessage(err)) {
 			return "local_unavailable";
 		}
@@ -10254,26 +10422,34 @@ export class AgentSession {
 	}): Promise<{ replyText: string | null }> {
 		const awaitReply = args.awaitReply !== false;
 		const incomingTimestamp = Date.now();
+		const incomingObservationId = crypto.randomUUID();
 		const incomingRecord: CustomMessage = {
 			role: "custom",
 			customType: "irc:incoming",
 			content: `[IRC \`${args.from}\` → you]\n\n${args.message}`,
 			display: true,
-			details: { from: args.from, message: args.message },
+			details: { observationId: incomingObservationId, from: args.from, message: args.message },
 			attribution: "agent",
 			timestamp: incomingTimestamp,
 		};
-		void this.#emitSessionEvent({ type: "irc_message", message: incomingRecord });
-		this.#forwardIrcRelayToMain({
-			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 };
 		}
 
@@ -10281,31 +10457,46 @@ 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]);
+			commitRosterClaim?.();
+			announceIncoming();
+			this.#emitIrcObservation(replyRecord);
+			this.#forwardIrcRelayToMain({
+				observationId: replyObservationId,
+				from: this.#agentId ?? "?",
+				to: args.from,
+				body: replyText,
+				kind: "reply",
+				timestamp: replyRecord.timestamp,
+			});
 
-		const replyRecord: CustomMessage = {
-			role: "custom",
-			customType: "irc:autoreply",
-			content: `[IRC you → \`${args.from}\` (auto)]\n\n${replyText}`,
-			display: true,
-			details: { to: args.from, reply: replyText },
-			attribution: "agent",
-			timestamp: Date.now(),
-		};
-		void this.#emitSessionEvent({ type: "irc_message", message: replyRecord });
-		this.#forwardIrcRelayToMain({
-			from: this.#agentId ?? "?",
-			to: args.from,
-			body: replyText,
-			kind: "reply",
-			timestamp: replyRecord.timestamp,
-		});
-		this.#queueBackgroundExchangeInjection([incomingRecord, replyRecord]);
-
-		return { replyText };
+			return { replyText };
+		} finally {
+			releaseRosterClaim?.();
+		}
 	}
 
 	/**
@@ -10315,6 +10506,7 @@ export class AgentSession {
 	 * it is NOT injected into the main agent's persisted history.
 	 */
 	#forwardIrcRelayToMain(args: {
+		observationId: string;
 		from: string;
 		to: string;
 		body: string;
@@ -10334,11 +10526,27 @@ export class AgentSession {
 			customType: "irc:relay",
 			content: `[IRC \`${args.from}\` ${arrow} \`${args.to}\`]\n\n${args.body}`,
 			display: true,
-			details: { from: args.from, to: args.to, body: args.body, kind: args.kind },
+			details: {
+				observationId: args.observationId,
+				from: args.from,
+				to: args.to,
+				body: args.body,
+				kind: args.kind,
+			},
 			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) });
+		});
 	}
 
 	/**
@@ -10346,7 +10554,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 {
@@ -10406,6 +10614,61 @@ export class AgentSession {
 		void this.#emitSessionEvent({ type: "subagent_steer_message", message: record });
 	}
 
+	#buildIrcRosterCandidate(): { signature: string; message: CustomMessage } | null {
+		const peers = (this.#agentRegistry?.listVisibleTo(this.#agentId ?? "") ?? [])
+			.map(peer => ({ id: peer.id, label: peer.rosterLabel || peer.displayName }))
+			.sort((left, right) => left.id.localeCompare(right.id));
+		const signature = JSON.stringify(peers);
+		if (peers.length === 0 && this.#lastDeliveredIrcRosterSignature === null) return null;
+		return {
+			signature,
+			message: {
+				role: "custom",
+				customType: "irc-peer-roster",
+				content: prompt.render(ircPeerRosterTemplate, {
+					roster: peers.map(peer => `${peer.id} (${peer.label})`).join(", "),
+				}),
+				display: false,
+				attribution: "agent",
+				timestamp: Date.now(),
+			},
+		};
+	}
+
+	#claimIrcRosterCandidate(): { token: symbol; epoch: number; message: CustomMessage } | null {
+		if (this.#ircRosterClaim) return null;
+		const candidate = this.#buildIrcRosterCandidate();
+		if (!candidate || candidate.signature === this.#lastDeliveredIrcRosterSignature) return null;
+		const token = Symbol("irc-roster");
+		const epoch = this.#ircRosterEpoch;
+		this.#ircRosterClaim = { token, signature: candidate.signature, epoch };
+		return { token, epoch, message: candidate.message };
+	}
+
+	#isCurrentIrcRosterClaim(token: symbol, epoch: number): boolean {
+		return this.#ircRosterEpoch === epoch && this.#ircRosterClaim?.token === token;
+	}
+
+	#commitIrcRosterClaim(token: symbol, epoch: number): void {
+		const claim = this.#ircRosterClaim;
+		if (this.#ircRosterEpoch !== epoch || claim?.token !== token) {
+			this.#releaseIrcRosterClaim(token, epoch);
+			return;
+		}
+		this.#lastDeliveredIrcRosterSignature = claim.signature;
+		this.#ircRosterClaim = null;
+	}
+
+	#releaseIrcRosterClaim(token: symbol, epoch: number): void {
+		if (this.#isCurrentIrcRosterClaim(token, epoch)) this.#ircRosterClaim = null;
+	}
+
+	#resetIrcRosterDeliveryState(): void {
+		this.#ircRosterEpoch += 1;
+		this.#lastDeliveredIrcRosterSignature = null;
+		this.#ircRosterClaim = null;
+	}
+
 	/**
 	 * Run a single ephemeral side-channel turn against this session's current
 	 * model + system prompt + history.  No tools are used; the side request
@@ -10421,62 +10684,112 @@ export class AgentSession {
 		promptText: string;
 		onTextDelta?: (delta: string) => void;
 		signal?: AbortSignal;
-	}): Promise<{ replyText: string; assistantMessage: AssistantMessage }> {
-		const model = this.model;
-		if (!model) {
-			throw new Error("No active model on session");
-		}
-		const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
-		if (!apiKey) {
-			throw new Error(`No API key for ${model.provider}/${model.id}`);
-		}
+		/** 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) {
+				throw new Error("No active model on session");
+			}
+			const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
+			if (!apiKey) {
+				throw new Error(`No API key for ${model.provider}/${model.id}`);
+			}
+
+			const rosterMessage =
+				rosterClaim && this.#isCurrentIrcRosterClaim(rosterClaim.token, rosterClaim.epoch)
+					? rosterClaim.message
+					: undefined;
+			if (rosterClaim && !rosterMessage) {
+				this.#releaseIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
+			}
+			let snapshot = this.#buildEphemeralSnapshot(args.promptText, rosterMessage ? [rosterMessage] : undefined);
+			let llmMessages = await this.convertMessagesToLlm(snapshot, args.signal);
+			if (rosterMessage && !this.#isCurrentIrcRosterClaim(rosterClaim!.token, rosterClaim!.epoch)) {
+				this.#releaseIrcRosterClaim(rosterClaim!.token, rosterClaim!.epoch);
+				// Conversion is asynchronous, so rebuild without a claim invalidated while it awaited.
+				snapshot = this.#buildEphemeralSnapshot(args.promptText);
+				llmMessages = await this.convertMessagesToLlm(snapshot, args.signal);
+			}
+			const context: Context = {
+				systemPrompt: this.systemPrompt,
+				messages: llmMessages,
+				// Empty tools array: with toolChoice="none" some encoders still serialize the
+				// recipient's tool catalog and the model leaks raw call markup
+				// (<function_calls>, DSML envelopes) into IRC replies. Stripping tools here
+				// removes the surface entirely.
+				tools: [],
+			};
+			const options = this.prepareSimpleStreamOptions(
+				{
+					apiKey,
+					sessionId: this.sessionId,
+					reasoning: toReasoningEffort(this.thinkingLevel),
+					hideThinkingSummary: this.agent.hideThinkingSummary,
+					serviceTier: this.serviceTier,
+					signal: args.signal,
+					toolChoice: "none",
+				},
+				model.provider,
+			);
 
-		const snapshot = this.#buildEphemeralSnapshot(args.promptText);
-		const llmMessages = await this.convertMessagesToLlm(snapshot, args.signal);
-		const context: Context = {
-			systemPrompt: this.systemPrompt,
-			messages: llmMessages,
-			// Empty tools array: with toolChoice="none" some encoders still serialize the
-			// recipient's tool catalog and the model leaks raw call markup
-			// (<function_calls>, DSML envelopes) into IRC replies. Stripping tools here
-			// removes the surface entirely.
-			tools: [],
-		};
-		const options = this.prepareSimpleStreamOptions(
-			{
-				apiKey,
-				sessionId: this.sessionId,
-				reasoning: toReasoningEffort(this.thinkingLevel),
-				hideThinkingSummary: this.agent.hideThinkingSummary,
-				serviceTier: this.serviceTier,
-				signal: args.signal,
-				toolChoice: "none",
-			},
-			model.provider,
-		);
+			let replyText = "";
+			let assistantMessage: AssistantMessage | undefined;
+			const stream = streamSimple(model, context, options);
+			for await (const event of stream) {
+				if (event.type === "text_delta") {
+					replyText += event.delta;
+					if (args.onTextDelta) args.onTextDelta(event.delta);
+					continue;
+				}
+				if (event.type === "done") {
+					assistantMessage = event.message;
+					break;
+				}
+				if (event.type === "error") {
+					throw new Error(event.error.errorMessage || "Ephemeral turn failed");
+				}
+			}
 
-		let replyText = "";
-		let assistantMessage: AssistantMessage | undefined;
-		const stream = streamSimple(model, context, options);
-		for await (const event of stream) {
-			if (event.type === "text_delta") {
-				replyText += event.delta;
-				if (args.onTextDelta) args.onTextDelta(event.delta);
-				continue;
+			if (!assistantMessage) {
+				throw new Error("Ephemeral turn ended without a final message");
 			}
-			if (event.type === "done") {
-				assistantMessage = event.message;
-				break;
+			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 (event.type === "error") {
-				throw new Error(event.error.errorMessage || "Ephemeral turn failed");
+			if (rosterClaim) {
+				this.#commitIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
+			}
+			return { replyText: dedupeIrcReply(replyText.trim()), assistantMessage };
+		} finally {
+			if (rosterClaim && !rosterClaimDeferred) {
+				this.#releaseIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
 			}
 		}
-
-		if (!assistantMessage) {
-			throw new Error("Ephemeral turn ended without a final message");
-		}
-		return { replyText: dedupeIrcReply(replyText.trim()), assistantMessage };
 	}
 
 	/**
@@ -10485,7 +10798,7 @@ export class AgentSession {
 	 * the partial response in context, then appends the prompt as a virtual
 	 * user message.
 	 */
-	#buildEphemeralSnapshot(promptText: string): AgentMessage[] {
+	#buildEphemeralSnapshot(promptText: string, prependMessages?: AgentMessage[]): AgentMessage[] {
 		const messages = [...this.messages];
 		const streaming = this.agent.state.streamMessage;
 		if (streaming && streaming.role === "assistant") {
@@ -10516,6 +10829,7 @@ export class AgentSession {
 				}
 			}
 		}
+		if (prependMessages) messages.push(...prependMessages);
 		messages.push({
 			role: "user",
 			content: [{ type: "text", text: promptText }],
@@ -10727,7 +11041,9 @@ export class AgentSession {
 
 			if (switchingToDifferentSession) {
 				this.#resetHindsightConversationTrackingIfHindsight();
+				this.#resetIrcRosterDeliveryState();
 			}
+
 			this.#reconnectToAgent();
 			return true;
 		} catch (error) {
@@ -10850,6 +11166,8 @@ export class AgentSession {
 			this.#closeCodexProviderSessionsForHistoryRewrite();
 		}
 
+		this.#resetIrcRosterDeliveryState();
+
 		return { selectedText, cancelled: false };
 	}
 
@@ -11085,6 +11403,52 @@ export class AgentSession {
 		let totalCacheWrite = 0;
 		let totalCost = 0;
 		let totalPremiumRequests = 0;
+		const totalCostBreakdown: Usage["cost"] = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+		let hasCompleteCostBreakdown = true;
+		const addCostBreakdown = (cost: unknown): void => {
+			if (!cost || typeof cost !== "object") {
+				hasCompleteCostBreakdown = false;
+				return;
+			}
+			const completeCost = cost as Usage["cost"];
+			if (
+				!Number.isFinite(completeCost.input) ||
+				completeCost.input < 0 ||
+				!Number.isFinite(completeCost.output) ||
+				completeCost.output < 0 ||
+				!Number.isFinite(completeCost.cacheRead) ||
+				completeCost.cacheRead < 0 ||
+				!Number.isFinite(completeCost.cacheWrite) ||
+				completeCost.cacheWrite < 0 ||
+				!Number.isFinite(completeCost.total) ||
+				completeCost.total < 0
+			) {
+				hasCompleteCostBreakdown = false;
+				return;
+			}
+			if (!hasCompleteCostBreakdown) return;
+			totalCostBreakdown.input += completeCost.input;
+			totalCostBreakdown.output += completeCost.output;
+			totalCostBreakdown.cacheRead += completeCost.cacheRead;
+			totalCostBreakdown.cacheWrite += completeCost.cacheWrite;
+			totalCostBreakdown.total += completeCost.total;
+			if (
+				!Number.isFinite(totalCostBreakdown.input) ||
+				!Number.isFinite(totalCostBreakdown.output) ||
+				!Number.isFinite(totalCostBreakdown.cacheRead) ||
+				!Number.isFinite(totalCostBreakdown.cacheWrite) ||
+				!Number.isFinite(totalCostBreakdown.total)
+			) {
+				hasCompleteCostBreakdown = false;
+			}
+		};
+		const hasCompleteTaskToolUsage = (details: unknown): boolean =>
+			Boolean(
+				details &&
+					typeof details === "object" &&
+					(details as Record<string, unknown>).usageCostBreakdownComplete === true,
+			);
+
 		const getTaskToolUsage = (details: unknown): Usage | undefined => {
 			if (!details || typeof details !== "object") return undefined;
 			const record = details as Record<string, unknown>;
@@ -11108,6 +11472,7 @@ export class AgentSession {
 				totalCacheWrite += assistantMsg.usage.cacheWrite;
 				totalPremiumRequests += assistantMsg.usage.premiumRequests ?? 0;
 				totalCost += assistantMsg.usage.cost.total;
+				addCostBreakdown(assistantMsg.usage.cost);
 			} else if (message.role === "toolResult") {
 				toolResults += 1;
 				if (message.toolName === "task") {
@@ -11119,6 +11484,11 @@ export class AgentSession {
 						totalCacheWrite += usage.cacheWrite;
 						totalPremiumRequests += usage.premiumRequests ?? 0;
 						totalCost += usage.cost.total;
+						if (hasCompleteTaskToolUsage(message.details)) {
+							addCostBreakdown(usage.cost);
+						} else {
+							hasCompleteCostBreakdown = false;
+						}
 					}
 				}
 			}
@@ -11140,6 +11510,7 @@ export class AgentSession {
 				total: totalInput + totalOutput + totalCacheRead + totalCacheWrite,
 			},
 			cost: totalCost,
+			...(hasCompleteCostBreakdown ? { costBreakdown: totalCostBreakdown } : {}),
 			premiumRequests: totalPremiumRequests,
 		};
 	}
@@ -11156,43 +11527,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> {
@@ -11207,10 +11627,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). */
@@ -11224,11 +11653,48 @@ export class AgentSession {
 		return count;
 	}
 
+	/**
+	 * Usage-anchor eligibility for context estimation. Mirrors the compaction
+	 * rule (see getAssistantUsage in compaction.ts): error/aborted turns carry
+	 * absent or partial usage, so they must not anchor an estimate. Anchor on
+	 * the last successful positive-usage assistant instead and let callers
+	 * estimate every later message (including error/aborted ones) as trailing
+	 * context.
+	 */
+	#anchorableAssistantUsage(message: AgentMessage): Usage | undefined {
+		if (message.role !== "assistant") return undefined;
+		const assistant = message as AssistantMessage;
+		if (assistant.stopReason === "aborted" || assistant.stopReason === "error") return undefined;
+		const usage = assistant.usage;
+		if (!usage || calculateContextTokens(usage) <= 0) return undefined;
+		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
-	 * heuristic estimate of the same content (stable system prefix + history through
-	 * the last usage-bearing assistant turn). Image-bearing content is bucketed out
+	 * heuristic estimate of the same content (stable system prefix + history
+	 * before the last usage-bearing assistant turn — that turn's own output is
+	 * the response, not part of the request's prompt, so it belongs on neither
+	 * side of the ratio). Image-bearing content is bucketed out
 	 * of BOTH sides using the identical fixed IMAGE_TOKEN_ESTIMATE so the 1200-token
 	 * image charge cannot skew the text ratio. Returns undefined when data is
 	 * insufficient, so prepareCompaction applies no correction (never the confounded
@@ -11239,9 +11705,9 @@ export class AgentSession {
 		let lastUsageIndex = -1;
 		let lastUsage: Usage | undefined;
 		for (let i = messages.length - 1; i >= 0; i--) {
-			const msg = messages[i];
-			if (msg.role === "assistant" && (msg as AssistantMessage).usage) {
-				lastUsage = (msg as AssistantMessage).usage;
+			const usage = this.#anchorableAssistantUsage(messages[i]);
+			if (usage) {
+				lastUsage = usage;
 				lastUsageIndex = i;
 				break;
 			}
@@ -11253,7 +11719,7 @@ export class AgentSession {
 		let heuristic = 0;
 		for (const block of this.agent.state.systemPrompt) heuristic += estimateTextTokensHeuristic(block);
 		let imageBlocks = 0;
-		for (let i = 0; i <= lastUsageIndex; i++) {
+		for (let i = 0; i < lastUsageIndex; i++) {
 			heuristic += this.#estimateMessageDisplayTokens(messages[i]);
 			imageBlocks += this.#countImageBlocks(messages[i]);
 		}
@@ -11266,52 +11732,61 @@ 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 last assistant message with usage
-		let lastUsageIndex: number | null = null;
-		let lastUsage: Usage | undefined;
-		for (let i = messages.length - 1; i >= 0; i--) {
-			const msg = messages[i];
-			if (msg.role === "assistant") {
-				const assistantMsg = msg as AssistantMessage;
-				if (assistantMsg.usage) {
-					lastUsage = assistantMsg.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,
 			};
 		}
 
-		const usageTokens = calculatePromptTokens(lastUsage);
+		// Anchor on total context tokens (input + cache + output), not prompt-only
+		// 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(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,
 		};
 	}
 
@@ -11332,55 +11807,33 @@ export class AgentSession {
 	}
 
 	/**
-	 * Conservative inflation applied to the native-free chars/4 estimate of the
-	 * UNSENT context delta. chars/4 undercounts dense code/CJK, so we bias high
-	 * to compact slightly early rather than overflow the model window before the
-	 * next provider response re-anchors the exact count.
+	 * Conservative inflation applied to the native-free estimate of the UNSENT
+	 * context delta. The heuristic is script-aware (CJK counted ~1 token/char),
+	 * but dense non-CJK content (compact JSON, diffs, hashes) can still exceed
+	 * chars/4, so we bias high to compact slightly early rather than overflow
+	 * the model window before the next provider response re-anchors the count.
 	 */
 	#compactionDeltaInflation = 1.2;
-	#compactionDeltaTokenCache = new WeakMap<AgentMessage, { len: number; tokens: number }>();
-
-	/**
-	 * Cheap content-size signal to invalidate the compaction-delta token cache on mutation. Recursively
-	 * sums string lengths across the whole message (depth-bounded), so it covers every
-	 * provider-visible shape (text/thinking/tool args, toolResult output, tool names, etc.)
-	 * without allocating a serialized copy. A size-preserving in-place edit yields only a
-	 * benign estimate drift.
-	 */
-	#messageTokenSize(value: unknown, depth = 0): number {
-		if (depth > 6) return 0;
-		if (typeof value === "string") return value.length;
-		if (typeof value === "number" || typeof value === "boolean") return 8;
-		if (Array.isArray(value)) {
-			let size = 0;
-			for (const item of value) size += this.#messageTokenSize(item, depth + 1);
-			return size;
-		}
-		if (value && typeof value === "object") {
-			let size = 0;
-			for (const item of Object.values(value)) size += this.#messageTokenSize(item, depth + 1);
-			return size;
-		}
-		return 0;
-	}
 
 	#estimateMessageCompactionDeltaTokens(message: AgentMessage): number {
-		// Provider usage anchors the already-sent context (see calculatePromptTokens); this
-		// estimates only the UNSENT delta with the native-free chars/4 heuristic, inflated by
+		// Provider usage anchors the already-sent context (see calculateContextTokens); this
+		// estimates only the UNSENT delta with the script-aware heuristic, inflated by
 		// #compactionDeltaInflation so dense input cannot undercount us past the compaction
-		// threshold before the next provider response re-anchors the exact count. Cached per
-		// message object, invalidated by a cheap content-size signal; a rare size-preserving
-		// in-place edit yields only a benign estimate drift, never wrong output.
-		const len = this.#messageTokenSize(message);
-		const cached = this.#compactionDeltaTokenCache.get(message);
-		if (cached && cached.len === len) return cached.tokens;
+		// threshold before the next provider response re-anchors the exact count.
+		//
+		// Deliberately uncached: this feeds the compaction-threshold decision, and a
+		// stale estimate after an in-place mutation (e.g. a same-length ASCII→CJK
+		// edit, which changes the script-aware estimate up to 4x) could hold the
+		// session under the threshold while the real prompt overflows. Any cheap
+		// invalidation signal short of recomputing the estimator's own converted
+		// fragments provably admits stale reuse, and the call sites run once per
+		// prompt over the few messages trailing the usage anchor, so correctness
+		// wins over a microcache here.
 		let heuristic = 0;
 		for (const llmMessage of convertToLlm([message])) {
 			heuristic += estimateMessageTokensHeuristic(llmMessage);
 		}
-		const tokens = Math.ceil(heuristic * this.#compactionDeltaInflation);
-		this.#compactionDeltaTokenCache.set(message, { len, tokens });
-		return tokens;
+		return Math.ceil(heuristic * this.#compactionDeltaInflation);
 	}
 
 	/**