@gajae-code/coding-agent 0.2.5 → 0.3.1

package/src/session/agent-session.ts

@@ -167,10 +167,12 @@ import type { HookCommandContext } from "../extensibility/hooks/types";
 import type { Skill, SkillWarning } from "../extensibility/skills";
 import { expandSlashCommand, type FileSlashCommand } from "../extensibility/slash-commands";
 import { buildGjcRuntimeSessionEnv, consumePendingGoalModeRequest } from "../gjc-runtime/goal-mode-request";
+import { writeArtifact } from "../gjc-runtime/state-writer";
 import { requestGjcWorkerIntegrationAttempt } from "../gjc-runtime/team-runtime";
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
+import { ensureWorkflowSkillActivationState } from "../hooks/skill-state";
 import { type LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
 import { resolveMemoryBackend } from "../memory-backend";
 import { getCurrentThemeName, theme } from "../modes/theme/theme";
@@ -263,7 +265,14 @@ export type AgentSessionEvent =
 			/** True when compaction was skipped for a benign reason (no model, no candidates, nothing to compact). */
 			skipped?: boolean;
 	  }
-	| { type: "auto_retry_start"; attempt: number; maxAttempts: number; delayMs: number; errorMessage: string }
+	| {
+			type: "auto_retry_start";
+			attempt: number;
+			maxAttempts: number;
+			delayMs: number;
+			errorMessage: string;
+			unbounded?: boolean;
+	  }
 	| { type: "auto_retry_end"; success: boolean; attempt: number; finalError?: string }
 	| { type: "retry_fallback_applied"; from: string; to: string; role: string }
 	| { type: "retry_fallback_succeeded"; model: string; role: string }
@@ -282,9 +291,14 @@ export type AgentSessionEvent =
  */
 const SAFE_PATH_COMPONENT = /^[A-Za-z0-9_-][A-Za-z0-9._-]{0,63}$/;
 
