@gajae-code/coding-agent 0.12.0 → 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,
@@ -130,6 +136,7 @@ import { CustomProviderWizardComponent, type CustomProviderWizardSubmit } from "
 import { ExtensionDashboard } from "../components/extensions";
 import type { PetMode } from "../components/gajae-pet-widget";
 import { HistorySearchComponent } from "../components/history-search";
+import { HookSelectorComponent } from "../components/hook-selector";
 import { JobsOverlayComponent } from "../components/jobs-overlay";
 import { ModelSelectorComponent } from "../components/model-selector";
 import type {
@@ -166,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",
@@ -196,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"),
@@ -351,6 +357,7 @@ export function createNotificationsEditorOperations(
 					richDraftEnabled: config.richDraft.enabled,
 					toolActivityEnabled: config.toolActivity.enabled,
 					streamingEnabled: config.streaming.enabled,
+					sound: config.sound,
 				},
 			};
 		},
@@ -724,6 +731,7 @@ export function createNotificationsEditorOperations(
 						{ path: "notifications.redact", op: "set", value: preferences.redact },
 						{ path: "notifications.verbosity", op: "set", value: preferences.verbosity },
 						{ path: "notifications.sessionScope", op: "set", value: preferences.sessionScope },
+						{ path: "notifications.telegram.sound", op: "set", value: preferences.sound },
 						{ path: "notifications.telegram.rich.enabled", op: "set", value: preferences.richEnabled },
 						{ path: "notifications.telegram.richDraft.enabled", op: "set", value: preferences.richDraftEnabled },
 						{ path: "notifications.telegram.streaming.enabled", op: "set", value: preferences.streamingEnabled },
@@ -818,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") {
@@ -1280,6 +1290,8 @@ export class SelectorController {
 						availableThemes,
 						availableModelProfiles: [...this.ctx.session.modelRegistry.getModelProfiles().keys()],
 						cwd: getProjectDir(),
+						gjcRuntimeSnapshot: this.ctx.session.gjcRuntimeSnapshot,
+						gjcActivationGeneration: this.ctx.session.gjcActivationGeneration,
 					},
 					{
 						onChange: (id, value) => this.handleSettingChange(id, value),
@@ -1561,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();
@@ -1621,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":
@@ -2133,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,
@@ -2156,6 +2174,7 @@ export class SelectorController {
 							summarize: wantsSummary,
 							customInstructions,
 						});
+						if (this.ctx.isStopped?.()) return;
 
 						if (result.aborted) {
 							// Summarization aborted - re-show tree selector
@@ -2171,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?.();
 					}
 				},
 				() => {
@@ -2201,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,
@@ -2235,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;
@@ -2273,6 +2293,7 @@ export class SelectorController {
 		}
 
 		const detached = await this.ctx.session.newSession();
+		if (this.ctx.isStopped?.()) return false;
 		if (!detached) {
 			return false;
 		}
@@ -2280,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(
@@ -2309,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();
@@ -2326,12 +2421,55 @@ 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();
 		}
 	}
 
+	/**
+	 * When `session.resumeModelBehavior` is "ask", offer a one-shot choice after
+	 * resuming: keep the model the session was last using, or switch to whatever
+	 * `modelRoles.default` currently resolves to. No-op if the setting is unset,
+	 * the two models already match, or either model can't be resolved.
+	 */
+	#maybePromptResumeModelChoice(): void {
+		if (this.ctx.settings?.get("session.resumeModelBehavior") !== "ask") return;
+		const sessionModel = this.ctx.session.model;
+		const currentDefault = this.ctx.session.resolveConfiguredDefaultModel?.();
+		if (!sessionModel || !currentDefault) return;
+		if (sessionModel.provider === currentDefault.provider && sessionModel.id === currentDefault.id) return;
+
+		this.showSelector(done => {
+			const selector = new HookSelectorComponent(
+				`This session last used ${sessionModel.provider}/${sessionModel.id}.\n` +
+					`Current default model is ${currentDefault.provider}/${currentDefault.id}.`,
+				[`Keep ${sessionModel.id}`, `Use ${currentDefault.id}`],
+				async (option: string) => {
+					done();
+					if (option === `Use ${currentDefault.id}`) {
+						try {
+							await this.ctx.session.setModel(currentDefault);
+							this.ctx.showStatus(`Switched to ${currentDefault.provider}/${currentDefault.id}`);
+						} catch (err) {
+							this.ctx.showError(err instanceof Error ? err.message : String(err));
+						}
+					}
+					this.ctx.ui.requestRender();
+				},
+				() => {
+					done();
+					this.ctx.ui.requestRender();
+				},
+			);
+			return { component: selector, focus: selector };
+		});
+	}
+
 	async handleSessionDeleteCommand(): Promise<void> {
 		const sessionFile = this.ctx.sessionManager.getSessionFile();
 		if (!sessionFile) {