@gajae-code/coding-agent 0.16.3 → 0.16.4

package/src/sdk/session-api-key.ts

@@ -0,0 +1,94 @@
+/**
+ * AgentLoop calls `getApiKey(provider)` before `streamFn`.
+ * Resolve/stream already use `getApiKey(model)`. If those two lookups diverge,
+ * the child dies locally (~8ms, 0 tokens, sanitized "Agent run failed.")
+ * and never reaches the working model-scoped path (#5081).
+ */
+export type SessionApiKeyModel = {
+	provider: string;
+	baseUrl?: string;
+};
+
+export type SessionApiKeyRegistry = {
+	getApiKey(
+		model: SessionApiKeyModel,
+		sessionId?: string,
+		options?: { signal?: AbortSignal },
+	): Promise<string | undefined>;
+	getApiKeyForProvider(
+		provider: string,
+		sessionId?: string,
+		baseUrl?: string,
+		options?: { signal?: AbortSignal },
+	): Promise<string | undefined>;
+};
+
+export type SessionApiKeyResolution = {
+	apiKey: string;
+	credentialSessionId: string | undefined;
+};
+
+export type SessionApiKeyCredentialType = "api_key" | "oauth" | undefined;
+
+export function isStableSessionApiKeyCredentialType(
+	previous: SessionApiKeyCredentialType,
+	replacement: SessionApiKeyCredentialType,
+): boolean {
+	return previous === replacement;
+}
+
+export function resolveLiveSessionApiKeyModel(
+	live: SessionApiKeyModel | undefined,
+	captured: SessionApiKeyModel | undefined,
+	provider: string,
+): SessionApiKeyModel | undefined {
+	if (live?.provider === provider) return live;
+	if (captured?.provider === provider) return captured;
+	return undefined;
+}
+
+async function lookupOnce(
+	registry: SessionApiKeyRegistry,
+	provider: string,
+	sessionId: string | undefined,
+	model: SessionApiKeyModel | undefined,
+	signal: AbortSignal | undefined,
+): Promise<string | undefined> {
+	signal?.throwIfAborted();
+	const matchingModel = model?.provider === provider ? model : undefined;
+	const options = signal ? { signal } : undefined;
+	let key: string | undefined;
+	if (matchingModel) {
+		key = await registry.getApiKey(matchingModel, sessionId, options);
+		signal?.throwIfAborted();
+	}
+	if (!key) {
+		key = await registry.getApiKeyForProvider(provider, sessionId, matchingModel?.baseUrl, options);
+		signal?.throwIfAborted();
+	}
+	return key;
+}
+
+export async function lookupSessionApiKey(
+	registry: SessionApiKeyRegistry,
+	provider: string,
+	sessionId: string | undefined,
+	model: SessionApiKeyModel | undefined,
+	allowUnscopedRetry = true,
+	signal?: AbortSignal,
+): Promise<SessionApiKeyResolution> {
+	let key = await lookupOnce(registry, provider, sessionId, model, signal);
+	// Architect children inherit the parent SID. Direct `-p --no-session` does
+	// not. Scoped miss then global/broker hit is the remaining 0-token death
+	// after #5105 (jsonl: Agent run failed / output 0).
+	if (!key && sessionId && allowUnscopedRetry) {
+		key = await lookupOnce(registry, provider, undefined, model, signal);
+		if (key) return { apiKey: key, credentialSessionId: undefined };
+	}
+	if (!key) {
+		throw Object.assign(new Error(`No API key found for provider "${provider}"`), {
+			code: "provider_unavailable",
+		});
+	}
+	return { apiKey: key, credentialSessionId: sessionId };
+}

package/src/sdk/session.ts

@@ -197,6 +197,11 @@ import { EventBus } from "../utils/event-bus";
 import { buildNamedToolChoice, buildNamedToolChoiceResult } from "../utils/tool-choice";
 import type { WorkspaceTree } from "../workspace-tree";
 import { createSessionLifecycleService } from "./lifecycle/client";