+function isUnderProjectGjc(cwd: string, targetPath: string): boolean {
+	const relative = path.relative(path.join(path.resolve(cwd), ".gjc"), path.resolve(targetPath));
+	return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime">;
+export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime" | "metadata">;
 
 export interface AsyncJobSnapshot {
 	running: AsyncJobSnapshotItem[];
@@ -852,12 +866,14 @@ export class AgentSession {
 
 	// Retry state
 	#retryAbortController: AbortController | undefined = undefined;
+	#retryNowRequested = false;
 	#retryAttempt = 0;
 	#retryPromise: Promise<void> | undefined = undefined;
 	#retryResolve: (() => void) | undefined = undefined;
 	#activeRetryFallback: ActiveRetryFallbackState | undefined = undefined;
 	// Todo completion reminder state
 	#todoReminderCount = 0;
+	#lastGoalReminderAssistantTimestamp: number | undefined = undefined;
 	#todoPhases: TodoPhase[] = [];
 	#toolChoiceQueue = new ToolChoiceQueue();
 
@@ -958,6 +974,12 @@ export class AgentSession {
 	 *  without producing an aborted message_end). */
 	#planCompactAbortPending = false;
 
+	/** One-shot flag armed by `abort({ silent: true })` (e.g. Esc consuming a
+	 *  queued steer). Consumed in #handleAgentEvent to stamp `SILENT_ABORT_MARKER`
+	 *  on the resulting aborted assistant `message_end` so the interrupt does not
+	 *  surface a red "Operation aborted" line; cleared by a later non-silent abort
+	 *  or by `abort`'s safety net when no aborted message_end is produced. */
+	#silentAbortPending = false;
 	/** Monotonic counter for `enqueueCustomMessageDisplay` tag generation;
 	 *  combined with `Date.now()` so tags stay unique even across rapid
 	 *  same-tick enqueues. */
@@ -1036,6 +1058,7 @@ export class AgentSession {
 		this.#promptInFlightCount = Math.max(0, this.#promptInFlightCount - 1);
 		if (this.#promptInFlightCount === 0) {
 			this.#releasePowerAssertion();
+			this.#flushPendingBackgroundExchanges();
 			this.#flushPendingAgentEnd();
 		}
 	}
@@ -1043,6 +1066,7 @@ export class AgentSession {
 	#resetInFlight(): void {
 		this.#promptInFlightCount = 0;
 		this.#releasePowerAssertion();
+		this.#flushPendingBackgroundExchanges();
 		this.#flushPendingAgentEnd();
 	}
 
@@ -1471,6 +1495,10 @@ export class AgentSession {
 		return tag;
 	}
 
+	getAgentId(): string | undefined {
+		return this.#agentId;
+	}
+
 	getAsyncJobSnapshot(options?: { recentLimit?: number }): AsyncJobSnapshot | null {
 		const manager = AsyncJobManager.instance();
 		if (!manager) return null;
@@ -1481,6 +1509,7 @@ export class AgentSession {
 			status: job.status,
 			label: job.label,
 			startTime: job.startTime,
+			metadata: job.metadata,
 		}));
 		const recent = manager.getRecentJobs(options?.recentLimit ?? 5, ownerFilter).map(job => ({
 			id: job.id,
@@ -1488,6 +1517,7 @@ export class AgentSession {
 			status: job.status,
 			label: job.label,
 			startTime: job.startTime,
+			metadata: job.metadata,
 		}));
 		const delivery = manager.getDeliveryState(ownerFilter);
 		return { running, recent, delivery };
@@ -1630,10 +1660,11 @@ export class AgentSession {
 			event.type === "message_end" &&
 			event.message.role === "assistant" &&
 			event.message.stopReason === "aborted" &&
-			this.#planCompactAbortPending
+			(this.#planCompactAbortPending || this.#silentAbortPending)
 		) {
 			(event.message as AssistantMessage).errorMessage = SILENT_ABORT_MARKER;
 			this.#planCompactAbortPending = false;
+			this.#silentAbortPending = false;
 		}
 
 		// Deobfuscate assistant message content for display emission — the LLM echoes back
@@ -1887,6 +1918,15 @@ export class AgentSession {
 						attempt: this.#retryAttempt,
 					});
 					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
+					// return in agent_end (successful `yield`, handoff-abort skip-maintenance,
+					// missing assistant message), so a retry that recovers on a yield turn
+					// would otherwise leave #retryPromise unresolved — wedging
+					// #waitForPostPromptRecovery and the session as permanently busy.
+					// #resolveRetry() is idempotent, so the later tail call is a no-op.
+					this.#resolveRetry();
 				}
 			}
 
@@ -1992,6 +2032,9 @@ export class AgentSession {
 
 			if (this.#assistantEndedWithSuccessfulYield(msg)) {
 				this.#lastSuccessfulYieldToolCallId = undefined;
+				if (msg.stopReason !== "error" && msg.stopReason !== "aborted" && (await this.#checkGoalCompletion(msg))) {
+					return;
+				}
 				return;
 			}
 			this.#lastSuccessfulYieldToolCallId = undefined;
@@ -2001,6 +2044,18 @@ export class AgentSession {
 				const didRetry = await this.#handleRetryableError(msg);
 				if (didRetry) return; // Retry was initiated, don't proceed to compaction
 			}
+			if (this.#retryAttempt > 0) {
+				// A prior retry ended on a non-retryable (terminal) message: emit
+				// the terminal retry-end and reset so observers clear retry state.
+				const attempt = this.#retryAttempt;
+				this.#retryAttempt = 0;
+				await this.#emitSessionEvent({
+					type: "auto_retry_end",
+					success: false,
+					attempt,
+					finalError: msg.errorMessage,
+				});
+			}
 			this.#resolveRetry();
 
 			const compactionTask = this.#checkCompaction(msg);
@@ -2015,6 +2070,9 @@ export class AgentSession {
 				if (this.#enforceRewindBeforeYield()) {
 					return;
 				}
+				if (await this.#checkGoalCompletion(msg)) {
+					return;
+				}
 				await this.#checkTodoCompletion();
 			}
 		}
@@ -2103,13 +2161,23 @@ export class AgentSession {
 		delayMs?: number;
 		generation?: number;
 		shouldContinue?: () => boolean;
-		onSkip?: () => void;
-		onError?: () => void;
+		onSkip?: (reason: "generation_changed" | "aborted_signal" | "queue_drained") => void;
+		onError?: (error: unknown) => void;
 	}): void {
+		const scheduledGeneration = options?.generation;
+		const signal = this.#postPromptTasksAbortController.signal;
 		this.#schedulePostPromptTask(
 			async () => {
+				if (signal.aborted) {
+					options?.onSkip?.("aborted_signal");
+					return;
+				}
+				if (scheduledGeneration !== undefined && this.#promptGeneration !== scheduledGeneration) {
+					options?.onSkip?.("generation_changed");
+					return;
+				}
 				if (options?.shouldContinue && !options.shouldContinue()) {
-					options.onSkip?.();
+					options.onSkip?.("queue_drained");
 					return;
 				}
 				try {
@@ -2119,17 +2187,45 @@ export class AgentSession {
 					logger.warn("agent.continue failed after scheduling", {
 						error: error instanceof Error ? error.message : String(error),
 					});
-					options?.onError?.();
+					options?.onError?.(error);
 				}
 			},
-			{
-				delayMs: options?.delayMs,
-				generation: options?.generation,
-				onSkip: options?.onSkip,
-			},
+			{ delayMs: options?.delayMs },
 		);
 	}
 
