@sayknow-cli/coding-agent 0.3.1 → 0.3.4

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,
@@ -246,6 +250,7 @@ import { releaseTabsForOwner } from "../tools/browser/tab-supervisor";
 import type { CheckpointState } from "../tools/checkpoint";
 import { outputMeta, wrapToolWithMetaNotice } from "../tools/output-meta";
 import { normalizeLocalScheme, resolveToCwd } from "../tools/path-utils";
+import { registerResourceGcSession } from "../tools/resource-gc";
 import { getLatestTodoPhasesFromEntries, type TodoItem, type TodoPhase } from "../tools/todo-write";
 import { ToolAbortError, ToolError } from "../tools/tool-errors";
 import { clampTimeout } from "../tools/tool-timeouts";
@@ -421,6 +426,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. */
@@ -953,11 +965,14 @@ export class AgentSession {
 	// Python execution state
 	#evalAbortControllers = new Set<AbortController>();
 	#evalKernelOwnerId: string;
+	/** Idempotent unregister handle for this session's resource-GC registration. */
+	#unregisterResourceGc?: () => void;
 	/**
 	 * AsyncJobManager owned by this session (top-level only). Subagents leave
 	 * 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;
@@ -1087,6 +1102,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,9 +1183,19 @@ export class AgentSession {
 		this.sessionManager = config.sessionManager;
 		this.settings = config.settings;
 		this.taskDepth = config.taskDepth ?? 0;
+		// Register this session with the process-wide resource GC (idle/RSS browser-tab eviction
+		// + stale screenshot cleanup). Session-keyed so concurrent sessions share one timer safely.
+		const resourceGcSessionId = this.sessionManager.getSessionId();
+		if (resourceGcSessionId) {
+			this.#unregisterResourceGc = registerResourceGcSession({
+				sessionId: resourceGcSessionId,
+				settings: this.settings,
+			});
+		}
 		// 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 ?? [];
@@ -1976,12 +2011,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
@@ -3240,10 +3281,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);
 			}
 		}
@@ -3252,6 +3297,8 @@ export class AgentSession {
 		// browsers disconnect, headless close gracefully). Scoped by the session id the
 		// browser tool tagged tabs with, so other live sessions' tabs are untouched.
 		// No-op when this session opened no tabs. Failure is logged, not thrown.
+		this.#unregisterResourceGc?.();
+		this.#unregisterResourceGc = undefined;
 		await releaseTabsForOwner(this.sessionManager.getSessionId()).catch((error: unknown) =>
 			logger.warn("session dispose: releaseTabsForOwner failed", { error }),
 		);
@@ -3291,6 +3338,8 @@ export class AgentSession {
 	async disposeChildSubprocesses(timeoutMs = SIGNAL_TEARDOWN_TIMEOUT_MS): Promise<void> {
 		const sessionId = this.sessionManager.getSessionId();
 		const kernelOwnerId = this.#evalKernelOwnerId;
+		this.#unregisterResourceGc?.();
+		this.#unregisterResourceGc = undefined;
 		const work = Promise.allSettled([
 			// kill:true so a forced exit also reaps spawned-app Chrome we own (headless
 			// always closes; connected/attached browsers only disconnect — never killed).
@@ -5198,6 +5247,19 @@ export class AgentSession {
 			attribution: "user",
 			timestamp: Date.now(),
 		});
+		// A live agent loop polls the steering queue at every tool/turn boundary
+		// and consumes this message on its own. But when a steer is queued while no
+		// loop is actively running — e.g. the session still reports busy only
+		// because a finished prompt is unwinding (deferred agent_end / post-prompt
+		// work) — nothing delivers it until the next explicit prompt or a
+		// user-interrupt abort, so it stalls until the user presses Esc. Schedule a
+		// continue so the steer is delivered promptly. A live loop (or an
+		// already-drained queue) makes the scheduled continue a no-op.
+		if (this.#canAutoContinueForSteer()) {
+			this.#scheduleAgentContinue({
+				shouldContinue: () => this.#canAutoContinueForSteer() && this.agent.hasQueuedSteering(),
+			});
+		}
 	}
 
 	/**
@@ -5242,6 +5304,21 @@ export class AgentSession {
 		return last?.role === "assistant";
 	}
 
+	/**
+	 * Gate for idle / winding-down steer auto-continue. Unlike the follow-up gate
+	 * this checks `agent.state.isStreaming` (a live agent loop) rather than the
+	 * public `isStreaming` (which stays true while a finished prompt unwinds), so a
+	 * steer queued during the unwind window is still delivered. A live loop returns
+	 * false here because it polls the steering queue itself.
+	 */
+	#canAutoContinueForSteer(): boolean {
+		if (this.agent.state.isStreaming) return false;
+		if (this.isRetrying) return false;
+		const messages = this.agent.state.messages;
+		const last = messages[messages.length - 1];
+		return last?.role === "assistant";
+	}
+
 	queueDeferredMessage(message: CustomMessage): void {
 		this.#queueHiddenNextTurnMessage(message, true);
 	}
@@ -5604,7 +5681,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) {
@@ -5613,6 +5690,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,
@@ -6242,33 +6355,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);
@@ -6326,19 +6487,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 };
 	}
 
 	/**
@@ -6456,7 +6621,7 @@ export class AgentSession {
 				throw new CompactionCancelledError();
 			}
 
-			this.sessionManager.appendCompaction(
+			const compactionEntryId = this.sessionManager.appendCompaction(
 				summary,
 				shortSummary,
 				firstKeptEntryId,
@@ -6465,24 +6630,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,
@@ -7480,11 +7628,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 };
@@ -7969,7 +8120,7 @@ export class AgentSession {
 				return;
 			}
 
-			this.sessionManager.appendCompaction(
+			const compactionEntryId = this.sessionManager.appendCompaction(
 				summary,
 				shortSummary,
 				firstKeptEntryId,
@@ -7978,24 +8129,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,
@@ -9613,7 +9747,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");
@@ -9711,7 +9845,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`);
 		}
@@ -9867,9 +10001,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 });
 			}