@gajae-code/coding-agent 0.12.1 → 0.12.2

package/src/modes/controllers/selector-controller.ts

@@ -43,7 +43,13 @@ import {
 	setTheme,
 	theme,
 } from "../../modes/theme/theme";
-import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/types";
+import {
+	clearInteractiveActivityLoaders,
+	type InteractiveModeContext,
+	type OAuthSelectorOptions,
+	stopInteractiveActivityIndicator,
+	suspendInteractiveActivityIndicator,
+} from "../../modes/types";
 import { getNotificationConfig, isTelegramConfigured, maskToken } from "../../sdk/bus/config";
 import {
 	clearTelegramActivationMarker,
@@ -167,7 +173,7 @@ import type { JobsObserver } from "../jobs-observer";
 import type { SessionObserverRegistry } from "../session-observer-registry";
 import type { TasksAggregator } from "../tasks-aggregator";
 import type { TranscriptItemRegistry } from "../transcript-item-registry";
-import { acquireResumeProgressLease } from "../utils/ui-helpers";
+import { acquireResumeProgressLease, type ResumeProgressLease } from "../utils/ui-helpers";
 
 const CALLBACK_SERVER_PROVIDERS = new Set<string>([
 	"anthropic",
@@ -197,7 +203,6 @@ export function buildStatusLineSettings(settingsInstance: Settings): StatusLineS
 		rightSegments: settingsInstance.get("statusLine.rightSegments"),
 		separator: settingsInstance.get("statusLine.separator"),
 		showHookStatus: settingsInstance.get("statusLine.showHookStatus"),
-		showActionHints: settingsInstance.get("statusLine.showActionHints"),
 		sessionAccent: settingsInstance.get("statusLine.sessionAccent"),
 		maxRows: settingsInstance.get("statusLine.maxRows"),
 		segmentOptions: settingsInstance.get("statusLine.segmentOptions"),
@@ -821,7 +826,9 @@ export class SelectorController {
 	 * @param create Factory that receives a `done` callback and returns the component and focus target
 	 */
 	showSelector(create: (done: () => void) => { component: Component; focus: Component }): void {
+		if (this.ctx.isStopped?.()) return;
 		const done = () => {
+			if (this.ctx.isStopped?.()) return;
 			// Prefer the pet-aware composer restore (InteractiveMode.restoreComposer); fall back
 			// to a plain editor swap for contexts that predate it (e.g. lightweight test doubles).
 			if (typeof this.ctx.restoreComposer === "function") {
@@ -1566,7 +1573,8 @@ export class SelectorController {
 				this.ctx.rebuildChatFromMessages("reconcile-same-transcript");
 				break;
 			case "theme": {
-				setTheme(value as string, true).then(result => {
+				setTheme(value as string, true, { shouldApply: () => !this.ctx.isStopped?.() }).then(result => {
+					if (this.ctx.isStopped?.()) return;
 					this.ctx.statusLine.invalidate();
 					this.ctx.updateEditorTopBorder();
 					this.ctx.ui.invalidate();
@@ -1626,13 +1634,16 @@ export class SelectorController {
 				this.ctx.session.agent.repetitionPenalty = repetitionPenalty >= 0 ? repetitionPenalty : undefined;
 				break;
 			}
+			case "statusLine.showActionHints": {
+				this.ctx.updateEditorChrome();
+				break;
+			}
 			case "statusLinePreset":
 			case "statusLine.preset":
 			case "statusLineSeparator":
 			case "statusLine.separator":
 			case "statusLineShowHooks":
 			case "statusLine.showHookStatus":
-			case "statusLine.showActionHints":
 			case "statusLine.sessionAccent":
 			case "statusLine.maxRows":
 			case "statusLine.leftSegments":
@@ -2138,12 +2149,14 @@ export class SelectorController {
 
 					// Set up escape handler and loader if summarizing
 					let summaryLoader: Loader | undefined;
+					let releaseActivityIndicator: (() => void) | undefined;
 					const originalOnEscape = this.ctx.editor.onEscape;
 
 					if (wantsSummary) {
 						this.ctx.editor.onEscape = () => {
 							this.ctx.session.abortBranchSummary();
 						};
+						releaseActivityIndicator = suspendInteractiveActivityIndicator(this.ctx);
 						this.ctx.chatContainer.addChild(new Spacer(1));
 						summaryLoader = new Loader(
 							this.ctx.ui,
@@ -2161,6 +2174,7 @@ export class SelectorController {
 							summarize: wantsSummary,
 							customInstructions,
 						});
+						if (this.ctx.isStopped?.()) return;
 
 						if (result.aborted) {
 							// Summarization aborted - re-show tree selector
@@ -2176,18 +2190,21 @@ export class SelectorController {
 						// Update UI — pass the context built by navigateTree to skip a second O(N) walk.
 						this.ctx.rebuildInitialMessages("reconcile-same-transcript", result.sessionContext);
 						await this.ctx.reloadTodos();
+						if (this.ctx.isStopped?.()) return;
 						if (result.editorText && !this.ctx.editor.getText().trim()) {
 							this.ctx.editor.setText(result.editorText);
 						}
 						this.ctx.showStatus("Navigated to selected point");
 					} catch (error) {
+						if (this.ctx.isStopped?.()) return;
 						this.ctx.showError(error instanceof Error ? error.message : String(error));
 					} finally {
 						if (summaryLoader) {
 							summaryLoader.stop();
-							this.ctx.statusContainer.clear();
+							if (!this.ctx.isStopped?.()) this.ctx.statusContainer.clear();
 						}
-						this.ctx.editor.onEscape = originalOnEscape;
+						if (!this.ctx.isStopped?.()) this.ctx.editor.onEscape = originalOnEscape;
+						releaseActivityIndicator?.();
 					}
 				},
 				() => {
@@ -2206,6 +2223,7 @@ export class SelectorController {
 
 	async showSessionSelector(): Promise<void> {
 		const sessions = await this.ctx.sessionManager.listForResumePickerReadOnly();
+		if (this.ctx.isStopped?.()) return;
 		this.showSelector(done => {
 			const selector = new SessionSelectorComponent(
 				sessions,
@@ -2240,12 +2258,9 @@ export class SelectorController {
 		});
 	}
 
-	#clearTransientSessionUi(): void {
-		if (this.ctx.loadingAnimation) {
-			this.ctx.loadingAnimation.stop();
-			this.ctx.loadingAnimation = undefined;
-		}
-		this.ctx.statusContainer.clear();
+	#clearTransientSessionUi(options?: { restoreBackground?: boolean; clearSpecializedLoaders?: boolean }): void {
+		if (options?.clearSpecializedLoaders) clearInteractiveActivityLoaders(this.ctx);
+		stopInteractiveActivityIndicator(this.ctx, { restoreBackground: options?.restoreBackground });
 		this.ctx.pendingMessagesContainer.clear();
 		this.ctx.compactionQueuedMessages = [];
 		this.ctx.streamingComponent = undefined;
@@ -2278,6 +2293,7 @@ export class SelectorController {
 		}
 
 		const detached = await this.ctx.session.newSession();
+		if (this.ctx.isStopped?.()) return false;
 		if (!detached) {
 			return false;
 		}
@@ -2285,28 +2301,50 @@ export class SelectorController {
 
 		this.#refreshSessionTerminalTitle();
 
-		this.#clearTransientSessionUi();
+		this.#clearTransientSessionUi({ clearSpecializedLoaders: true });
 		this.ctx.statusLine.invalidate();
 		this.ctx.statusLine.setSessionStartTime(Date.now());
 		this.ctx.updateEditorTopBorder();
 		this.ctx.updateEditorBorderColor();
 		this.ctx.rebuildInitialMessages("replace-identity");
 		await this.ctx.reloadTodos();
+		if (this.ctx.isStopped?.()) return false;
 		this.ctx.ui.requestRender();
 		return true;
 	}
 
+	/**
+	 * Guards `handleResumeSession` against overlapping resumes.
+	 *
+	 * `acquireResumeProgressLease` only owns the spinner, so it cannot serialize
+	 * two resumes, and the session picker dispatches resume through a
+	 * void-returning `onSelect` callback — a second selection would otherwise
+	 * start a concurrent transition whose rejection nobody awaits.
+	 */
+	#resumeInFlight = false;
+
 	async handleResumeSession(sessionPath: string): Promise<void> {
-		const previousSessionId = this.ctx.sessionManager.getSessionId();
-		this.#clearTransientSessionUi();
-		const progressLease = acquireResumeProgressLease(this.ctx);
+		if (this.#resumeInFlight) {
+			this.ctx.showStatus("Resume already in progress");
+			return;
+		}
+		this.#resumeInFlight = true;
+		const releaseActivityIndicator = suspendInteractiveActivityIndicator(this.ctx);
+		// Everything below runs inside the try so a synchronous failure (a throwing
+		// session-manager accessor, an unavailable status rail) can never strand the
+		// guard and silently disable every later resume.
+		let progressLease: ResumeProgressLease | undefined;
 		try {
+			const previousSessionId = this.ctx.sessionManager.getSessionId();
+			progressLease = acquireResumeProgressLease(this.ctx);
 			await progressLease.committed;
+			if (this.ctx.isStopped?.()) return;
 			const migrationPolicy =
 				this.ctx.settings?.get("session.directoryMigration") === "disabled" ? "disabled" : "copy-retain";
 			let writableSessionPath = sessionPath;
 			if (this.ctx.sessionManager.isManagedDestination()) {
 				const inspection = await SessionManager.inspectSessionTailReadOnly(sessionPath);
+				if (this.ctx.isStopped?.()) return;
 				if (inspection.kind === "error")
 					throw new Error(`Could not inspect selected session: ${inspection.reason}`);
 				writableSessionPath = await this.ctx.sessionManager.prepareManagedCandidateForStrictAdoption(
@@ -2314,14 +2352,66 @@ export class SelectorController {
 					migrationPolicy,
 					inspection.identity,
 				);
+				if (this.ctx.isStopped?.()) return;
 			}
 			// Switch session via AgentSession (emits hook and tool session events)
-			if (
-				!(await this.ctx.session.switchSession(writableSessionPath, {
+			let switched: boolean;
+			let transitionMutationStarted = false;
+			try {
+				switched = await this.ctx.session.switchSession(writableSessionPath, {
 					transition: { origin: INTERACTIVE_SELECTOR_RESUME_ORIGIN },
-				}))
-			)
+					onTransitionMutationStarted: () => {
+						transitionMutationStarted = true;
+					},
+				});
+				if (this.ctx.isStopped?.()) return;
+			} catch (error) {
+				if (this.ctx.isStopped?.()) return;
+				// `switchSession` opens with `#beginSessionTransition`, which throws
+				// `{ code: "busy" }` while another transition (compaction, handoff, fork,
+				// another switch, …) owns the session. Resume is a UI action dispatched
+				// through a void callback, so report that as status instead of rejecting a
+				// promise nobody awaits. Admission-busy never acquired the lease, so the
+				// owner's transient state — including the `compactionQueuedMessages` that
+				// hold input typed during compaction — must survive untouched.
+				const typed = error as { code?: unknown } | undefined;
+				if (typed?.code === "busy") {
+					this.ctx.showStatus("Another session operation is already in progress");
+					return;
+				}
+				// A rejection can occur either before the transition mutates the live session
+				// (for example, a rejecting `session_before_switch` hook) or after disconnect/
+				// abort has begun. Preserve the current session's transient UI in the former
+				// case; reconcile only state invalidated by a transition that actually mutated.
+				// Reconciliation stays best-effort so cleanup failure never replaces the
+				// original switch failure.
+				if (transitionMutationStarted) {
+					try {
+						progressLease.clear();
+						this.#clearTransientSessionUi({ restoreBackground: false, clearSpecializedLoaders: true });
+					} catch {
+						logger.warn("Resume transient-UI reconciliation failed after a session switch error", {
+							classification: "resume-cleanup-failed",
+						});
+					}
+				}
+				throw error;
+			}
+			// `#clearTransientSessionUi` drops `compactionQueuedMessages`, so it must stay
+			// untouched on the paths that never acquired the session-transition lease:
+			// admission-busy above and managed-candidate preparation before it.
+			//
+			// A pre-mutation hook cancellation preserves the current session and all of
+			// its foreground/retry UI. A rollback after disconnect/abort must clear it.
+			if (!switched) {
+				if (transitionMutationStarted) {
+					progressLease.clear();
+					this.#clearTransientSessionUi({ restoreBackground: false, clearSpecializedLoaders: true });
+				}
 				return;
+			}
+			progressLease.clear();
+			this.#clearTransientSessionUi({ restoreBackground: false, clearSpecializedLoaders: true });
 			const switchingToDifferentSession = previousSessionId !== this.ctx.sessionManager.getSessionId();
 			if (switchingToDifferentSession) this.ctx.resetIrcSidebarSession();
 			this.#refreshSessionTerminalTitle();
@@ -2331,10 +2421,13 @@ export class SelectorController {
 				switchingToDifferentSession ? "replace-identity" : "reconcile-same-transcript",
 			);
 			await this.ctx.reloadTodos();
+			if (this.ctx.isStopped?.()) return;
 			this.ctx.showStatus("Resumed session");
 			this.#maybePromptResumeModelChoice();
 		} finally {
-			progressLease.clear();
+			progressLease?.clear();
+			this.#resumeInFlight = false;
+			releaseActivityIndicator();
 		}
 	}