+	#logCompactionContinuationSkipped(
+		source: "auto_continue_prompt" | "queued_continue" | "overflow_retry",
+		reason: string,
+	): void {
+		logger.warn("Auto-compaction continuation skipped", { source, reason });
+	}
+
+	#logCompactionContinuationError(
+		source: "auto_continue_prompt" | "queued_continue" | "overflow_retry",
+		error: unknown,
+	): void {
+		logger.warn("Auto-compaction continuation failed", {
+			source,
+			reason: error instanceof Error && error.name === "AgentBusyError" ? "queue_drained" : "not_resumable_tail",
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
+
+	#isResumableAgentTail(): boolean {
+		const lastMsg = this.agent.state.messages.at(-1);
+		return lastMsg !== undefined && lastMsg.role !== "assistant";
+	}
+
+	#stripOverflowFailedTurnForRetry(): void {
+		const messages = this.agent.state.messages;
+		const lastMsg = messages.at(-1);
+		const contextWindow = this.model?.contextWindow ?? 0;
+		if (lastMsg?.role === "assistant" && isContextOverflow(lastMsg as AssistantMessage, contextWindow)) {
+			this.agent.replaceMessages(messages.slice(0, -1));
+		}
+	}
+
 	#scheduleAutoContinuePrompt(generation: number): void {
 		const continuePrompt = async () => {
 			await this.#promptWithMessage(
@@ -2140,16 +2236,28 @@ export class AgentSession {
 					timestamp: Date.now(),
 				},
 				autoContinuePrompt,
-				{ skipPostPromptRecoveryWait: true },
+				{ skipPostPromptRecoveryWait: true, skipCompactionCheck: true },
 			);
 		};
-		this.#schedulePostPromptTask(
-			async signal => {
+		const scheduledGeneration = generation;
+		const signal = this.#postPromptTasksAbortController.signal;
+		this.#trackPostPromptTask(
+			(async () => {
 				await Promise.resolve();
-				if (signal.aborted) return;
-				await continuePrompt();
-			},
-			{ generation },
+				if (signal.aborted) {
+					this.#logCompactionContinuationSkipped("auto_continue_prompt", "aborted_signal");
+					return;
+				}
+				if (this.#promptGeneration !== scheduledGeneration) {
+					this.#logCompactionContinuationSkipped("auto_continue_prompt", "generation_changed");
+					return;
+				}
+				try {
+					await continuePrompt();
+				} catch (error) {
+					this.#logCompactionContinuationError("auto_continue_prompt", error);
+				}
+			})(),
 		);
 	}
 