+import {
+	isStableSessionApiKeyCredentialType,
+	lookupSessionApiKey,
+	resolveLiveSessionApiKeyModel,
+} from "./session-api-key";
 import {
 	attachLifecycleStartupCapability,
 	lifecycleMcpStartupTimeoutOption,
@@ -2338,15 +2343,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 			if (options.skills === undefined && settings.get("skills.enabled")) {
 				try {
-					const reloaded = await loadSkills({
-						...settings.getGroup("skills"),
-						agentDir,
-						cwd: to,
-						disabledExtensions: settings.get("disabledExtensions"),
-					});
-					skills = withEmbeddedDefaultGjcSkills(reloaded.skills);
-					if (!options.parentTaskPrefix) setActiveSkills(skills);
-					await session?.replaceSkills(skills);
+					await session?.reloadSkills(to);
 				} catch (error) {
 					logger.warn("Failed to reload skills after session rescope", { error: safeErrorForLog(error) });
 				}
@@ -2708,13 +2705,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				else signal.addEventListener("abort", () => resolve(), { once: true });
 				return promise;
 			},
+			getSessionId: () => sessionManager.getSessionId(),
 			// Subagents inherit the parent's manager; its registered endpoint is
 			// authoritative for owned-registration keying and endpoint-first
 			// manager lookup (the child's own id is never registered), so tools
 			// pass the same endpoint the manager's completion callback resolves
 			// (review thread P1). For a top-level session this equals the
 			// session id.
-			getSessionId: () => AsyncJobManager.endpointIdOf(asyncJobManager) ?? asyncJobEndpointId,
+			getAsyncEndpointId: () => AsyncJobManager.endpointIdOf(asyncJobManager) ?? asyncJobEndpointId,
 			registerForegroundFoldParticipant: adapter =>
 				session?.registerForegroundFoldParticipant(adapter) ?? (() => {}),
 			hasForegroundBashBackgroundRequestHandler: () => session?.hasForegroundBashBackgroundRequestHandler() ?? false,
@@ -3924,6 +3922,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				appendSystemPrompt: appendPrompt,
 				pluginAppendices: pluginSystemAppendices,
 				repeatToolDescriptions,
+				reasoningLanguage: settings.get("reasoningLanguage"),
 				intentField,
 				toolDiscoveryActive: effectiveDiscoveryMode === "all" || mcpDiscoveryEnabled,
 				eagerTasks: resolveEagerTasks(),
@@ -4257,6 +4256,32 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			).seedNormalizedMessages(options.forkContextSeed.messages);
 		}
 
