@sayknow-cli/coding-agent 0.3.0 → 0.3.2

package/src/session/agent-session.ts

@@ -50,7 +50,11 @@ import {
 	type SummaryOptions,
 	shouldCompact,
 } from "@sayknow-cli/agent-core/compaction";
-import { DEFAULT_PRUNE_CONFIG, pruneToolOutputs } from "@sayknow-cli/agent-core/compaction/pruning";
+import {
+	DEFAULT_PRUNE_CONFIG,
+	pruneAssistantToolArguments,
+	pruneToolOutputs,
+} from "@sayknow-cli/agent-core/compaction/pruning";
 import type {
 	AssistantMessage,
 	Context,
@@ -127,7 +131,7 @@ import {
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
 import { reset as resetCapabilities } from "../capability";
 import type { Rule } from "../capability/rule";
-import { MODEL_ROLE_IDS, type ModelRegistry } from "../config/model-registry";
+import { MODEL_ROLE_IDS, type ModelRegistry, SKC_MODEL_ASSIGNMENT_TARGETS } from "../config/model-registry";
 import {
 	extractExplicitThinkingSelector,
 	formatModelSelectorValue,
@@ -286,6 +290,8 @@ import { ToolChoiceQueue } from "./tool-choice-queue";
 import { YieldQueue } from "./yield-queue";
 
 /** Session-specific events that extend the core AgentEvent */
+export type AutoCompactionContinuationSkipReason = "auto_continue_disabled_non_resumable_tail";
+
 export type AgentSessionEvent =
 	| AgentEvent
 	| { type: "auto_compaction_start"; reason: "threshold" | "overflow" | "idle"; action: "context-full" | "handoff" }
@@ -298,6 +304,7 @@ export type AgentSessionEvent =
 			errorMessage?: string;
 			/** True when compaction was skipped for a benign reason (no model, no candidates, nothing to compact). */
 			skipped?: boolean;
+			continuationSkipReason?: AutoCompactionContinuationSkipReason;
 	  }
 	| {
 			type: "auto_retry_start";
@@ -418,6 +425,13 @@ export interface AgentSessionConfig {
 	 * **MUST NOT** dispose it on their own teardown.
 	 */
 	ownedAsyncJobManager?: AsyncJobManager;
+	/**
+	 * MCPManager whose lifecycle this session owns (top-level sessions that
+	 * connected plugin-bundle MCP servers). Only the owned manager is
+	 * disconnected on dispose; subagents and callers that merely observe the
+	 * process-global manager **MUST NOT** dispose it on their own teardown.
+	 */
+	ownedMcpManager?: MCPManager;
 	/** Optional fork-context seed used to initialize a child session before its first prompt. */
 	forkContextSeed?: ForkContextSeed;
 	/** Optional provider state override. Fork-context children should omit this by default. */
@@ -955,6 +969,7 @@ export class AgentSession {
 	 * this undefined and **MUST NOT** dispose the global instance on teardown.
 	 */
 	readonly #ownedAsyncJobManager: AsyncJobManager | undefined;
+	readonly #ownedMcpManager: MCPManager | undefined;
 	#pendingPythonMessages: PythonExecutionMessage[] = [];
 	#activeEvalExecutions = new Set<Promise<unknown>>();
 	#evalExecutionDisposing = false;
@@ -1084,6 +1099,16 @@ export class AgentSession {
 	#lastSuccessfulYieldToolCallId: string | undefined = undefined;
 	#promptGeneration = 0;
 	#providerSessionState = new Map<string, ProviderSessionState>();
+	/**
+	 * Provider keys for which the Anthropic fast-mode auto-fallback fired this
+	 * session (the provider rejected `speed:"fast"` and we retried without it).
+	 * Provider/API-session scoped — matching the provider's own per-session
+	 * `fastModeDisabled` flag — NOT model-keyed. Transient (never persisted): it
+	 * suppresses the current-model fast indicator and dedups the one-time warning
+	 * WITHOUT mutating the user's intended `serviceTier`, so task subagents still
+	 * inherit the intended tier and a different provider still shows fast.
+	 */
+	#fastModeAutoDisabledProviderKeys = new Set<string>();
 	#hindsightSessionState: HindsightSessionState | undefined = undefined;
 	readonly rawSseDebugBuffer: RawSseDebugBuffer;
 
@@ -1158,6 +1183,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.#ownedMcpManager = config.ownedMcpManager;
 		this.#scopedModels = config.scopedModels ?? [];
 		this.#thinkingLevel = config.thinkingLevel;
 		this.#promptTemplates = config.promptTemplates ?? [];
@@ -1869,7 +1895,6 @@ export class AgentSession {
 										this.#resolveTtsrResume();
 										return;
 									}
-									this.#ttsrAbortPending = false;
 									this.#perToolTtsrInjections.clear();
 									const ttsrSettings = this.#ttsrManager?.getSettings();
 									if (ttsrSettings?.contextMode === "discard" && targetAssistantIndex !== -1) {
@@ -1898,11 +1923,22 @@ export class AgentSession {
 										);
 										this.#markTtsrInjected(details.rules);
 									}
-									try {
-										await this.agent.continue();
-									} catch {
-										this.#resolveTtsrResume();
-									}
+									await this.#scheduleAgentContinue({
+										delayMs: 0,
+										generation,
+										shouldContinue: () => {
+											this.#ttsrAbortPending = false;
+											return true;
+										},
+										onSkip: () => {
+											this.#ttsrAbortPending = false;
+											this.#resolveTtsrResume();
+										},
+										onError: () => {
+											this.#ttsrAbortPending = false;
+											this.#resolveTtsrResume();
+										},
+									});
 								},
 								{ delayMs: 50 },
 							);
@@ -1963,12 +1999,18 @@ export class AgentSession {
 				const currentGrantsAnthropicPriority =
 					this.serviceTier === "priority" || this.serviceTier === "claude-only";
 				if (assistantMsg.disabledFeatures?.includes("priority") && currentGrantsAnthropicPriority) {
-					this.setServiceTier(undefined);
-					this.emitNotice(
-						"warning",
-						"Priority/fast mode rejected for this model; retried without it. Fast mode is now off.",
-						"priority",
-					);
+					// The provider auto-dropped `speed:"fast"` for the current model's
+					// provider this turn. Record a transient, provider-scoped marker
+					// instead of clearing the user's intended tier, so task subagents
+					// still inherit it and a different provider still gets fast mode.
+					// Warn once per provider until the user re-arms with `/fast on`.
+					if (this.#markFastModeAutoDisabledForCurrentModel()) {
+						this.emitNotice(
+							"warning",
+							"Priority/fast mode rejected for this model; retried without it. Fast mode is off for this model until you re-enable it with /fast on.",
+							"priority",
+						);
+					}
 				}
 				// Resolve TTSR resume gate before checking for new deferred injections.
 				// Gate on #ttsrAbortPending, not stopReason: a non-TTSR abort (e.g. streaming
@@ -2214,7 +2256,7 @@ export class AgentSession {
 	#schedulePostPromptTask(
 		task: (signal: AbortSignal) => Promise<void>,
 		options?: { delayMs?: number; generation?: number; onSkip?: () => void },
-	): void {
+	): Promise<void> {
 		const delayMs = options?.delayMs ?? 0;
 		const signal = this.#postPromptTasksAbortController.signal;
 		const scheduled = (async () => {
@@ -2236,18 +2278,20 @@ export class AgentSession {
 			await task(signal);
 		})();
 		this.#trackPostPromptTask(scheduled);
+		return scheduled;
 	}
 
 	#scheduleAgentContinue(options?: {
 		delayMs?: number;
 		generation?: number;
+		skipCompactionCheck?: boolean;
 		shouldContinue?: () => boolean;
 		onSkip?: (reason: "generation_changed" | "aborted_signal" | "queue_drained") => void;
 		onError?: (error: unknown) => void;
-	}): void {
+	}): Promise<void> {
 		const scheduledGeneration = options?.generation;
 		const signal = this.#postPromptTasksAbortController.signal;
-		this.#schedulePostPromptTask(
+		return this.#schedulePostPromptTask(
 			async () => {
 				if (signal.aborted) {
 					options?.onSkip?.("aborted_signal");
@@ -2263,6 +2307,9 @@ export class AgentSession {
 				}
 				try {
 					await this.#maybeRestoreRetryFallbackPrimary();
+					if (!options?.skipCompactionCheck) {
+						await this.#checkEstimatedContextBeforePrompt();
+					}
 					await this.agent.continue();
 				} catch (error) {
 					logger.warn("agent.continue failed after scheduling", {
@@ -2307,6 +2354,34 @@ export class AgentSession {
 		}
 	}
 
+	#detectOverflowRetryContinuationSkip(): AutoCompactionContinuationSkipReason | undefined {
+		this.#stripOverflowFailedTurnForRetry();
+		if (this.#isResumableAgentTail()) return undefined;
+		const compactionSettings = this.settings.getGroup("compaction");
+		return compactionSettings.autoContinue === false ? "auto_continue_disabled_non_resumable_tail" : undefined;
+	}
+
+	#scheduleOverflowRetryContinuation(generation: number): void {
+		this.#stripOverflowFailedTurnForRetry();
+		if (this.#isResumableAgentTail()) {
+			this.#scheduleAgentContinue({
+				delayMs: 100,
+				generation,
+				onSkip: reason => this.#logCompactionContinuationSkipped("overflow_retry", reason),
+				onError: error => this.#logCompactionContinuationError("overflow_retry", error),
+			});
+			return;
+		}
+
+		const compactionSettings = this.settings.getGroup("compaction");
+		if (compactionSettings.autoContinue !== false) {
+			this.#scheduleAutoContinuePrompt(generation);
+			return;
+		}
+
+		this.#logCompactionContinuationSkipped("overflow_retry", "auto_continue_disabled_non_resumable_tail");
+	}
+
 	#scheduleAutoContinuePrompt(generation: number): void {
 		const continuePrompt = async () => {
 			await this.#promptWithMessage(
@@ -3052,6 +3127,7 @@ export class AgentSession {
 				willRetry: event.willRetry,
 				errorMessage: event.errorMessage,
 				skipped: event.skipped,
+				continuationSkipReason: event.continuationSkipReason,
 			});
 		} else if (event.type === "auto_retry_start") {
 			await this.#extensionRunner.emit({
@@ -3193,10 +3269,14 @@ export class AgentSession {
 				AsyncJobManager.setInstance(undefined);
 			}
 		}
-		const mcpManager = MCPManager.instance();
-		if (mcpManager) {
-			await mcpManager.disconnectAll();
-			if (MCPManager.instance() === mcpManager) {
+		// Only disconnect the MCP manager THIS session owns (top-level sessions that
+		// connected plugin-bundle MCP servers). Subagents and callers that merely
+		// observe the process-global manager must never tear down a manager they do
+		// not own. Mirrors the ownedAsyncJobManager rule above.
+		const ownedMcpManager = this.#ownedMcpManager;
+		if (ownedMcpManager) {
+			await ownedMcpManager.disconnectAll();
+			if (MCPManager.instance() === ownedMcpManager) {
 				MCPManager.setInstance(undefined);
 			}
 		}
@@ -5557,7 +5637,7 @@ export class AgentSession {
 	}
 
 	#syncTodoPhasesFromBranch(): void {
-		const phases = getLatestTodoPhasesFromEntries(this.sessionManager.getBranch());
+		const phases = getLatestTodoPhasesFromEntries(this.sessionManager.getActivePathEntriesCanonical());
 		// Strip completed/abandoned tasks — they were done in a previous run,
 		// so they have no bearing on progress tracking for the new turn.
 		for (const phase of phases) {
@@ -5566,6 +5646,42 @@ export class AgentSession {
 		this.setTodoPhases(phases.filter(p => p.tasks.length > 0));
 	}
 
+	async #applyCompactionPostAppend(
+		compactionEntryId: string,
+		firstKeptEntryId: string,
+		fromExtension?: boolean,
+	): Promise<CompactionEntry | undefined> {
+		const eviction = this.sessionManager.evictCompactedContent(firstKeptEntryId, compactionEntryId);
+		if (eviction.evictedEntries > 0) await this.sessionManager.rewriteEntries();
+		const sessionContext = this.buildDisplaySessionContext();
+		this.agent.replaceMessages(sessionContext.messages);
+		this.#syncTodoPhasesFromBranch();
+		this.#closeCodexProviderSessionsForHistoryRewrite();
+
+		// Get the saved compaction entry for the hook without materializing all entries.
+		const savedCompactionEntry = this.sessionManager.getEntryForFidelity(compactionEntryId) as
+			| CompactionEntry
+			| undefined;
+
+		if (this.#extensionRunner && savedCompactionEntry) {
+			await this.#extensionRunner.emit({
+				type: "session_compact",
+				compactionEntry: savedCompactionEntry,
+				fromExtension: fromExtension ?? false,
+			});
+		}
+
+		return savedCompactionEntry;
+	}
+
+	async applyCompactionPostAppendForTests(
+		compactionEntryId: string,
+		firstKeptEntryId: string,
+		fromExtension?: boolean,
+	): Promise<CompactionEntry | undefined> {
+		return this.#applyCompactionPostAppend(compactionEntryId, firstKeptEntryId, fromExtension);
+	}
+
 	#cloneTodoPhases(phases: TodoPhase[]): TodoPhase[] {
 		return phases.map(phase => ({
 			name: phase.name,
@@ -6195,33 +6311,81 @@ export class AgentSession {
 		return resolveServiceTier(this.#subagentServiceTier(), provider) === "priority";
 	}
 
+	/**
+	 * Provider/API-session key used to scope the fast-mode auto-disable marker.
+	 * Mirrors the provider's own per-session `fastModeDisabled` scope (the key in
+	 * {@link #providerSessionState} cleared by `clearAnthropicFastModeFallback`),
+	 * so the marker is provider-scoped, never model-keyed. Returns `undefined`
+	 * when no model/provider is selected.
+	 */
+	#fastModeProviderKey(provider: string | undefined = this.model?.provider): string | undefined {
+		return provider;
+	}
+
+	/**
+	 * Record that the current model's provider had fast mode auto-dropped this
+	 * session. Returns `true` only when the provider key is newly marked, so the
+	 * caller emits the one-time warning exactly once per provider until re-arm.
+	 */
+	#markFastModeAutoDisabledForCurrentModel(): boolean {
+		const key = this.#fastModeProviderKey();
+		if (key === undefined) return false;
+		if (this.#fastModeAutoDisabledProviderKeys.has(key)) return false;
+		this.#fastModeAutoDisabledProviderKeys.add(key);
+		return true;
+	}
+
+	/** True when `provider`'s fast mode was auto-disabled this session. */
+	#isFastModeAutoDisabledForProvider(provider?: string): boolean {
+		const key = this.#fastModeProviderKey(provider);
+		return key !== undefined && this.#fastModeAutoDisabledProviderKeys.has(key);
+	}
+
+	/**
+	 * Re-arm fast mode after an auto-disable: clear the provider's sticky
+	 * `fastModeDisabled` fallback flag and the session auto-disable markers so the
+	 * next request carries `speed:"fast"` again and a future rejection can warn
+	 * once more. Called on explicit re-enable (`/fast on`, re-arming tier change),
+	 * never by the transient Q1 auto-disable path.
+	 */
+	#rearmFastMode(): void {
+		clearAnthropicFastModeFallback(this.#providerSessionState);
+		this.#fastModeAutoDisabledProviderKeys.clear();
+	}
+
 	/**
 	 * True when the configured `serviceTier` resolves to `"priority"` for the
-	 * *currently selected model's provider*. Returns false for scoped tiers
-	 * that don't match (e.g. `"openai-only"` on an anthropic model) and when
-	 * no model is selected.
+	 * *currently selected model's provider* AND fast mode was not auto-disabled
+	 * for that provider this session. This is the current-model EFFECTIVE
+	 * predicate (what the next request actually does); use {@link isFastForProvider}
+	 * for pure configured intent (e.g. subagent/`modelRoles` display rows).
 	 */
 	isFastModeActive(): boolean {
-		return this.isFastForProvider(this.model?.provider);
+		const provider = this.model?.provider;
+		return this.isFastForProvider(provider) && !this.#isFastModeAutoDisabledForProvider(provider);
 	}
 
 	setServiceTier(serviceTier: ServiceTier | undefined): void {
-		if (this.serviceTier === serviceTier) return;
-		// Re-arming priority on Anthropic? Clear the per-session auto-fallback
-		// sticky disable so the next request actually carries `speed: "fast"`
-		// again. Without this, `/fast on` (or user switching to a tier that
-		// grants anthropic priority) after an auto-disable is a silent no-op
-		// and the warning notice fires every turn.
+		// Re-arming a priority-granting tier always clears the per-session
+		// auto-fallback sticky disable AND the auto-disable markers so the next
+		// request carries `speed: "fast"` again — even when the tier is unchanged
+		// (re-selecting the same tier is a deliberate re-arm), and before the
+		// no-op early-return below.
 		if (serviceTier === "priority" || serviceTier === "claude-only") {
-			clearAnthropicFastModeFallback(this.#providerSessionState);
+			this.#rearmFastMode();
 		}
+		if (this.serviceTier === serviceTier) return;
 		this.agent.serviceTier = serviceTier;
 		this.sessionManager.appendServiceTierChange(serviceTier ?? null);
 	}
 
 	setFastMode(enabled: boolean): void {
 		if (enabled && this.isFastModeEnabled()) {
-			// Already on under any scope — keep the user's scoped value.
+			// Intent already grants fast mode under some scope — keep the user's
+			// scoped value but still re-arm, so an explicit `/fast on` after a
+			// provider auto-disable actually clears the sticky fallback + markers
+			// (otherwise it is a silent no-op). No history append: intent is unchanged.
+			this.#rearmFastMode();
 			return;
 		}
 		this.setServiceTier(enabled ? "priority" : undefined);
@@ -6279,19 +6443,23 @@ export class AgentSession {
 	async #pruneToolOutputs(): Promise<{ prunedCount: number; tokensSaved: number } | undefined> {
 		const branchEntries = this.sessionManager.getBranch();
 		const result = pruneToolOutputs(branchEntries, DEFAULT_PRUNE_CONFIG);
-		if (result.prunedCount === 0) {
+		const argumentResult = pruneAssistantToolArguments(branchEntries, DEFAULT_PRUNE_CONFIG);
+		const tokensSaved = result.tokensSaved + argumentResult.argumentTokensSaved;
+		const prunedCount = result.prunedCount + argumentResult.argumentPrunedCount;
+		if (prunedCount === 0) {
 			return undefined;
 		}
 
 		// getBranch() returns materialized copies for blob-externalized entries, so
 		// the pruning mutations must be written back into the canonical store.
-		this.sessionManager.applyEntryMessageUpdates(result.prunedEntries);
+		const combined = [...result.prunedEntries, ...argumentResult.prunedEntries];
+		this.sessionManager.applyEntryMessageUpdates(combined);
 		await this.sessionManager.rewriteEntries();
 		const sessionContext = this.buildDisplaySessionContext();
 		this.agent.replaceMessages(sessionContext.messages);
 		this.#syncTodoPhasesFromBranch();
 		this.#closeCodexProviderSessionsForHistoryRewrite();
-		return result;
+		return { prunedCount, tokensSaved };
 	}
 
 	/**
@@ -6409,7 +6577,7 @@ export class AgentSession {
 				throw new CompactionCancelledError();
 			}
 
-			this.sessionManager.appendCompaction(
+			const compactionEntryId = this.sessionManager.appendCompaction(
 				summary,
 				shortSummary,
 				firstKeptEntryId,
@@ -6418,24 +6586,7 @@ export class AgentSession {
 				fromExtension,
 				preserveData,
 			);
-			const newEntries = this.sessionManager.getEntries();
-			const sessionContext = this.buildDisplaySessionContext();
-			this.agent.replaceMessages(sessionContext.messages);
-			this.#syncTodoPhasesFromBranch();
-			this.#closeCodexProviderSessionsForHistoryRewrite();
-
-			// Get the saved compaction entry for the hook
-			const savedCompactionEntry = newEntries.find(e => e.type === "compaction" && e.summary === summary) as
-				| CompactionEntry
-				| undefined;
-
-			if (this.#extensionRunner && savedCompactionEntry) {
-				await this.#extensionRunner.emit({
-					type: "session_compact",
-					compactionEntry: savedCompactionEntry,
-					fromExtension,
-				});
-			}
+			await this.#applyCompactionPostAppend(compactionEntryId, firstKeptEntryId, fromExtension);
 
 			const compactionResult: CompactionResult = {
 				summary,
@@ -6722,6 +6873,8 @@ export class AgentSession {
 			const compactionSettings = this.settings.getGroup("compaction");
 			if (compactionSettings.enabled && compactionSettings.strategy !== "off") {
 				await this.#runAutoCompaction("overflow", true);
+			} else {
+				this.#scheduleOverflowRetryContinuation(generation);
 			}
 			return;
 		}
@@ -6732,17 +6885,19 @@ export class AgentSession {
 		// Skip if this was an error (non-overflow errors don't have usage data)
 		if (assistantMessage.stopReason === "error") return;
 		let contextTokens = calculateContextTokens(assistantMessage.usage);
-		const maxOutputTokens = this.model?.maxTokens ?? 0;
+		// Model maxTokens is a capability ceiling, not a per-turn reservation.
+		// Auto maintenance should track actual context fullness.
+		const autoCompactionOutputReserveTokens = 0;
 		// Cache-epoch invariant: pruning rewrites already-sent toolResult history,
 		// which breaks the provider prompt-cache prefix mid-epoch. Only prune at a
 		// sanctioned maintenance boundary, i.e. when the un-pruned context already
 		// crosses the compaction threshold. Pruning may then avert full compaction.
-		if (!shouldCompact(contextTokens, contextWindow, compactionSettings, maxOutputTokens)) return;
+		if (!shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) return;
 		const pruneResult = await this.#pruneToolOutputs();
 		if (pruneResult) {
 			contextTokens = Math.max(0, contextTokens - pruneResult.tokensSaved);
 		}
-		if (shouldCompact(contextTokens, contextWindow, compactionSettings, maxOutputTokens)) {
+		if (shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) {
 			// Try promotion first — if a larger model is available, switch instead of compacting
 			const promoted = await this.#tryContextPromotion(assistantMessage);
 			if (!promoted) {
@@ -6820,14 +6975,16 @@ export class AgentSession {
 		if (!compactionSettings.enabled || compactionSettings.strategy === "off") return;
 
 		let contextTokens = this.#estimateContextTokensForCompaction(pendingMessages).tokens;
-		const maxOutputTokens = model.maxTokens ?? 0;
-		if (!shouldCompact(contextTokens, contextWindow, compactionSettings, maxOutputTokens)) return;
+		// Model maxTokens is a capability ceiling, not a per-turn reservation.
+		// Auto maintenance should track actual context fullness.
+		const autoCompactionOutputReserveTokens = 0;
+		if (!shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) return;
 
 		const pruneResult = await this.#pruneToolOutputs();
 		if (pruneResult) {
 			contextTokens = Math.max(0, contextTokens - pruneResult.tokensSaved);
 		}
-		if (shouldCompact(contextTokens, contextWindow, compactionSettings, maxOutputTokens)) {
+		if (shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) {
 			await this.#runAutoCompaction("threshold", false, false, {
 				continueAfterMaintenance: false,
 				deferHandoffMaintenance: false,
@@ -7427,11 +7584,14 @@ export class AgentSession {
 		availableModels: Model[],
 		currentModel: Model | undefined,
 	): ResolvedModelRoleValue {
+		const target = SKC_MODEL_ASSIGNMENT_TARGETS[role as keyof typeof SKC_MODEL_ASSIGNMENT_TARGETS];
 		const roleModelStr =
-			role === "default"
-				? (this.settings.getModelRole("default") ??
-					(currentModel ? `${currentModel.provider}/${currentModel.id}` : undefined))
-				: this.settings.getModelRole(role);
+			target?.settingsPath === "task.agentModelOverrides"
+				? this.settings.get("task.agentModelOverrides")[role]
+				: role === "default"
+					? (this.settings.getModelRole("default") ??
+						(currentModel ? `${currentModel.provider}/${currentModel.id}` : undefined))
+					: this.settings.getModelRole(role);
 
 		if (!roleModelStr) {
 			return { model: undefined, thinkingLevel: undefined, explicitThinkingLevel: false, warning: undefined };
@@ -7730,32 +7890,18 @@ export class AgentSession {
 
 			const preparation = prepareCompaction(pathEntries, compactionSettings);
 			if (!preparation) {
+				const continuationSkipReason = willRetry ? this.#detectOverflowRetryContinuationSkip() : undefined;
 				await this.#emitSessionEvent({
 					type: "auto_compaction_end",
 					action,
 					result: undefined,
 					aborted: false,
-					willRetry: false,
+					willRetry: willRetry && !continuationSkipReason,
 					skipped: true,
+					continuationSkipReason,
 				});
 				if (willRetry) {
-					this.#stripOverflowFailedTurnForRetry();
-					if (this.#isResumableAgentTail()) {
-						this.#scheduleAgentContinue({
-							delayMs: 100,
-							generation,
-							onSkip: skipReason => this.#logCompactionContinuationSkipped("overflow_retry", skipReason),
-							onError: error => this.#logCompactionContinuationError("overflow_retry", error),
-						});
-					} else {
-						const tail = this.agent.state.messages.at(-1) as AssistantMessage | undefined;
-						logger.warn("Auto-compaction continuation skipped", {
-							source: "overflow_retry",
-							reason: "not_resumable_tail",
-							role: tail?.role,
-							stopReason: tail?.stopReason,
-						});
-					}
+					this.#scheduleOverflowRetryContinuation(generation);
 				} else if (continueAfterMaintenance && reason !== "idle" && this.agent.hasQueuedMessages()) {
 					this.#scheduleAgentContinue({
 						delayMs: 100,
@@ -7930,7 +8076,7 @@ export class AgentSession {
 				return;
 			}
 
-			this.sessionManager.appendCompaction(
+			const compactionEntryId = this.sessionManager.appendCompaction(
 				summary,
 				shortSummary,
 				firstKeptEntryId,
@@ -7939,24 +8085,7 @@ export class AgentSession {
 				fromExtension,
 				preserveData,
 			);
-			const newEntries = this.sessionManager.getEntries();
-			const sessionContext = this.buildDisplaySessionContext();
-			this.agent.replaceMessages(sessionContext.messages);
-			this.#syncTodoPhasesFromBranch();
-			this.#closeCodexProviderSessionsForHistoryRewrite();
-
-			// Get the saved compaction entry for the hook
-			const savedCompactionEntry = newEntries.find(e => e.type === "compaction" && e.summary === summary) as
-				| CompactionEntry
-				| undefined;
-
-			if (this.#extensionRunner && savedCompactionEntry) {
-				await this.#extensionRunner.emit({
-					type: "session_compact",
-					compactionEntry: savedCompactionEntry,
-					fromExtension,
-				});
-			}
+			await this.#applyCompactionPostAppend(compactionEntryId, firstKeptEntryId, fromExtension);
 
 			const result: CompactionResult = {
 				summary,
@@ -7966,26 +8095,18 @@ export class AgentSession {
 				details,
 				preserveData,
 			};
-			await this.#emitSessionEvent({ type: "auto_compaction_end", action, result, aborted: false, willRetry });
+			const continuationSkipReason = willRetry ? this.#detectOverflowRetryContinuationSkip() : undefined;
+			await this.#emitSessionEvent({
+				type: "auto_compaction_end",
+				action,
+				result,
+				aborted: false,
+				willRetry: willRetry && !continuationSkipReason,
+				continuationSkipReason,
+			});
 
 			if (willRetry) {
-				this.#stripOverflowFailedTurnForRetry();
-				if (!this.#isResumableAgentTail()) {
-					const tail = this.agent.state.messages.at(-1) as AssistantMessage | undefined;
-					logger.warn("Auto-compaction continuation skipped", {
-						source: "overflow_retry",
-						reason: "not_resumable_tail",
-						role: tail?.role,
-						stopReason: tail?.stopReason,
-					});
-				} else {
-					this.#scheduleAgentContinue({
-						delayMs: 100,
-						generation,
-						onSkip: reason => this.#logCompactionContinuationSkipped("overflow_retry", reason),
-						onError: error => this.#logCompactionContinuationError("overflow_retry", error),
-					});
-				}
+				this.#scheduleOverflowRetryContinuation(generation);
 			} else if (continueAfterMaintenance && reason !== "idle" && this.agent.hasQueuedMessages()) {
 				// Auto-compaction can complete while follow-up/steering/custom messages are waiting.
 				// Kick the loop so queued messages are actually delivered.
@@ -9582,7 +9703,7 @@ export class AgentSession {
 		cancelled: boolean;
 	}> {
 		const previousSessionFile = this.sessionFile;
-		const selectedEntry = this.sessionManager.getEntry(entryId);
+		const selectedEntry = this.sessionManager.getEntryForFidelity(entryId);
 
 		if (selectedEntry?.type !== "message" || selectedEntry.message.role !== "user") {
 			throw new Error("Invalid entry ID for branching");
@@ -9680,7 +9801,7 @@ export class AgentSession {
 			throw new Error("No model available for summarization");
 		}
 
-		const targetEntry = this.sessionManager.getEntry(targetId);
+		const targetEntry = this.sessionManager.getEntryForFidelity(targetId);
 		if (!targetEntry) {
 			throw new Error(`Entry ${targetId} not found`);
 		}
@@ -9836,9 +9957,11 @@ export class AgentSession {
 
 		for (const entry of entries) {
 			if (entry.type !== "message") continue;
-			if (entry.message.role !== "user") continue;
+			const fidelityEntry = this.sessionManager.getEntryForFidelity(entry.id);
+			if (fidelityEntry?.type !== "message") continue;
+			if (fidelityEntry.message.role !== "user") continue;
 
-			const text = this.#extractUserMessageText(entry.message.content);
+			const text = this.#extractUserMessageText(fidelityEntry.message.content);
 			if (text) {
 				result.push({ entryId: entry.id, text });
 			}