@@ -2871,6 +2979,7 @@ export class AgentSession {
 				maxAttempts: event.maxAttempts,
 				delayMs: event.delayMs,
 				errorMessage: event.errorMessage,
+				unbounded: event.unbounded,
 			});
 		} else if (event.type === "auto_retry_end") {
 			await this.#extensionRunner.emit({
@@ -3485,7 +3594,7 @@ export class AgentSession {
 	 * prompts or tool execution can run.
 	 */
 	#wrapToolForDeepInterviewMutationGuard<T extends AgentTool>(tool: T): T {
-		if (!["edit", "write", "ast_edit"].includes(tool.name)) return tool;
+		if (!["edit", "write", "ast_edit", "bash"].includes(tool.name)) return tool;
 		return new Proxy(tool, {
 			get: (target, prop) => {
 				if (prop !== "execute") return Reflect.get(target, prop, target);
@@ -4291,12 +4400,17 @@ export class AgentSession {
 		// Canonical GJC workflow skills (deep-interview, ralplan, ultragoal, team)
 		// own their `.gjc/state/skill-active-state.json` row through the
 		// `gjc state handoff` and `gjc state clear` runtime verbs. The prompt
-		// observer here used to overwrite the row with `phase: running` and
-		// later remove it with `active:false`, which clobbered handoff lineage
-		// (`handoff_from`/`handoff_at`) and made the HUD inconsistent with
-		// mode-state. The observational filesystem write is now skipped for
-		// canonical skills; the in-memory `#activeSkillState` tracking below
-		// keeps `getActiveSkillState` accurate for the chain guard.
+		// observer must not overwrite an existing row (that clobbered handoff
+		// lineage `handoff_from`/`handoff_at` and desynced the HUD). But a fresh
+		// `/skill:<name>` invocation has no row yet, so seed `.gjc/state`
+		// idempotently here: `ensureWorkflowSkillActivationState` writes the
+		// initial mode-state + active row only when the skill is not already
+		// active, so the mutation guard and Stop hook engage immediately instead
+		// of relying on the skill prompt to run its own state-init steps.
+		if (active) {
+			await ensureWorkflowSkillActivationState({ cwd: this.sessionManager.getCwd(), skill, sessionId });
+		}
+		// In-memory tracking keeps `getActiveSkillState` accurate for the chain guard.
 		this.#activeSkillState = active ? { skill, sessionId } : undefined;
 	}
 
@@ -4942,6 +5056,13 @@ export class AgentSession {
 		return this.#steeringMessages.length + this.#followUpMessages.length + this.#pendingNextTurnMessages.length;
 	}
 
+	/** Whether the agent has queued steering messages that a `user_interrupt`
+	 *  abort would resume into (steer-on-interrupt). Drives the Esc-on-steer UX:
+	 *  the first Esc consumes the steer and auto-continues, a second Esc aborts. */
+	get hasQueuedSteering(): boolean {
+		return this.agent.hasQueuedSteering();
+	}
+
 	/** Get pending messages (read-only). Returns the public text-only view;
 	 *  internal `{text, tag?}` records are mapped to `.text` so callers
 	 *  (`updatePendingMessagesDisplay`, `restoreQueuedMessagesToEditor`) see
@@ -5027,7 +5148,28 @@ export class AgentSession {
 	/**
 	 * Abort current operation and wait for agent to become idle.
 	 */
-	async abort(options?: { goalReason?: "interrupted" | "internal"; timeoutMs?: number }): Promise<void> {
+	async abort(options?: {
+		goalReason?: "interrupted" | "internal";
+		timeoutMs?: number;
+		cause?:
+			| "user_interrupt"
+			| "new_session"
+			| "session_switch"
+			| "compaction"
+			| "handoff"
+			| "tool_abort"
+			| "internal";
+		/** Suppress the "Operation aborted" line on the resulting aborted message
+		 *  by stamping `SILENT_ABORT_MARKER`. Used when Esc consumes a queued steer
+		 *  and resumes via steer-on-interrupt, so the interrupt reads as a quiet
+		 *  hand-off rather than a failure. */
+		silent?: boolean;
+	}): Promise<void> {
+		if (options?.silent) {
+			this.#silentAbortPending = true;
+		} else {
+			this.#silentAbortPending = false;
+		}
 		this.abortRetry();
 		this.#promptGeneration++;
 		this.#scheduledHiddenNextTurnGeneration = undefined;
@@ -5067,6 +5209,10 @@ export class AgentSession {
 		// block runs, but nested prompt setup/finalizers may still be unwinding. Without this,
 		// a subsequent prompt() can incorrectly observe the session as busy after an abort.
 		this.#resetInFlight();
+		// Safety net: clear the silent-abort flag if it was never consumed (the
+		// abort produced no aborted assistant message_end to stamp). Prevents the
+		// marker from leaking onto a later, unrelated abort.
+		this.#silentAbortPending = false;
 		// Safety net: if the agent loop aborted without producing an assistant
 		// message (e.g. failed before the first stream), the in-flight yield was
 		// never resolved or rejected by the normal message_end path. Reject it now
@@ -5074,6 +5220,18 @@ export class AgentSession {
 		if (this.#toolChoiceQueue.hasInFlight) {
 			this.#toolChoiceQueue.reject("aborted");
 		}
+
+		// Steer-on-interrupt: after a genuine user interrupt, resume with any
+		// queued steering instead of going idle. Lifecycle/teardown causes
+		// (default "internal") suppress this; new-session/handoff additionally
+		// clear the steering queue, and compaction resumes via its own path.
+		if ((options?.cause ?? "internal") === "user_interrupt" && this.agent.hasQueuedSteering()) {
+			this.#scheduleAgentContinue({
+				delayMs: 1,
+				generation: this.#promptGeneration,
+				shouldContinue: () => this.agent.hasQueuedSteering(),
+			});
+		}
 	}
 
 	/**
@@ -5129,6 +5287,9 @@ export class AgentSession {
 		this.#scheduledHiddenNextTurnGeneration = undefined;
 
 		this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
+		if (this.model) {
+			this.sessionManager.appendModelChange(`${this.model.provider}/${this.model.id}`);
+		}
 		this.sessionManager.appendServiceTierChange(this.serviceTier ?? null);
 		if (nextDiscoverySessionToolNames) {
 			await this.#applyActiveToolsByName(nextDiscoverySessionToolNames, { persistMCPSelection: false });
@@ -5920,6 +6081,11 @@ export class AgentSession {
 			this.#pendingNextTurnMessages = [];
 			this.#scheduledHiddenNextTurnGeneration = undefined;
 			this.#todoReminderCount = 0;
+			if (model) {
+				this.sessionManager.appendModelChange(`${model.provider}/${model.id}`);
+			}
+			this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
+			this.sessionManager.appendServiceTierChange(this.serviceTier ?? null);
 
 			// Inject the handoff document as a custom message
 			const handoffContent = createHandoffContext(handoffText);
@@ -5931,7 +6097,14 @@ export class AgentSession {
 				if (artifactsDir) {
 					const handoffFilePath = path.join(artifactsDir, createHandoffFileName());
 					try {
-						await Bun.write(handoffFilePath, `${handoffText}\n`);
+						if (isUnderProjectGjc(this.sessionManager.getCwd(), handoffFilePath)) {
+							await writeArtifact(handoffFilePath, `${handoffText}\n`, {
+								cwd: this.sessionManager.getCwd(),
+								audit: { category: "artifact", verb: "write", owner: "gjc-runtime" },
+							});
+						} else {
+							await Bun.write(handoffFilePath, `${handoffText}\n`);
+						}
 						savedPath = handoffFilePath;
 					} catch (error) {
 						logger.warn("Failed to save handoff document to disk", {
@@ -6200,6 +6373,39 @@ export class AgentSession {
 			toolChoice: todoWriteToolChoice,
 		};
 	}
+
+	async #checkGoalCompletion(assistantMessage: AssistantMessage): Promise<boolean> {
+		const state = this.getGoalModeState();
+		if (!state?.enabled || state.goal.status !== "active") {
+			this.#lastGoalReminderAssistantTimestamp = undefined;
+			return false;
+		}
+		if (this.#lastGoalReminderAssistantTimestamp === assistantMessage.timestamp) {
+			return false;
+		}
+		this.#lastGoalReminderAssistantTimestamp = assistantMessage.timestamp;
+
+		const continuationPrompt = this.#goalRuntime.buildContinuationPrompt();
+		if (!continuationPrompt) return false;
+		const reminder = [
+			"<system-reminder>",
+			"You stopped while a goal is still active and uncleared.",
+			"Continue working on the active goal until it is verified complete, paused, or dropped.",
+			"",
+			continuationPrompt,
+			"</system-reminder>",
+		].join("\n");
+
+		logger.debug("Goal completion: sending active-goal reminder", { goalId: state.goal.id });
+		this.agent.appendMessage({
+			role: "developer",
+			content: [{ type: "text", text: reminder }],
+			attribution: "agent",
+			timestamp: Date.now(),
+		});
+		this.#scheduleAgentContinue({ generation: this.#promptGeneration });
+		return true;
+	}
 	/**
 	 * Check if agent stopped with incomplete todos and prompt to continue.
 	 */
@@ -6843,12 +7049,34 @@ export class AgentSession {
 					willRetry: false,
 					skipped: true,
 				});
-				if (!willRetry && this.agent.hasQueuedMessages()) {
+				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,
+						});
+					}
+				} else if (reason !== "idle" && this.agent.hasQueuedMessages()) {
 					this.#scheduleAgentContinue({
 						delayMs: 100,
 						generation,
 						shouldContinue: () => this.agent.hasQueuedMessages(),
+						onSkip: skipReason => this.#logCompactionContinuationSkipped("queued_continue", skipReason),
+						onError: error => this.#logCompactionContinuationError("queued_continue", error),
 					});
+				} else if (reason !== "idle" && compactionSettings.autoContinue !== false) {
+					this.#scheduleAutoContinuePrompt(generation);
 				}
 				return;
 			}
