@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/session/agent-session.ts

@@ -36,6 +36,7 @@ import {
 	canContinuePersistedHistory,
 	dispatchedToolIdentity,
 	getAgentTerminalOwnerContext,
+	isContinuingMidRunMaintenanceOutcome,
 	isNonDispatchedToolEvent,
 	type ManagedAttemptContinuationOwnership,
 	type ManagedAttemptDecision,
@@ -438,6 +439,7 @@ import {
 	type ConfiguredFallbackChain,
 	cappedExponentialWithFullJitter,
 	compactionRetryDelay,
+	describeCompactionCandidateFailures,
 	effectiveFallbackDelay,
 	FallbackChainController,
 	type FallbackChainRuntimeState,
@@ -882,6 +884,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 +1050,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;
@@ -2786,7 +2792,7 @@ export class AgentSession {
 		this.#activeAttemptScope = undefined;
 		this.#activeLogicalRunId = undefined;
 	}
-	#acceptSdkAttemptRun(handle: AttemptRunHandle, sdkRunToken?: string): void {
+	#acceptSdkAttemptRun(handle: AttemptRunHandle, sdkRunToken?: string, sdkRunTokens?: string[]): void {
 		const predecessorScope = this.#activeAttemptScope;
 		const predecessorSdkRunToken =
 			predecessorScope === undefined ? undefined : this.#sdkRunTokensByAttemptScope.get(predecessorScope);
@@ -2799,6 +2805,11 @@ export class AgentSession {
 		if (sdkRunToken !== undefined) {
 			this.#activeSdkRunToken = sdkRunToken;
 			this.#sdkRunTokensByAttemptScope.set(handle.scope, sdkRunToken);
+			const inheritedCohort =
+				predecessorScope !== undefined && predecessorSdkRunToken === sdkRunToken
+					? this.#sdkRunCohortsByAttemptScope.get(predecessorScope)
+					: undefined;
+			this.#sdkRunCohortsByAttemptScope.set(handle.scope, sdkRunTokens ?? inheritedCohort ?? [sdkRunToken]);
 		}
 		if (carryRecoverySkip) this.#skipPostPromptRecoveryWaitByAttemptScope.add(handle.scope);
 	}
@@ -3103,6 +3114,7 @@ export class AgentSession {
 	#sdkRunTokensByQueuedMessage = new WeakMap<AgentMessage, string>();
 	#skipPostPromptRecoveryWaitByAttemptScope = new WeakSet<AttemptScope>();
 	#sdkRunTokensByAttemptScope = new WeakMap<AttemptScope, string>();
+	#sdkRunCohortsByAttemptScope = new WeakMap<AttemptScope, string[]>();
 	#activeSdkRunToken: string | undefined;
 	#activeAttemptScope: AttemptScope | undefined;
 	#attemptAuthority!: AttemptScopeAuthority;
@@ -3124,6 +3136,8 @@ export class AgentSession {
 
 	#skills: Skill[];
 	#skillWarnings: SkillWarning[];
+	#reloadSkills: AgentSessionConfig["reloadSkills"];
+	#onSkillsReloaded: AgentSessionConfig["onSkillsReloaded"];
 
 	// Custom commands (TypeScript slash commands)
 	#customCommands: LoadedCustomCommand[] = [];
@@ -4556,6 +4570,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;
@@ -4569,7 +4585,7 @@ export class AgentSession {
 		this.#transformContext = config.transformContext ?? (messages => messages);
 		const configuredOnPayload = config.onPayload;
 		this.#onPayload = configuredOnPayload
-			? (payload, model, scope) => configuredOnPayload(payload, model, scope)
+			? (payload, model, scope, signal) => configuredOnPayload(payload, model, scope, signal)
 			: undefined;
 		this.rawSseDebugBuffer = config.rawSseDebugBuffer ?? new RawSseDebugBuffer();
 		// Avoid wrapping in an `async` closure when no user callback is configured: the
@@ -4578,9 +4594,9 @@ export class AgentSession {
 		// shows up as ~3.5% self time in streaming profiles.
 		const configuredOnResponse = config.onResponse;
 		this.#onResponse = configuredOnResponse
-			? async (response, model, scope) => {
+			? async (response, model, scope, signal) => {
 					this.rawSseDebugBuffer.recordResponse(response, model);
-					await configuredOnResponse(response, model, scope);
+					await configuredOnResponse(response, model, scope, signal);
 				}
 			: (response, model, _scope) => {
 					this.rawSseDebugBuffer.recordResponse(response, model);
@@ -5638,6 +5654,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 +5955,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 +6235,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
@@ -6889,12 +6932,15 @@ export class AgentSession {
 					assistantMsg.stopReason !== "aborted" &&
 					this.#retryAttempt > 0
 				) {
+					// Clear ownership before notifying observers: agent_end may run while
+					// the success event is awaiting its subscribers.
+					const attempt = this.#retryAttempt;
+					this.#retryAttempt = 0;
 					await this.#emitSessionEvent({
 						type: "auto_retry_end",
 						success: true,
-						attempt: this.#retryAttempt,
+						attempt,
 					});
-					this.#retryAttempt = 0;
 					// Settle the retry gate here, colocated with the success event, rather
 					// than relying on the generic #resolveRetry() at the end of the
 					// agent_end branch. That tail resolver is bypassed by every early
@@ -6983,7 +7029,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 +7042,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 +7134,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)) {
@@ -7482,15 +7540,19 @@ export class AgentSession {
 												const inheritedSdkRunToken = options?.continueQueuedOnly
 													? undefined
 													: (options?.sdkRunToken ?? scheduledSdkRunToken);
-												const consumedSdkRunToken = acceptance.consumedQueuedMessages
+												const consumedSdkRunTokens = acceptance.consumedQueuedMessages
 													.map(message => this.#sdkRunTokensByQueuedMessage.get(message))
-													.find((token): token is string => token !== undefined);
-												const sdkRunToken = consumedSdkRunToken ?? inheritedSdkRunToken;
+													.filter((token): token is string => token !== undefined);
+												const sdkRunToken = consumedSdkRunTokens[0] ?? inheritedSdkRunToken;
 												this.#fireQueuedPromotionHooks(acceptance.consumedQueuedMessages, {
 													startsOwnRun: startsOwn,
 												});
 												if (startsOwn) this.#activeSdkRunToken = sdkRunToken;
-												this.#acceptSdkAttemptRun(handle, sdkRunToken);
+												this.#acceptSdkAttemptRun(
+													handle,
+													sdkRunToken,
+													consumedSdkRunTokens.length > 0 ? consumedSdkRunTokens : undefined,
+												);
 												options?.onRunAccepted?.(handle);
 												// Keep the queued token available through the acceptance callback;
 												// SDK follow-up owners bind it to the new attempt scope there.
@@ -8580,7 +8642,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
@@ -8625,6 +8688,9 @@ export class AgentSession {
 					{
 						type: "agent_start",
 						...(sdkRunToken ? { sdkRunToken } : {}),
+						...(deliveryScope
+							? { sdkRunTokens: this.#sdkRunCohortsByAttemptScope.get(deliveryScope as AttemptScope) }
+							: {}),
 					},
 					undefined,
 					deliveryScope,
@@ -9371,10 +9437,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 }),
 			),
 		]);
@@ -9500,6 +9566,11 @@ export class AgentSession {
 		});
 	}
 