+		const resolvedCredentialScopes = new Map<string, string | undefined>();
+		const resolveAgentApiKey = async (provider: string, signal?: AbortSignal): Promise<string> => {
+			const liveModel = resolveLiveSessionApiKeyModel(sessionAgent?.state.model, model, provider);
+			const hasExplicitScopePolicy =
+				modelRegistry.authStorage.hasSessionCredentialSelector(provider, credentialSessionId) ||
+				modelRegistry.authStorage.hasSessionCredentialAuto(provider, credentialSessionId);
+			const resolution = await lookupSessionApiKey(
+				modelRegistry,
+				provider,
+				credentialSessionId,
+				liveModel,
+				!hasExplicitScopePolicy,
+				signal,
+			);
+			resolvedCredentialScopes.set(provider, resolution.credentialSessionId);
+			return resolution.apiKey;
+		};
+		const resolvedCredentialType = (provider: string): "api_key" | "oauth" | undefined => {
+			const scope = resolvedCredentialScopes.has(provider)
+				? resolvedCredentialScopes.get(provider)
+				: credentialSessionId;
+			return modelRegistry.authStorage.getEffectiveCredentialType(provider, scope, {
+				owner: modelRegistry.getAuthStorageOwner(),
+			});
+		};
+
 		agent = new Agent({
 			initialState: {
 				systemPrompt,
@@ -4295,44 +4320,42 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			shouldPause: options.shouldPause,
 			preferWebsockets: preferOpenAICodexWebsockets,
 			getToolContext: tc => toolContextStore.getContext(tc),
-			getApiKey: async provider => {
+			getApiKey: provider => {
 				// AgentLoop asks by provider, but the active model carries the
 				// model-scoped credential selector. Read it at call time so model
 				// changes are honored after /new, fork, resume, or branch switches.
-				const liveModel = sessionAgent?.state.model ?? model;
-				const key =
-					liveModel?.provider === provider
-						? await modelRegistry.getApiKey(liveModel, credentialSessionId)
-						: undefined;
-				const providerKey = key ?? (await modelRegistry.getApiKeyForProvider(provider, credentialSessionId));
-				if (!providerKey) {
-					throw new Error(`No API key found for provider "${provider}"`);
-				}
-				return providerKey;
+				return resolveAgentApiKey(provider);
 			},
-			getAuthCredentialType: provider => modelRegistry.getSessionCredentialType(provider, credentialSessionId),
+			getAuthCredentialType: resolvedCredentialType,
 			streamFn: async (streamModel, context, streamOptions) => {
 				const requestStartedAt = performance.now();
 				let stream: Awaited<ReturnType<typeof streamSimple>>;
 				try {
-					const effectiveApiKey = await modelRegistry.getApiKey(streamModel, credentialSessionId);
 					stream = await streamSimple(streamModel, context, {
 						...streamOptions,
-						apiKey: effectiveApiKey,
-						authCredentialType: modelRegistry.getSessionCredentialType(streamModel.provider, credentialSessionId),
 						onAuthError: async (provider, oldKey, error) => {
+							const resolvedScope = resolvedCredentialScopes.has(provider)
+								? resolvedCredentialScopes.get(provider)
+								: credentialSessionId;
 							await modelRegistry.authStorage.invalidateCredentialMatching(provider, oldKey, {
 								signal: streamOptions?.signal,
-								sessionId: credentialSessionId,
+								sessionId: resolvedScope,
 								owner: modelRegistry.getAuthStorageOwner(),
 							});
 							logger.debug("Retrying provider request after credential invalidation", {
 								provider,
 								error: error instanceof Error ? error.message : String(error),
 							});
-							return modelRegistry.getApiKey(streamModel, credentialSessionId, {
-								signal: streamOptions?.signal,
-							});
+							const replacementApiKey = await resolveAgentApiKey(provider, streamOptions?.signal);
+							if (
+								!isStableSessionApiKeyCredentialType(
+									streamOptions?.authCredentialType,
+									resolvedCredentialType(provider),
+								)
+							) {
+								return undefined;
+							}
+							return replacementApiKey;
 						},
 					});
 				} catch (error) {
@@ -4459,6 +4482,27 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			customCommands: customCommandsResult.commands,
 			skills,
 			skillWarnings,
+			reloadSkills:
+				options.skills === undefined
+					? async reloadCwd => {
+							if (!settings.get("skills.enabled")) {
+								return { skills: getEmbeddedDefaultGjcSkills(), warnings: [] };
+							} else {
+								const reloaded = await loadSkills({
+									...settings.getGroup("skills"),
+									agentDir,
+									cwd: reloadCwd,
+									disabledExtensions: settings.get("disabledExtensions"),
+								});
+								return { skills: withEmbeddedDefaultGjcSkills(reloaded.skills), warnings: reloaded.warnings };
+							}
+						}
+					: undefined,
+			onSkillsReloaded: (reloadedSkills, reloadedWarnings) => {
+				skills = reloadedSkills;
+				skillWarnings = reloadedWarnings;
+				if (!options.parentTaskPrefix) setActiveSkills(reloadedSkills);
+			},
 			skillsSettings: settings.getGroup("skills"),
 			modelRegistry,
 			taskDepth,

package/src/sdk/transport/serve-cli.ts

@@ -92,10 +92,10 @@ function brokerSessionRows(sessions: readonly unknown[]): BrokerSessionRow[] {
 }
 
 /** Exhausts strict broker `session.list` pages into one full session snapshot. */
-export async function listBrokerSessions(broker: SdkClient): Promise<BrokerSessionRow[]> {
+export async function listBrokerSessions(broker: SdkClient, explicitSessionId?: string): Promise<BrokerSessionRow[]> {
 	try {
 		const pages = await traverseSessionList(
-			{},
+			{ ...(explicitSessionId ? { resolveSessionId: explicitSessionId } : {}) },
 			async input => await broker.global("session.list", input),
 			response => {
 				brokerResult(response);
@@ -147,7 +147,7 @@ export async function runSdkServe(argv: string[]): Promise<void> {
 		throw new Error("broker_unavailable: SDK broker is not reachable");
 	}
 	try {
-		const sessionId = selectBrokerSession(await listBrokerSessions(broker), parsed.sessionId);
+		const sessionId = selectBrokerSession(await listBrokerSessions(broker, parsed.sessionId), parsed.sessionId);
 		const endpoint = brokerResult(await broker.global("session.get_endpoint", { sessionId }));
 		const url = typeof endpoint.url === "string" && endpoint.url ? endpoint.url : undefined;
 		const token = typeof endpoint.token === "string" ? endpoint.token : "";

package/src/session/agent-session.ts

@@ -36,6 +36,7 @@ import {
 	canContinuePersistedHistory,
 	dispatchedToolIdentity,
 	getAgentTerminalOwnerContext,
+	isContinuingMidRunMaintenanceOutcome,
 	isNonDispatchedToolEvent,
 	type ManagedAttemptContinuationOwnership,
 	type ManagedAttemptDecision,
@@ -882,6 +883,10 @@ export interface AgentSessionConfig {
 	skills?: Skill[];
 	/** Skill loading warnings (already captured by SDK) */
 	skillWarnings?: SkillWarning[];
+	/** Re-enumerate filesystem and marketplace skills after plugin lifecycle changes. */
+	reloadSkills?: (cwd: string) => Promise<{ skills: Skill[]; warnings: SkillWarning[] }>;
+	/** Publish a successfully committed skill catalog to SDK/process snapshots. */
+	onSkillsReloaded?: (skills: Skill[], warnings: SkillWarning[]) => void;
 	/** Custom commands (TypeScript slash commands) */
 	customCommands?: LoadedCustomCommand[];
 	skillsSettings?: SkillsSettings;
@@ -1044,7 +1049,7 @@ type AutoCompactionTerminalStatus =
 	| { kind: "compacted"; continuationScheduled?: boolean }
 	| { kind: "aborted"; source: "signal" | "hook" }
 	| { kind: "skipped"; continuationScheduled?: boolean }
-	| { kind: "failed" };
+	| { kind: "failed"; errorMessage: string };
 
 type ToolOutputPruneResult = {
 	prunedCount: number;
@@ -3124,6 +3129,8 @@ export class AgentSession {
 
 	#skills: Skill[];
 	#skillWarnings: SkillWarning[];
+	#reloadSkills: AgentSessionConfig["reloadSkills"];
+	#onSkillsReloaded: AgentSessionConfig["onSkillsReloaded"];
 
 	// Custom commands (TypeScript slash commands)
 	#customCommands: LoadedCustomCommand[] = [];
@@ -4556,6 +4563,8 @@ export class AgentSession {
 		this.agent.setMainAttemptScopeObserver(scope => this.#bindAttemptScope(scope));
 		this.#skills = config.skills ?? [];
 		this.#skillWarnings = config.skillWarnings ?? [];
+		this.#reloadSkills = config.reloadSkills;
+		this.#onSkillsReloaded = config.onSkillsReloaded;
 		this.#customCommands = config.customCommands ?? [];
 		this.#skillsSettings = config.skillsSettings;
 		this.#modelRegistry = config.modelRegistry;
@@ -5638,6 +5647,27 @@ export class AgentSession {
 		if (failures.length > 0) throw new AggregateError(failures, "Tool session cleanup failed.");
 	}
 
+	#claimToolSessionTransitionCleanups(): Promise<void> {
+		const cleanups = Array.from(this.#toolSessionTransitionCleanups);
+		this.#toolSessionTransitionCleanups.clear();
+		return this.#settleClaimedToolSessionCleanups(cleanups, "Tool session transition cleanup failed.");
+	}
+
+	#claimToolSessionCleanups(): Promise<void> {
+		const cleanups = Array.from(this.#toolSessionCleanups);
+		this.#toolSessionCleanups.clear();
+		return this.#settleClaimedToolSessionCleanups(cleanups, "Tool session cleanup failed.");
+	}
+
+	async #settleClaimedToolSessionCleanups(
+		cleanups: readonly (() => Promise<void> | void)[],
+		message: string,
+	): Promise<void> {
+		const results = await Promise.allSettled(cleanups.map(async cleanup => await cleanup()));
+		const failures = results.flatMap(result => (result.status === "rejected" ? [result.reason] : []));
+		if (failures.length > 0) throw new AggregateError(failures, message);
+	}
+
 	getAsyncJobSnapshot(options?: { recentLimit?: number }): AsyncJobSnapshot | null {
 		// The session's OWNED manager first: /jobs, the status header, and the
 		// active-background count must reflect THIS session's jobs — with
@@ -5918,7 +5948,9 @@ export class AgentSession {
 		const canonicalAdmission = this.#reserveCanonicalMessageAdmission(event);
 		const terminalOwner = event.type === "agent_end" ? getAgentTerminalOwnerContext(event) : undefined;
 		const maintenanceCheckpoint =
-			event.type === "agent_end" && event.stopReason === "maintenance" && event.maintenanceOutcome !== "aborted";
+			event.type === "agent_end" &&
+			event.stopReason === "maintenance" &&
+			isContinuingMidRunMaintenanceOutcome(event.maintenanceOutcome);
 		const terminalClaim =
 			maintenanceCheckpoint || !terminalOwner
 				? undefined
@@ -6196,9 +6228,13 @@ export class AgentSession {
 			this.#requestWorkerIntegrationAttempt();
 		}
 		// A maintenance agent_end is an internal checkpoint only while another
-		// continuation will follow. An aborted maintenance run is its terminal
-		// settlement and must reach public subscribers.
-		if (event.type === "agent_end" && event.stopReason === "maintenance" && event.maintenanceOutcome !== "aborted")
+		// continuation will follow. Failed or aborted maintenance is terminal and
+		// must reach public subscribers.
+		if (
+			event.type === "agent_end" &&
+			event.stopReason === "maintenance" &&
+			isContinuingMidRunMaintenanceOutcome(event.maintenanceOutcome)
+		)
 			return;
 
 		// Hold agent_end until the prompt's finally and all earlier async event work
@@ -6983,7 +7019,7 @@ export class AgentSession {
 
 		if (
 			event.type === "agent_end" &&
-			!(event.stopReason === "maintenance" && event.maintenanceOutcome !== "aborted")
+			!(event.stopReason === "maintenance" && isContinuingMidRunMaintenanceOutcome(event.maintenanceOutcome))
 		) {
 			this.#releaseDeferredSdkFollowUps();
 		}
@@ -6996,28 +7032,33 @@ export class AgentSession {
 			// the same run on the rewritten context (no synthetic prompt), skipping
 			// the goal-runtime / skill-state / retry / compaction finalization a
 			// normal agent_end runs — none of that applies to an in-progress run.
-			// "aborted" settles without resuming; the generation guard drops the
-			// continuation if a newer prompt/abort has moved the run on.
+			// Failed and aborted outcomes fall through to terminal handling. The
+			// generation guard drops a successful continuation if a newer prompt/abort
+			// has moved the run on.
 			if (event.stopReason === "maintenance") {
-				this.#lastAssistantMessage = undefined;
-				const outcome = event.maintenanceOutcome;
-				if (
-					outcome &&
-					outcome !== "aborted" &&
-					!maintenanceWasDisposed &&
-					!this.#isDisposed &&
-					maintenanceGeneration !== undefined &&
-					this.#promptGeneration === maintenanceGeneration
-				) {
-					this.#scheduleAgentContinue({
-						generation: maintenanceGeneration,
-						skipCompactionCheck: true,
-						resourceRunId: activePromptHandle,
-						maintenanceContinuation: true,
-						sdkRunToken: attemptScope ? this.#sdkRunTokensByAttemptScope.get(attemptScope) : undefined,
-					});
+				if (isContinuingMidRunMaintenanceOutcome(event.maintenanceOutcome)) {
+					this.#lastAssistantMessage = undefined;
+					if (
+						!maintenanceWasDisposed &&
+						!this.#isDisposed &&
+						maintenanceGeneration !== undefined &&
+						this.#promptGeneration === maintenanceGeneration
+					) {
+						this.#scheduleAgentContinue({
+							generation: maintenanceGeneration,
+							skipCompactionCheck: true,
+							resourceRunId: activePromptHandle,
+							maintenanceContinuation: true,
+							sdkRunToken: attemptScope ? this.#sdkRunTokensByAttemptScope.get(attemptScope) : undefined,
+						});
+					}
+					return;
 				}
-				return;
+				// Cancellation already owns teardown and terminal publication. Running
+				// normal post-turn finalization here can deadlock abort/dispose while the
+				// maintenance barrier is unwinding. Failed maintenance alone carries the
+				// synthetic assistant error that must flow through terminal handling.
+				if (event.maintenanceOutcome === "aborted") return;
 			}
 			const usage = this.getSessionStats().tokens;
 			await this.#goalRuntime.onAgentEnd({
@@ -7083,6 +7124,13 @@ export class AgentSession {
 				return;
 			}
 			this.#lastSuccessfulYieldToolCallId = undefined;
+			if (event.stopReason === "maintenance" && event.maintenanceOutcome === "failed") {
+				// The maintenance error already terminalized the run. Retrying this
+				// synthetic assistant failure would resubmit the unchanged context that
+				// maintenance failed to rewrite.
+				this.#resolveRetry();
+				return;
+			}
 
 			// Check for retryable errors first (overloaded, rate limit, server errors)
 			if (this.#isRetryableError(msg)) {
@@ -8580,7 +8628,8 @@ export class AgentSession {
 					? this.#sdkRunTokensByAttemptScope.get(deliveryScope as AttemptScope)
 					: undefined;
 		const isTerminalAgentEnd =
-			event.type === "agent_end" && !(event.stopReason === "maintenance" && event.maintenanceOutcome !== "aborted");
+			event.type === "agent_end" &&
+			!(event.stopReason === "maintenance" && isContinuingMidRunMaintenanceOutcome(event.maintenanceOutcome));
 		const finishAttempt = () => {
 			if (!isTerminalAgentEnd) return;
 			// A merged wake batch whose flush fired while still streaming cleared its
@@ -9371,10 +9420,10 @@ export class AgentSession {
 			// one here left signal exit orphaning the subprocess. Each runner clears
 			// its set, so a graceful dispose running first makes this a no-op rather
 			// than a double free.
-			this.#runToolSessionCleanups().catch((error: unknown) =>
+			this.#claimToolSessionCleanups().catch((error: unknown) =>
 				logger.warn("signal teardown: tool session cleanups failed", { error }),
 			),
-			this.#runToolSessionTransitionCleanups().catch((error: unknown) =>
+			this.#claimToolSessionTransitionCleanups().catch((error: unknown) =>
 				logger.warn("signal teardown: tool session transition cleanups failed", { error }),
 			),
 		]);
@@ -14200,6 +14249,25 @@ export class AgentSession {
 		await this.refreshBaseSystemPrompt();
 	}
 
+	/** Refresh the live registered-skill catalog after install/remove/reload. */
+	async reloadSkills(cwd = this.sessionManager.getCwd()): Promise<void> {
+		if (!this.#reloadSkills) return;
+		const reloaded = await this.#reloadSkills(cwd);
+		const previousSkills = this.#skills;
+		const previousWarnings = this.#skillWarnings;
+		this.#skills = reloaded.skills;
+		this.#skillWarnings = reloaded.warnings;
+		try {
+			await this.refreshBaseSystemPrompt();
+		} catch (error) {
+			this.#skills = previousSkills;
+			this.#skillWarnings = previousWarnings;
+			await this.refreshBaseSystemPrompt().catch(() => {});
+			throw error;
+		}
+		this.#onSkillsReloaded?.(reloaded.skills, reloaded.warnings);
+	}
+
 	/**
 	 * Retire the cached workspace tree after a rescope so the next turn re-scans
 	 * at the new cwd instead of re-presenting the abandoned launcher root.
@@ -18407,18 +18475,23 @@ export class AgentSession {
 	 * prune → promote → compact machinery and returns an explicit outcome.
 	 *
 	 * A non-"not-needed" outcome ends the current run losslessly
-	 * (`agent_end.stopReason === "maintenance"`); the `agent_end` handler is the
-	 * single continuation owner that resumes the run with no synthetic prompt.
-	 * This method never self-continues, runs goal-runtime hooks, clears skill
-	 * state, or emits a user-facing pause.
+	 * (`agent_end.stopReason === "maintenance"`). The `agent_end` handler resumes
+	 * committed maintenance with no synthetic prompt and terminalizes failed or
+	 * aborted maintenance. This method never self-continues, runs goal-runtime
+	 * hooks, clears skill state, or emits a user-facing pause.
 	 */
 	async #runMidRunMaintenance(
 		context: AgentContext,
 		lifecycle: MidRunMaintenanceLifecycle,
 	): Promise<ContextMaintenanceResult> {
-		const result = (outcome: MidRunMaintenanceOutcome, releaseCurrentContext = false): ContextMaintenanceResult => ({
+		const result = (
+			outcome: MidRunMaintenanceOutcome,
+			releaseCurrentContext = false,
+			errorMessage?: string,
+		): ContextMaintenanceResult => ({
 			outcome,
 			...(releaseCurrentContext ? { releaseCurrentContext: true } : {}),
+			...(errorMessage ? { errorMessage } : {}),
 		});
 		if (this.#isDisposed) return { outcome: "aborted" };
 		const invocationController = new AbortController();
@@ -18529,7 +18602,13 @@ export class AgentSession {
 			if (compactionStatus.kind === "aborted") {
 				return compactionStatus.source === "hook" ? result("not-needed") : result("aborted");
 			}
-			return result("failed");
+			return result(
+				"failed",
+				false,
+				compactionStatus.kind === "failed"
+					? compactionStatus.errorMessage
+					: "Context maintenance could not commit a compaction before the next model request.",
+			);
 		} finally {
 			this.#activeMidRunBarrierControllers.delete(invocationController);
 		}
@@ -19643,12 +19722,15 @@ export class AgentSession {
 	 */
 	#maintenanceProviderTransport(): {
 		sessionId: string | undefined;
+		providerSessionId: string | undefined;
 		providerSessionState: Map<string, ProviderSessionState>;
 		preferWebsockets: boolean | undefined;
 		remoteCompactionFallbackHealth: RemoteCompactionFallbackHealthHooks;
 	} {
+		const providerSessionId = this.agent.providerSessionId ?? this.agent.sessionId;
 		return {
-			sessionId: this.agent.providerSessionId ?? this.agent.sessionId,
+			sessionId: providerSessionId,
+			providerSessionId,
 			providerSessionState: this.#providerSessionState,
 			preferWebsockets: this.agent.preferWebsockets,
 			remoteCompactionFallbackHealth: this.#remoteCompactionFallbackHealth,
@@ -20286,7 +20368,7 @@ export class AgentSession {
 						? `Context overflow recovery failed: ${errorMessage}`
 						: `Auto-compaction failed: ${errorMessage}`,
 			});
-			return { kind: "failed" };
+			return { kind: "failed", errorMessage };
 		} finally {
 			if (this.#autoCompactionAbortController === autoCompactionAbortController) {
 				this.#autoCompactionAbortController = undefined;
@@ -22350,7 +22432,10 @@ export class AgentSession {
 				onChunk,
 				signal: abortController.signal,
 			});
-			this.recordPythonResult(code, result, options);
+			// A retained kernel can finish after strict session close has fenced
+			// persistence. The caller still receives its completed result, but it
+			// must not reopen a closing session to append history.
+			if (!this.#evalExecutionDisposing) this.recordPythonResult(code, result, options);
 			return result;
 		})();
 		return await this.trackEvalExecution(execution, abortController);