@@ -7050,26 +7278,36 @@ export class AgentSession {
 			};
 			await this.#emitSessionEvent({ type: "auto_compaction_end", action, result, aborted: false, willRetry });
 
-			if (!willRetry && reason !== "idle" && compactionSettings.autoContinue !== false) {
-				this.#scheduleAutoContinuePrompt(generation);
-			}
-
 			if (willRetry) {
-				const messages = this.agent.state.messages;
-				const lastMsg = messages[messages.length - 1];
-				if (lastMsg?.role === "assistant" && (lastMsg as AssistantMessage).stopReason === "error") {
-					this.agent.replaceMessages(messages.slice(0, -1));
+				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.#scheduleAgentContinue({ delayMs: 100, generation });
-			} else if (this.agent.hasQueuedMessages()) {
+			} else if (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.
 				this.#scheduleAgentContinue({
 					delayMs: 100,
 					generation,
 					shouldContinue: () => this.agent.hasQueuedMessages(),
+					onSkip: reason => this.#logCompactionContinuationSkipped("queued_continue", reason),
+					onError: error => this.#logCompactionContinuationError("queued_continue", error),
 				});
+			} else if (reason !== "idle" && compactionSettings.autoContinue !== false) {
+				this.#scheduleAutoContinuePrompt(generation);
 			}
 		} catch (error) {
 			if (autoCompactionSignal.aborted) {
@@ -7121,19 +7359,14 @@ export class AgentSession {
 	// =========================================================================
 
 	/**
-	 * Check if an error is retryable (transient errors or usage limits).
-	 * Context overflow errors are NOT retryable (handled by compaction instead).
-	 * Usage-limit errors are retryable because the retry handler performs credential switching.
+	 * Whether an error should be retried. Uses the ordered classifier:
+	 * context-overflow routes to compaction; clearly-terminal coded errors
+	 * (auth/400/not-found) surface immediately; usage-limit, transient, and
+	 * unknown/no-code errors are retryable.
 	 */
 	#isRetryableError(message: AssistantMessage): boolean {
-		if (message.stopReason !== "error" || !message.errorMessage) return false;
-
-		// Context overflow is handled by compaction, not retry
-		const contextWindow = this.model?.contextWindow ?? 0;
-		if (isContextOverflow(message, contextWindow)) return false;
-
-		const err = message.errorMessage;
-		return this.#isTransientErrorMessage(err) || isUsageLimitError(err);
+		const classification = this.#classifyErrorForRetry(message);
+		return classification === "usage_limit" || classification === "transient" || classification === "unknown";
 	}
 
 	#isTransientErrorMessage(errorMessage: string): boolean {
@@ -7159,6 +7392,63 @@ export class AgentSession {
 		);
 	}
 
+	#isTerminalErrorMessage(errorMessage: string): boolean {
+		// Errors that will never succeed on retry (auth/permission, malformed
+		// request, unknown/unsupported model). These surface immediately rather
+		// than retry forever.
+		return /unauthorized|forbidden|authentication_error|permission_error|permission denied|invalid api key|invalid_request_error|invalid request|bad request|bad_request|validation_error|unprocessable|payload too large|payment required|insufficient_quota|insufficient credits|missing required (parameter|field)|invalid schema|invalid tool_choice|unsupported (parameter|value|model)|model_not_found|no such model|unknown model|does not (exist|support)|request was aborted|request aborted|the user aborted/i.test(
+			errorMessage,
+		);
+	}
+
+	#extractExplicitHttpStatusFromErrorMessage(errorMessage: string): number | undefined {
+		// Parse only explicit HTTP/status wording. Do not treat generic
+		// `error: 400` as an HTTP status because rate-limit copy can say
+		// "rate limit error: 400 requests per minute".
+		const match = /\b(?:http(?:\s+status)?|status(?:[\s_-]+code)?)(?:\s+|[:=]\s*)(\d{3})\b/i.exec(errorMessage);
+		if (!match) return undefined;
+		const status = Number(match[1]);
+		return Number.isFinite(status) && status >= 100 && status <= 599 ? status : undefined;
+	}
+
+	/**
+	 * Ordered retry classification: overflow (compaction) -> terminal (surface)
+	 * -> usage_limit (rotation) -> transient (retry) -> unknown (retry).
+	 */
+	#classifyErrorForRetry(
+		message: AssistantMessage,
+	): "none" | "overflow" | "terminal" | "usage_limit" | "transient" | "unknown" {
+		if (message.stopReason !== "error" || !message.errorMessage) return "none";
+		const contextWindow = this.model?.contextWindow ?? 0;
+		if (isContextOverflow(message, contextWindow)) return "overflow";
+		const err = message.errorMessage;
+		// Stream-envelope errors are only transient in the pre-message_start
+		// variant; any other envelope failure is structural and must surface.
+		if (/anthropic stream envelope error:/i.test(err)) {
+			return this.#isTransientEnvelopeErrorMessage(err) ? "transient" : "terminal";
+		}
+		const explicitStatus = this.#extractExplicitHttpStatusFromErrorMessage(err);
+		const structuredStatus = message.errorStatus;
+		const terminalStatus = explicitStatus ?? structuredStatus;
+		const isTerminalHttp4xx =
+			terminalStatus !== undefined &&
+			terminalStatus >= 400 &&
+			terminalStatus < 500 &&
+			terminalStatus !== 408 &&
+			terminalStatus !== 425 &&
+			terminalStatus !== 429;
+		if (this.#isTerminalErrorMessage(err)) return "terminal";
+		if (isUsageLimitError(err)) return "usage_limit";
+		// Explicit HTTP/status wording is authoritative. Structured provider status
+		// is also authoritative except for rate-limit copy where providers may have
+		// parsed an incidental quota number such as "400 requests per minute".
+		if (isTerminalHttp4xx && (explicitStatus !== undefined || !/rate.?limit|too many requests/i.test(err))) {
+			return "terminal";
+		}
+		if (this.#isTransientErrorMessage(err)) return "transient";
+		return "unknown";
+	}
+
 	#getRetryFallbackChains(): RetryFallbackChains {
 		const configuredChains = this.settings.get("retry.fallbackChains");
 		if (!configuredChains || typeof configuredChains !== "object") return {};
@@ -7428,6 +7718,8 @@ export class AgentSession {
 	async #handleRetryableError(message: AssistantMessage): Promise<boolean> {
 		const retrySettings = this.settings.getGroup("retry");
 		if (!retrySettings.enabled) return false;
+		const retryClassification = this.#classifyErrorForRetry(message);
+		const unboundedClass = retryClassification === "transient" || retryClassification === "unknown";
 
 		const generation = this.#promptGeneration;
 		this.#retryAttempt++;
@@ -7440,7 +7732,7 @@ export class AgentSession {
 			this.#retryResolve = resolve;
 		}
 
-		if (this.#retryAttempt > retrySettings.maxRetries) {
+		if (!unboundedClass && this.#retryAttempt > retrySettings.maxRetries) {
 			// Max retries exceeded, emit final failure and reset
 			await this.#emitSessionEvent({
 				type: "auto_retry_end",
@@ -7497,7 +7789,16 @@ export class AgentSession {
 		// assistant error message is preserved in agent state so the caller
 		// can act on it.
 		const maxDelayMs = retrySettings.maxDelayMs;
-		if (maxDelayMs > 0 && delayMs > maxDelayMs && !switchedCredential && !switchedModel) {
+		if (unboundedClass && !switchedCredential && !switchedModel) {
+			// Retry forever: honor a provider-supplied wait, otherwise cap the
+			// exponential backoff at the ceiling instead of giving up.
+			if (parsedRetryAfterMs !== undefined) {
+				delayMs = Math.max(delayMs, parsedRetryAfterMs);
+			} else if (maxDelayMs > 0) {
+				delayMs = Math.min(delayMs, maxDelayMs);
+			}
+		}
+		if (!unboundedClass && maxDelayMs > 0 && delayMs > maxDelayMs && !switchedCredential && !switchedModel) {
 			const attempt = this.#retryAttempt;
 			this.#retryAttempt = 0;
 			await this.#emitSessionEvent({
@@ -7510,12 +7811,22 @@ export class AgentSession {
 			return false;
 		}
 
+		// Create and install the backoff abort controller BEFORE emitting
+		// auto_retry_start, so a synchronous retryNow()/abortRetry() invoked from
+		// an event subscriber (e.g. the TUI Esc handler) is not lost in the gap
+		// between the event and the controller assignment.
+		const retryAbortController = new AbortController();
+		this.#retryAbortController?.abort();
+		this.#retryAbortController = retryAbortController;
+		this.#retryNowRequested = false;
+
 		await this.#emitSessionEvent({
 			type: "auto_retry_start",
 			attempt: this.#retryAttempt,
 			maxAttempts: retrySettings.maxRetries,
 			delayMs,
 			errorMessage,
+			unbounded: unboundedClass,
 		});
 
 		// Remove error message from agent state (keep in session for history)
@@ -7525,34 +7836,49 @@ export class AgentSession {
 		}
 
 		// Wait with exponential backoff (abortable).
-		const retryAbortController = new AbortController();
-		this.#retryAbortController?.abort();
-		this.#retryAbortController = retryAbortController;
 		try {
 			await scheduler.wait(delayMs, { signal: retryAbortController.signal });
 		} catch {
 			if (this.#retryAbortController !== retryAbortController) {
 				return false;
 			}
-			// Aborted during sleep - emit end event so UI can clean up
-			const attempt = this.#retryAttempt;
-			this.#retryAttempt = 0;
 			this.#retryAbortController = undefined;
-			await this.#emitSessionEvent({
-				type: "auto_retry_end",
-				success: false,
-				attempt,
-				finalError: "Retry cancelled",
-			});
-			this.#resolveRetry();
-			return false;
+			if (this.#retryNowRequested) {
+				// Retry-now: skip the remaining backoff and fall through to
+				// re-attempt immediately (keeps the retry session alive).
+				this.#retryNowRequested = false;
+			} else {
+				// Aborted during sleep (cancel) - emit end event so UI can clean up
+				const attempt = this.#retryAttempt;
+				this.#retryAttempt = 0;
+				await this.#emitSessionEvent({
+					type: "auto_retry_end",
+					success: false,
+					attempt,
+					finalError: "Retry cancelled",
+				});
+				this.#resolveRetry();
+				return false;
+			}
 		}
 		if (this.#retryAbortController === retryAbortController) {
 			this.#retryAbortController = undefined;
 		}
 
 		// Retry via continue() outside the agent_end event callback chain.
-		this.#scheduleAgentContinue({ delayMs: 1, generation });
+		// If the scheduled continue cannot run — it throws (e.g. AgentBusyError from a
+		// concurrent turn, or "Cannot continue ...") or is skipped because a newer
+		// generation took over — the agent_end that normally resolves #retryPromise
+		// never arrives. Finalize the retry in that case so #waitForPostPromptRecovery
+		// (and the in-flight prompt holding it open) cannot wedge the session as
+		// permanently busy, which would turn every later prompt() into a
+		// non-recoverable AgentBusyError loop.
+		this.#scheduleAgentContinue({
+			delayMs: 1,
+			generation,
+			onError: () => this.#failRetryRecovery("Retry continuation failed to start"),
+			onSkip: () => this.#failRetryRecovery("Retry continuation was superseded"),
+		});
 
 		return true;
 	}