+	/** Test seam: await all currently admitted coordinator sidecar writes. */
+	async awaitCoordinatorRuntimeStatePersistenceForTests(): Promise<void> {
+		await this.#coordinatorPersistQueue;
+		await this.#drainUnbarrieredCoordinatorPersists();
+	}
 	queueCoordinatorRuntimeStatePersistForTests(event: AgentSessionEvent, gate: Promise<void>): Promise<void> {
 		this.#agentEventAdmission.set(event, {
 			persistGeneration: this.#coordinatorPersistGeneration,
@@ -10226,11 +10297,12 @@ export class AgentSession {
 		let wrappersByVersion = this.#guardedToolWrapperCache.get(tool);
 		const cached = wrappersByVersion?.get(cacheKey);
 		if (cached) return cached as T;
-		const wrapped = this.#wrapToolForCwdTransitionFence(
+		const innerTool = tool instanceof ExtensionToolWrapper ? tool.getInnerTool() : tool;
+		const guarded = this.#wrapToolForCwdTransitionFence(
 			this.#wrapToolForWorkflowMutationGuard(
 				this.#wrapToolForAcpPermission(
 					guardToolForUltragoalAsk(
-						tool,
+						innerTool,
 						() => this.sessionManager.getCwd(),
 						() => ({
 							activeSkillState: this.getActiveSkillState(),
@@ -10241,6 +10313,7 @@ export class AgentSession {
 				),
 			),
 		);
+		const wrapped = (this.#extensionRunner ? new ExtensionToolWrapper(guarded, this.#extensionRunner) : guarded) as T;
 		// The object published into `agent.state.tools` — and therefore the object the
 		// agent loop actually dispatches to — is this guard wrapper, not the registry
 		// entry. A wrapper built from a proven built-in inherits that proof; one built
@@ -10921,10 +10994,10 @@ export class AgentSession {
 				preparedOptions.onPayload = sessionOnPayload;
 			} else {
 				const requestOnPayload = options.onPayload;
-				preparedOptions.onPayload = async (payload, model, callbackScope) => {
-					const sessionPayload = await sessionOnPayload(payload, model, callbackScope);
+				preparedOptions.onPayload = async (payload, model, callbackScope, signal) => {
+					const sessionPayload = await sessionOnPayload(payload, model, callbackScope, signal);
 					const sessionResolvedPayload = sessionPayload ?? payload;
-					const requestPayload = await requestOnPayload(sessionResolvedPayload, model, callbackScope);
+					const requestPayload = await requestOnPayload(sessionResolvedPayload, model, callbackScope, signal);
 					return requestPayload ?? sessionResolvedPayload;
 				};
 			}
@@ -10935,9 +11008,9 @@ export class AgentSession {
 				preparedOptions.onResponse = sessionOnResponse;
 			} else {
 				const requestOnResponse = options.onResponse;
-				preparedOptions.onResponse = async (response, model, callbackScope) => {
-					await sessionOnResponse(response, model, callbackScope);
-					await requestOnResponse(response, model, callbackScope);
+				preparedOptions.onResponse = async (response, model, callbackScope, signal) => {
+					await sessionOnResponse(response, model, callbackScope, signal);
+					await requestOnResponse(response, model, callbackScope, signal);
 				};
 			}
 		}
@@ -11818,6 +11891,11 @@ export class AgentSession {
 		const releaseStartupPromptWaiter = this.#reserveStartupPromptWaiter();
 		try {
 			await this.#promptInternal(text, options, releaseStartupPromptWaiter);
+			// Agent-core converts listener failures into an aborted response. Keep a
+			// rejected persistence fence typed at the public prompt boundary instead
+			// of reporting the misleading provider-level "Request was aborted".
+			const appendRejection = this.sessionManager.getAppendIdentityMismatch();
+			if (appendRejection) throw appendRejection;
 		} finally {
 			releaseStartupPromptWaiter();
 		}
@@ -12409,6 +12487,14 @@ export class AgentSession {
 			hasPendingNextTurnMessages = pendingNextTurnMessageCount > 0;
 			const promptAttribution: "user" | "agent" | undefined =
 				"attribution" in message ? message.attribution : undefined;
+			let effectivePrompt = expandedText;
+			const messageImages =
+				"content" in message && Array.isArray(message.content)
+					? message.content.filter((content): content is ImageContent => content.type === "image")
+					: undefined;
+			let effectiveImages =
+				options?.images ?? (messageImages && messageImages.length > 0 ? messageImages : undefined);
+			let promptMessage = message;
 			let phaseACompleted = false;
 			let fileMentionMessages: AgentMessage[] = [];
 			let beforeAgentStartResultMessages: BeforeAgentStartInternalMessage[] = [];
@@ -12429,7 +12515,49 @@ export class AgentSession {
 				if (!phaseACompleted) {
 					phaseACompleted = true;
 					// Phase A (one-time side-effectful products; runs once).
-					const fileMentions = extractFileMentions(expandedText);
+					const beforeAgentStartSystemPrompt = await this.#buildSystemPromptForAgentStart(effectivePrompt);
+					hindsightRecall = this.getHindsightSessionState()?.getRecallSnippetForInjection();
+					planReferenceMessage = await this.#buildPlanReferenceMessage();
+					// Emit before_agent_start extension event. Race hook completion with
+					// prompt cancellation so a wedged hook cannot retain SDK prompt authority.
+					if (this.#extensionRunner?.hasHandlers("before_agent_start")) this.#markRetryReplayUnsafe();
+					if (this.#extensionRunner) {
+						const result = await this.#awaitPromptPreflight(
+							generation,
+							preflightSignal,
+							this.#extensionRunner.emitBeforeAgentStart(
+								effectivePrompt,
+								effectiveImages,
+								beforeAgentStartSystemPrompt,
+								preflightSignal,
+							),
+						);
+						if (result?.messages) beforeAgentStartResultMessages = [...result.messages];
+						if (result?.prompt !== undefined) effectivePrompt = result.prompt;
+						if (result && Object.hasOwn(result, "images")) effectiveImages = result.images;
+						if (result?.prompt !== undefined || (result && Object.hasOwn(result, "images"))) {
+							if (
+								promptMessage.role === "user" ||
+								promptMessage.role === "developer" ||
+								promptMessage.role === "custom"
+							) {
+								promptMessage = {
+									...promptMessage,
+									content: [{ type: "text", text: effectivePrompt }, ...(effectiveImages ?? [])],
+								};
+							}
+						}
+						if (result?.systemPrompt !== undefined) {
+							this.agent.setSystemPrompt(result.systemPrompt);
+						} else if (result?.prompt !== undefined) {
+							this.agent.setSystemPrompt(await this.#buildSystemPromptForAgentStart(effectivePrompt));
+						} else {
+							this.agent.setSystemPrompt(beforeAgentStartSystemPrompt);
+						}
+					} else {
+						this.agent.setSystemPrompt(beforeAgentStartSystemPrompt);
+					}
+					const fileMentions = extractFileMentions(effectivePrompt);
 					if (fileMentions.length > 0) {
 						const cwd = this.sessionManager.getCwd();
 						// Collect resolved paths already shown (read or mentioned) in the
@@ -12457,31 +12585,6 @@ export class AgentSession {
 							recentlyShownPaths,
 						});
 					}
-					const beforeAgentStartSystemPrompt = await this.#buildSystemPromptForAgentStart(expandedText);
-					hindsightRecall = this.getHindsightSessionState()?.getRecallSnippetForInjection();
-					planReferenceMessage = await this.#buildPlanReferenceMessage();
-					// Emit before_agent_start extension event. Race hook completion with
-					// prompt cancellation so a wedged hook cannot retain SDK prompt authority.
-					if (this.#extensionRunner?.hasHandlers("before_agent_start")) this.#markRetryReplayUnsafe();
-					if (this.#extensionRunner) {
-						const result = await this.#awaitPromptPreflight(
-							generation,
-							preflightSignal,
-							this.#extensionRunner.emitBeforeAgentStart(
-								expandedText,
-								options?.images,
-								beforeAgentStartSystemPrompt,
-							),
-						);
-						if (result?.messages) beforeAgentStartResultMessages = [...result.messages];
-						if (result?.systemPrompt !== undefined) {
-							this.agent.setSystemPrompt(result.systemPrompt);
-						} else {
-							this.agent.setSystemPrompt(beforeAgentStartSystemPrompt);
-						}
-					} else {
-						this.agent.setSystemPrompt(beforeAgentStartSystemPrompt);
-					}
 					// Invoke first-party internal before-agent-start contributors. These
 					// run alongside the extension runner (not via user-loaded hooks) and
 					// append through the same custom-message attribution path. Errors are nonfatal.
@@ -12492,8 +12595,8 @@ export class AgentSession {
 									generation,
 									preflightSignal,
 									contributor({
-										prompt: expandedText,
-										images: options?.images,
+										prompt: effectivePrompt,
+										images: effectiveImages,
 										sessionId: this.sessionId,
 									}),
 								);
@@ -12551,7 +12654,7 @@ export class AgentSession {
 				}
 
 				const promptIndex = messages.length;
-				messages.push(message);
+				messages.push(promptMessage);
 
 				// Re-present captured pending next-turn messages (never drained here).
 				// Reclassify deferred envelopes before injecting them into the new
@@ -14200,6 +14303,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 +18529,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 +18656,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);
 		}
@@ -19356,10 +19489,10 @@ export class AgentSession {
 					isError: message.isError,
 					content: this.#normalizeProviderReplayValue(message.content),
 				};
-			case "bashExecution":
+			case "pythonExecution":
 				return {
 					role: message.role,
-					command: message.command,
+					code: message.code,
 					output: message.output,
 					exitCode: message.exitCode,
 					cancelled: message.cancelled,
@@ -19377,12 +19510,13 @@ export class AgentSession {
 						: undefined,
 					excludeFromContext: message.excludeFromContext,
 				};
-			case "pythonExecution":
+			case "bashExecution":
 				return {
 					role: message.role,
-					code: message.code,
+					command: message.command,
 					output: message.output,
 					exitCode: message.exitCode,
+					signal: message.signal,
 					cancelled: message.cancelled,
 					meta: message.meta
 						? {
@@ -19643,12 +19777,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,
@@ -20078,6 +20215,10 @@ export class AgentSession {
 				const telemetry = resolveTelemetry(this.agent.telemetry, this.sessionId);
 				let compactResult: CompactionResult | undefined;
 				let lastError: unknown;
+				// Every candidate that was tried and failed, in order. Only the last failure
+				// used to reach the user, which named whichever same-provider fallback the
+				// chain ended on and hid that the session model itself had already failed.
+				const candidateFailures: Array<{ model: string; message: string }> = [];
 
 				for (const candidate of candidates) {
 					const apiKey = await this.#modelRegistry.getApiKey(candidate, this.credentialSessionId);
@@ -20111,6 +20252,7 @@ export class AgentSession {
 							const message = error instanceof Error ? error.message : String(error);
 							if (this.#isCompactionAuthFailure(error)) {
 								lastError = this.#buildCompactionAuthError();
+								candidateFailures.push({ model: `${candidate.provider}/${candidate.id}`, message });
 								break;
 							}
 							const retryAfterMs = this.#parseRetryAfterMsFromError(message);
@@ -20123,6 +20265,7 @@ export class AgentSession {
 									isUsageLimitError(message));
 							if (!shouldRetry) {
 								lastError = error;
+								candidateFailures.push({ model: `${candidate.provider}/${candidate.id}`, message });
 								break;
 							}
 
@@ -20147,6 +20290,7 @@ export class AgentSession {
 										model: `${candidate.provider}/${candidate.id}`,
 									});
 									lastError = error;
+									candidateFailures.push({ model: `${candidate.provider}/${candidate.id}`, message });
 									break; // Exit retry loop, continue to next candidate
 								}
 								// No more candidates - we have to wait
@@ -20172,7 +20316,9 @@ export class AgentSession {
 
 				if (!compactResult) {
 					if (lastError) {
-						throw lastError;
+						throw candidateFailures.length > 1
+							? describeCompactionCandidateFailures(candidateFailures, lastError)
+							: lastError;
 					}
 					throw new Error("Compaction failed: no available model");
 				}
@@ -20286,7 +20432,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;
@@ -22247,6 +22393,7 @@ export class AgentSession {
 			command,
 			output: result.output,
 			exitCode: result.exitCode,
+			signal: result.signal,
 			cancelled: result.cancelled,
 			truncated: result.truncated,
 			meta,
@@ -22350,7 +22497,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);