@sayknow-cli/coding-agent 0.3.11 → 0.3.13

package/src/session/agent-session.ts

@@ -26,6 +26,8 @@ import {
 	type AgentMessage,
 	type AgentState,
 	type AgentTool,
+	assertImagePlaceholdersHavePayload,
+	canContinuePersistedHistory,
 	resolveTelemetry,
 	type StablePrefixSnapshot,
 	ThinkingLevel,
@@ -151,6 +153,7 @@ import { onAppendOnlyModeChanged } from "../config/settings";
 import { RawSseDebugBuffer } from "../debug/raw-sse-buffer";
 import { loadCapability } from "../discovery";
 import { expandApplyPatchToEntries, normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../edit";
+import { MAX_EDIT_FILE_BYTES } from "../edit/read-file";
 import { disposeVmContextsByOwner } from "../eval/js/context-manager";
 import {
 	disposeKernelSessionsByOwner,
@@ -203,6 +206,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 {
@@ -252,7 +256,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";
@@ -289,6 +296,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,
@@ -296,8 +304,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";
 
@@ -360,6 +373,11 @@ export interface AsyncJobSnapshot {
 // Types
 // ============================================================================
 
+export interface RetainedMemorySample {
+	tuiChatChildren?: number;
+	tuiCachedRenderBytes?: number;
+}
+
 export interface AgentSessionConfig {
 	agent: Agent;
 	sessionManager: SessionManager;
@@ -439,6 +457,8 @@ export interface AgentSessionConfig {
 	 * **MUST NOT** dispose it on their own teardown.
 	 */
 	ownedAsyncJobManager?: AsyncJobManager;
+	/** Cheap TUI retained-memory counters; absent for headless sessions. */
+	retainedMemorySampler?: () => RetainedMemorySample;
 	/**
 	 * MCPManager whose lifecycle this session owns (top-level sessions that
 	 * connected plugin-bundle MCP servers). Only the owned manager is
@@ -529,6 +549,7 @@ export interface SessionStats {
 	};
 	premiumRequests: number;
 	cost: number;
+	costBreakdown?: Usage["cost"];
 }
 
 /** Internal marker for hook messages queued through the agent loop */
@@ -1084,6 +1105,68 @@ export function buildContextInjectionSignature(kind: string, parts: readonly str
 	}
 	return hash.digest("base64url");
 }
+
+const STREAMING_EDIT_FILE_CACHE_MAX_ENTRIES = 16;
+const STREAMING_EDIT_FILE_CACHE_MAX_TOTAL_BYTES = 32 * 1024 * 1024;
+
+type StreamingEditFileCacheEntry = {
+	content: string;
+	bytes: number;
+};
+
+export class StreamingEditFileCache {
+	#entries = new Map<string, StreamingEditFileCacheEntry>();
+	#totalBytes = 0;
+
+	get(path: string): string | undefined {
+		const entry = this.#entries.get(path);
+		if (entry === undefined) return undefined;
+		this.#entries.delete(path);
+		this.#entries.set(path, entry);
+		return entry.content;
+	}
+
+	set(path: string, content: string): void {
+		const bytes = Buffer.byteLength(content, "utf8");
+		if (bytes > MAX_EDIT_FILE_BYTES || bytes > STREAMING_EDIT_FILE_CACHE_MAX_TOTAL_BYTES) {
+			this.delete(path);
+			return;
+		}
+
+		this.delete(path);
+		while (
+			this.#entries.size >= STREAMING_EDIT_FILE_CACHE_MAX_ENTRIES ||
+			this.#totalBytes + bytes > STREAMING_EDIT_FILE_CACHE_MAX_TOTAL_BYTES
+		) {
+			const oldestPath = this.#entries.keys().next().value;
+			if (oldestPath === undefined) break;
+			this.delete(oldestPath);
+		}
+
+		this.#entries.set(path, { content, bytes });
+		this.#totalBytes += bytes;
+	}
+
+	delete(path: string): void {
+		const entry = this.#entries.get(path);
+		if (entry === undefined) return;
+		this.#entries.delete(path);
+		this.#totalBytes -= entry.bytes;
+	}
+
+	clear(): void {
+		this.#entries.clear();
+		this.#totalBytes = 0;
+	}
+
+	has(path: string): boolean {
+		return this.#entries.has(path);
+	}
+
+	get totalBytes(): number {
+		return this.#totalBytes;
+	}
+}
 export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
@@ -1148,6 +1231,7 @@ export class AgentSession {
 	#compactionAbortController: AbortController | undefined = undefined;
 	#autoCompactionAbortController: AbortController | undefined = undefined;
 	#resourceSampler: () => EmergencyCompactionSample = () => this.#defaultResourceSample();
+	#retainedMemorySampler: (() => RetainedMemorySample) | undefined;
 	#prePromptContextCheckPromise: Promise<void> | undefined = undefined;
 
 	// Branch summarization state
@@ -1198,6 +1282,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;
@@ -1321,7 +1408,7 @@ export class AgentSession {
 
 	#streamingEditPrecheckedToolCallIds = new Set<string>();
 
-	#streamingEditFileCache = new Map<string, string>();
+	#streamingEditFileCache = new StreamingEditFileCache();
 	readonly streamingEditDebugCounters = {
 		guardRuns: 0,
 		processedChars: 0,
@@ -1447,6 +1534,7 @@ export class AgentSession {
 		// Power assertions are taken per turn (see #beginInFlight); nothing acquired here.
 		this.#evalKernelOwnerId = config.evalKernelOwnerId ?? `agent-session:${Snowflake.next()}`;
 		this.#ownedAsyncJobManager = config.ownedAsyncJobManager;
+		this.#retainedMemorySampler = config.retainedMemorySampler;
 		this.#ownedMcpManager = config.ownedMcpManager;
 		this.#scopedModels = config.scopedModels ?? [];
 		this.#thinkingLevel = config.thinkingLevel;
@@ -2013,6 +2101,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
@@ -2024,12 +2122,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
@@ -2132,7 +2225,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 };
 			}
 		}
 
@@ -2147,6 +2242,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();
@@ -2316,14 +2420,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));
 				}
@@ -2688,8 +2798,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 {
@@ -3170,7 +3279,31 @@ export class AgentSession {
 		// which is the optional patch-preview verification gated by
 		// edit.streamingAbort. Skip the read when the setting is off.
 		if (this.settings.get("edit.streamingAbort")) {
-			this.#ensureFileCache(streamingEdit.resolvedPath);
+			// Fire-and-forget async priming: toolcall deltas arrive on the hot
+			// stream path, so never block it on filesystem I/O. The abort-check
+			// path (#maybeAbortStreamingEdit) still falls back to the sync read
+			// if priming hasn't completed by the time removed lines appear.
+			void this.#preCacheFileAsync(streamingEdit.resolvedPath);
+		}
+	}
+
+	#streamingEditPrecachePending = new Set<string>();
+	async #preCacheFileAsync(resolvedPath: string): Promise<void> {
+		if (this.#streamingEditFileCache.has(resolvedPath)) return;
+		if (this.#streamingEditPrecachePending.has(resolvedPath)) return;
+		this.#streamingEditPrecachePending.add(resolvedPath);
+		try {
+			const stat = await fs.promises.stat(resolvedPath);
+			if (stat.size > MAX_EDIT_FILE_BYTES) return;
+
+			const rawText = await fs.promises.readFile(resolvedPath, "utf-8");
+			if (this.#streamingEditFileCache.has(resolvedPath)) return;
+			const { text } = stripBom(rawText);
+			this.#streamingEditFileCache.set(resolvedPath, normalizeToLF(text));
+		} catch {
+			// Don't cache on read errors (including ENOENT) - let the edit tool handle them
+		} finally {
+			this.#streamingEditPrecachePending.delete(resolvedPath);
 		}
 	}
 
@@ -3178,6 +3311,9 @@ export class AgentSession {
 		if (this.#streamingEditFileCache.has(resolvedPath)) return;
 
 		try {
+			const stat = fs.statSync(resolvedPath);
+			if (stat.size > MAX_EDIT_FILE_BYTES) return;
+
 			const rawText = fs.readFileSync(resolvedPath, "utf-8");
 			const { text } = stripBom(rawText);
 			this.#streamingEditFileCache.set(resolvedPath, normalizeToLF(text));
@@ -3665,6 +3801,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
@@ -3728,6 +3866,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
@@ -3828,6 +3978,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();
@@ -4795,6 +4959,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);
 	}
@@ -4929,6 +5101,7 @@ export class AgentSession {
 
 	setWorkflowGateEmitter(emitter: WorkflowGateEmitter | undefined): void {
 		this.#workflowGateEmitter = emitter;
+		notifyWorkflowGateEmitterChanged(this.sessionId, emitter);
 		if (emitter) {
 			this.#ensureWorkflowGateAskTool();
 		}
@@ -5298,6 +5471,7 @@ export class AgentSession {
 
 		// Expand file-based prompt templates if requested
 		const expandedText = expandPromptTemplates ? expandPromptTemplate(text, [...this.#promptTemplates]) : text;
+		assertImagePlaceholdersHavePayload(expandedText, options?.images);
 		const workflowIntentDiff = options?.synthetic ? null : buildWorkflowIntentDiff(expandedText);
 
 		// If streaming, queue via steer() or followUp() based on option
@@ -5475,6 +5649,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();
@@ -5526,6 +5701,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);
 			}
@@ -5630,10 +5810,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();
 		}
 	}
@@ -5784,6 +5981,7 @@ export class AgentSession {
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this.#promptTemplates]);
+		assertImagePlaceholdersHavePayload(expandedText, images);
 		await this.#queueSteer(expandedText, images);
 	}
 
@@ -5800,6 +5998,7 @@ export class AgentSession {
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this.#promptTemplates]);
+		assertImagePlaceholdersHavePayload(expandedText, images);
 		await this.#queueFollowUp(expandedText, images, {
 			forceOneAtATime: options?.followUpQueuePolicy === "sequential",
 		});
@@ -5809,6 +6008,7 @@ export class AgentSession {
 	 * Internal: Queue a steering message (already expanded, no extension command check).
 	 */
 	async #queueSteer(text: string, images?: ImageContent[]): Promise<void> {
+		assertImagePlaceholdersHavePayload(text, images);
 		const displayText = text || (images && images.length > 0 ? "[Image]" : "");
 		this.#steeringMessages.push(this.#createQueuedDisplayEntry(displayText));
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
@@ -5840,6 +6040,7 @@ export class AgentSession {
 	 * Internal: Queue a follow-up message (already expanded, no extension command check).
 	 */
 	async #queueFollowUp(text: string, images?: ImageContent[], options?: { forceOneAtATime?: boolean }): Promise<void> {
+		assertImagePlaceholdersHavePayload(text, images);
 		const displayText = text || (images && images.length > 0 ? "[Image]" : "");
 		this.#followUpMessages.push(this.#createQueuedDisplayEntry(displayText));
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
@@ -6057,6 +6258,7 @@ export class AgentSession {
 				message.display,
 				message.details,
 				message.attribution ?? "agent",
+				getSessionMessageObservationId(appMessage),
 			);
 			return;
 		}
@@ -6084,6 +6286,7 @@ export class AgentSession {
 			message.display,
 			message.details,
 			message.attribution ?? "agent",
+			getSessionMessageObservationId(appMessage),
 		);
 	}
 
@@ -6557,6 +6760,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({
@@ -6664,6 +6869,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({
@@ -7603,6 +7810,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")) {
@@ -7641,6 +7850,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;
@@ -7732,9 +7949,14 @@ export class AgentSession {
 		this.#resourceSampler = sampler;
 	}
 
+	setRetainedMemorySampler(sampler: (() => RetainedMemorySample) | undefined): void {
+		this.#retainedMemorySampler = sampler;
+	}
+
 	#defaultResourceSample(): EmergencyCompactionSample {
 		let providerBytes = 0;
 		let imageBytes = 0;
+		const retainedMemory = this.#retainedMemorySampler?.() ?? {};
 		for (const message of this.state.messages) {
 			const content = (message as { content?: unknown }).content;
 			if (typeof content === "string") {
@@ -7756,6 +7978,10 @@ export class AgentSession {
 			providerBytes,
 			messageCount: this.state.messages.length,
 			imageBytes,
+			sessionResidentImageBytes: this.sessionManager.getResidentImageBytes(),
+			materializedResidentBytes: this.#streamingEditFileCache.totalBytes,
+			tuiChatChildren: retainedMemory.tuiChatChildren ?? 0,
+			tuiCachedRenderBytes: retainedMemory.tuiCachedRenderBytes ?? 0,
 		};
 	}
 
@@ -8071,7 +8297,7 @@ export class AgentSession {
 			attribution: "agent",
 			timestamp: Date.now(),
 		});
-		this.#scheduleAgentContinue({ generation: this.#promptGeneration });
+		this.#scheduleAgentContinue({ skipCompactionCheck: true });
 	}
 
 	/**
@@ -9152,16 +9378,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
@@ -9173,14 +9389,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
@@ -9188,7 +9405,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";
 		}
@@ -10140,17 +10359,19 @@ 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({
+			observationId: incomingObservationId,
 			from: args.from,
 			to: this.#agentId ?? "?",
 			body: args.message,
@@ -10172,17 +10393,19 @@ export class AgentSession {
 			signal: args.signal,
 		});
 
+		const replyObservationId = crypto.randomUUID();
 		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 },
+			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,
@@ -10201,6 +10424,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;
@@ -10220,7 +10444,13 @@ 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,
 		};
@@ -10292,6 +10522,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
@@ -10308,61 +10593,84 @@ export class AgentSession {
 		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}`);
-		}
+		const rosterClaim = this.#claimIrcRosterCandidate();
+		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) {
+				this.#commitIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
 			}
-			if (event.type === "error") {
-				throw new Error(event.error.errorMessage || "Ephemeral turn failed");
+			return { replyText: dedupeIrcReply(replyText.trim()), assistantMessage };
+		} finally {
+			if (rosterClaim) {
+				this.#releaseIrcRosterClaim(rosterClaim.token, rosterClaim.epoch);
 			}
 		}
-
-		if (!assistantMessage) {
-			throw new Error("Ephemeral turn ended without a final message");
-		}
-		return { replyText: dedupeIrcReply(replyText.trim()), assistantMessage };
 	}
 
 	/**
@@ -10371,7 +10679,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") {
@@ -10402,6 +10710,7 @@ export class AgentSession {
 				}
 			}
 		}
+		if (prependMessages) messages.push(...prependMessages);
 		messages.push({
 			role: "user",
 			content: [{ type: "text", text: promptText }],
@@ -10613,7 +10922,9 @@ export class AgentSession {
 
 			if (switchingToDifferentSession) {
 				this.#resetHindsightConversationTrackingIfHindsight();
+				this.#resetIrcRosterDeliveryState();
 			}
+
 			this.#reconnectToAgent();
 			return true;
 		} catch (error) {
@@ -10736,6 +11047,8 @@ export class AgentSession {
 			this.#closeCodexProviderSessionsForHistoryRewrite();
 		}
 
+		this.#resetIrcRosterDeliveryState();
+
 		return { selectedText, cancelled: false };
 	}
 
@@ -10971,6 +11284,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>;
@@ -10994,6 +11353,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") {
@@ -11005,6 +11365,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;
+						}
 					}
 				}
 			}
@@ -11026,6 +11391,7 @@ export class AgentSession {
 				total: totalInput + totalOutput + totalCacheRead + totalCacheWrite,
 			},
 			cost: totalCost,
+			...(hasCompleteCostBreakdown ? { costBreakdown: totalCostBreakdown } : {}),
 			premiumRequests: totalPremiumRequests,
 		};
 	}
@@ -11110,11 +11476,30 @@ 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;
+	}
+
 	/**
 	 * 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
@@ -11125,9 +11510,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;
 			}
@@ -11139,7 +11524,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]);
 		}
@@ -11164,18 +11549,16 @@ export class AgentSession {
 	} {
 		const messages = this.messages;
 
-		// Find last assistant message with usage
+		// 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 msg = messages[i];
-			if (msg.role === "assistant") {
-				const assistantMsg = msg as AssistantMessage;
-				if (assistantMsg.usage) {
-					lastUsage = assistantMsg.usage;
-					lastUsageIndex = i;
-					break;
-				}
+			const usage = this.#anchorableAssistantUsage(messages[i]);
+			if (usage) {
+				lastUsage = usage;
+				lastUsageIndex = i;
+				break;
 			}
 		}
 
@@ -11190,7 +11573,11 @@ export class AgentSession {
 			};
 		}
 
-		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(lastUsage);
 		let trailingTokens = 0;
 		for (let i = lastUsageIndex + 1; i < messages.length; i++) {
 			trailingTokens += estimateMessage(messages[i]);
@@ -11218,55 +11605,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);
 	}
 
 	/**