@@ -7561,8 +7887,41 @@ export class AgentSession {
 	 * Cancel in-progress retry.
 	 */
 	abortRetry(): void {
+		this.#retryNowRequested = false;
 		this.#retryAbortController?.abort();
-		// Note: _retryAttempt is reset in the catch block of _autoRetry
+		// Note: #retryAttempt is reset in the catch block of #handleRetryableError
+		this.#resolveRetry();
+	}
+
+	/**
+	 * Skip the current retry backoff and re-attempt immediately. Distinct from
+	 * abortRetry(), which cancels the retry and returns to idle. No-op when no
+	 * retry backoff is active.
+	 */
+	retryNow(): void {
+		if (!this.#retryAbortController) return;
+		this.#retryNowRequested = true;
+		this.#retryAbortController.abort();
+	}
+
+	/**
+	 * Finalize a pending auto-retry that can no longer reach a resolving agent_end
+	 * (the scheduled continue threw or was superseded). Without this, #retryPromise
+	 * stays unresolved, #waitForPostPromptRecovery never returns, the owning
+	 * prompt's in-flight count is never released, and the session reports
+	 * `isStreaming === true` forever — turning every later prompt() into a
+	 * non-recoverable AgentBusyError. No-op once the retry has already settled.
+	 */
+	#failRetryRecovery(reason: string): void {
+		if (!this.#retryPromise) return;
+		const attempt = this.#retryAttempt;
+		this.#retryAttempt = 0;
+		void this.#emitSessionEvent({
+			type: "auto_retry_end",
+			success: false,
+			attempt,
+			finalError: reason,
+		});
 		this.#resolveRetry();
 	}
 
@@ -8190,13 +8549,17 @@ export class AgentSession {
 				return;
 			}
 			if (this.isStreaming) {
-				setTimeout(attempt, 50);
+				// Re-poll while streaming, but do not let this housekeeping timer
+				// keep the event loop alive on its own (CPU-7).
+				const pollTimer = setTimeout(attempt, 50);
+				pollTimer.unref?.();
 				return;
 			}
 			this.#scheduledBackgroundExchangeFlush = false;
 			this.#flushPendingBackgroundExchanges();
 		};
-		setTimeout(attempt, 0);
+		const kickoff = setTimeout(attempt, 0);
+		kickoff.unref?.();
 	}
 
 	#flushPendingBackgroundExchanges(): void {
@@ -8279,6 +8642,8 @@ export class AgentSession {
 		const previousFallbackSelectedMCPToolNames = previousSessionFile
 			? this.#getSessionDefaultSelectedMCPToolNames(previousSessionFile)
 			: undefined;
+		const previousAgentSteeringQueue = this.agent.snapshotSteering();
+		const previousAgentFollowUpQueue = this.agent.snapshotFollowUp();
 
 		this.#steeringMessages = [];
 		this.#followUpMessages = [];
@@ -8297,6 +8662,12 @@ export class AgentSession {
 			const fallbackSelectedMCPToolNames = this.#getSessionDefaultSelectedMCPToolNames(sessionPath);
 			await this.#restoreMCPSelectionsForSessionContext(sessionContext, { fallbackSelectedMCPToolNames });
 
+			// The target session is loaded and MCP selections are restored: the
+			// switch is committed far enough to discard pre-switch delivery queues.
+			// Clear before session_switch hooks, so messages enqueued by hooks belong
+			// to the new session and remain deliverable.
+			this.agent.clearAllQueues();
+
 			// Emit session_switch event to hooks
 			if (this.#extensionRunner) {
 				await this.#extensionRunner.emit({
@@ -8391,6 +8762,9 @@ export class AgentSession {
 			this.#followUpMessages = previousFollowUpMessages;
 			this.#pendingNextTurnMessages = previousPendingNextTurnMessages;
 			this.#scheduledHiddenNextTurnGeneration = previousScheduledHiddenNextTurnGeneration;
+			this.agent.clearAllQueues();
+			this.agent.restoreSteering(previousAgentSteeringQueue);
+			this.agent.restoreFollowUp(previousAgentFollowUpQueue);
 			if (previousModel) {
 				this.agent.setModel(previousModel);
 			}