@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/modes/components/smart-routing-panel.ts

@@ -0,0 +1,531 @@
+import { Container, getKeybindings, matchesKey, replaceTabs, Spacer, Text, truncateToWidth } from "@gajae-code/tui";
+import { sanitizeDisplayLine } from "@gajae-code/utils";
+import type {
+	AutoroutingProvenance,
+	AutoroutingProviderOrderHint,
+	AutoroutingSetup,
+	AutoroutingTier,
+	TierMap,
+} from "../../config/autorouting-contract";
+import type { AutoroutingSourceIdentity } from "../../config/autorouting-generator";
+import { theme } from "../theme/theme";
+
+/** Longest rendered panel line before truncation. */
+export const MAX_PANEL_LINE_WIDTH = 200;
+
+export type SmartRoutingPreview = {
+	readonly setup: AutoroutingSetup;
+	readonly tiers: TierMap;
+	readonly provenance: AutoroutingProvenance;
+	readonly sourceIdentity: AutoroutingSourceIdentity;
+};
+
+export type SmartRoutingIntent =
+	| {
+			kind: "apply";
+			draft: AutoroutingSetup;
+			preview: SmartRoutingPreview;
+			confirmHandEdit?: boolean;
+	  }
+	| {
+			kind: "refresh";
+			confirmHandEdit?: boolean;
+	  }
+	| {
+			kind: "clear";
+	  }
+	| {
+			kind: "toggle";
+			enabled: boolean;
+	  };
+
+export type SmartRoutingPanelMode = "editing" | "confirming" | "committing" | "done" | "error";
+export type SmartRoutingConfirmation = "clear" | "hand-edit" | undefined;
+
+export interface SmartRoutingPanelOptions {
+	setup: AutoroutingSetup;
+	tiers?: TierMap;
+	provenance?: AutoroutingProvenance;
+	/** Advisory drift between the recorded declaration and current provider priority. */
+	providerOrderHint?: AutoroutingProviderOrderHint;
+	enabled: boolean;
+	readOnly: boolean;
+	stale: boolean;
+	preview: SmartRoutingPreview;
+	generatePreview: (draft: AutoroutingSetup) => SmartRoutingPreview;
+	onSelect: (intent: SmartRoutingIntent) => undefined | Promise<SmartRoutingPreview | undefined>;
+	onCancel: () => void;
+}
+
+function cloneSetup(setup: AutoroutingSetup): AutoroutingSetup {
+	return structuredClone(setup);
+}
+
+function clonePreview(preview: SmartRoutingPreview): SmartRoutingPreview {
+	return structuredClone(preview);
+}
+
+function isPrintable(data: string): boolean {
+	return data.length === 1 && data >= " " && data !== "\x7f";
+}
+
+function isBackspace(data: string): boolean {
+	return data === "\x7f" || data === "\b";
+}
+
+/**
+ * Provider names, allowlist entries, generated selectors, and error text all
+ * originate in hand-editable config or catalog data, so any of them can carry
+ * tabs, control bytes, line breaks, or terminal escape sequences. Any of those
+ * can inject extra rows or evade the width cap, so flatten and bound the value
+ * before it reaches a renderer.
+ */
+function displaySafe(text: string): string {
+	return truncateToWidth(replaceTabs(sanitizeDisplayLine(text)), MAX_PANEL_LINE_WIDTH);
+}
+
+function formatTier(tier: AutoroutingTier, tiers: TierMap | undefined): string {
+	const selectors = tiers?.[tier];
+	return displaySafe(
+		`${tier}: ${selectors && selectors.length > 0 ? selectors.join(", ") : "(empty; manual fallback)"}`,
+	);
+}
+
+/**
+ * Presentational smart-routing setup editor. It owns only ephemeral draft and
+ * preview state; all durable changes are emitted as typed intents.
+ */
+export class SmartRoutingPanelComponent extends Container {
+	readonly #onSelect: SmartRoutingPanelOptions["onSelect"];
+	readonly #onCancel: () => void;
+	readonly #generatePreview: (draft: AutoroutingSetup) => SmartRoutingPreview;
+	readonly #readOnly: boolean;
+	#draft: AutoroutingSetup;
+
+	#tiers?: TierMap;
+	#provenance?: AutoroutingProvenance;
+	#enabled: boolean;
+	#stale: boolean;
+	#preview: SmartRoutingPreview;
+	#mode: SmartRoutingPanelMode = "editing";
+	#confirmation: SmartRoutingConfirmation;
+	/** Intent that triggered the current hand-edit confirmation, replayed verbatim on confirm. */
+	#pendingIntent: SmartRoutingIntent | undefined;
+	#providerCursor = 0;
+	#allowlistEditing = false;
+	#allowlistBuffer = "";
+	#providerOrderHint: AutoroutingProviderOrderHint | undefined;
+	#status = "";
+	#error = "";
+
+	constructor(options: SmartRoutingPanelOptions) {
+		super();
+		this.#onSelect = options.onSelect;
+		this.#onCancel = options.onCancel;
+		this.#generatePreview = options.generatePreview;
+		this.#readOnly = options.readOnly;
+		this.#draft = cloneSetup(options.setup);
+
+		this.#tiers = options.tiers ? structuredClone(options.tiers) : undefined;
+		this.#provenance = options.provenance ? structuredClone(options.provenance) : undefined;
+		this.#enabled = options.enabled;
+		this.#providerOrderHint = options.providerOrderHint ? structuredClone(options.providerOrderHint) : undefined;
+		this.#stale = options.stale;
+		this.#preview = clonePreview(options.preview);
+		this.#render();
+	}
+
+	get mode(): SmartRoutingPanelMode {
+		return this.#mode;
+	}
+
+	get confirmation(): SmartRoutingConfirmation {
+		return this.#confirmation;
+	}
+
+	getDraft(): AutoroutingSetup {
+		return cloneSetup(this.#draft);
+	}
+
+	getPreviewPayload(): SmartRoutingPreview {
+		return clonePreview(this.#preview);
+	}
+
+	getProviderOrder(): readonly string[] {
+		return [...this.#draft.providers];
+	}
+
+	/**
+	 * Advisory-only, non-destructive hint update.
+	 *
+	 * `refreshState` deliberately replaces the draft and clears editor state, so it
+	 * must never be used for a background settings change: an external
+	 * `modelProviderOrder` edit would then discard the user's unsaved reordering,
+	 * allowlist buffer, cursor, and confirmation. This replaces the hint and nothing
+	 * else.
+	 */
+	updateProviderOrderHint(hint: AutoroutingProviderOrderHint | undefined): void {
+		this.#providerOrderHint = hint ? structuredClone(hint) : undefined;
+		this.#render();
+	}
+
+	/** Replace the panel's persisted snapshot after a controller mutation. */
+	refreshState(options: {
+		setup: AutoroutingSetup;
+		tiers?: TierMap;
+		provenance?: AutoroutingProvenance;
+		enabled: boolean;
+		providerOrderHint?: AutoroutingProviderOrderHint;
+		stale: boolean;
+		preview: SmartRoutingPreview;
+	}): void {
+		this.#draft = cloneSetup(options.setup);
+		this.#tiers = options.tiers ? structuredClone(options.tiers) : undefined;
+		this.#provenance = options.provenance ? structuredClone(options.provenance) : undefined;
+		this.#enabled = options.enabled;
+		this.#stale = options.stale;
+		this.#providerOrderHint = options.providerOrderHint ? structuredClone(options.providerOrderHint) : undefined;
+		this.#preview = clonePreview(options.preview);
+		this.#providerCursor = Math.min(this.#providerCursor, Math.max(0, this.#draft.providers.length - 1));
+		this.#mode = "editing";
+		this.#confirmation = undefined;
+		this.#status = "";
+		this.#error = "";
+		this.#render();
+	}
+
+	#render(): void {
+		this.detachAll();
+		this.addChild(new Text(theme.fg("accent", "Smart routing setup"), 0, 0));
+		this.addChild(
+			new Text(theme.fg("muted", "Declare providers in priority order; generated chains are deterministic."), 0, 0),
+		);
+		if (this.#readOnly) {
+			this.addChild(
+				new Text(
+					theme.fg("warning", "Read-only: temporary or --models-scoped sessions cannot write autorouting."),
+					0,
+					0,
+				),
+			);
+		}
+		if (this.#stale) {
+			this.addChild(
+				new Text(
+					theme.fg("warning", "Stale generated setup: catalog/map or hand-edited tiers differ from provenance."),
+					0,
+					0,
+				),
+			);
+		}
+		// Advisory only: a changed provider priority is a new suggestion, never proof
+		// that the persisted tiers went stale.
+		if (this.#providerOrderHint?.reordered) {
+			this.addChild(
+				new Text(
+					theme.fg("muted", "Provider priority changed since this setup was generated. Press r to refresh."),
+					0,
+					0,
+				),
+			);
+		}
+		if (this.#providerOrderHint && this.#providerOrderHint.missing.length > 0) {
+			this.addChild(
+				new Text(
+					theme.fg(
+						"muted",
+						displaySafe(
+							`Declared providers missing from the catalog: ${this.#providerOrderHint.missing.join(", ")}`,
+						),
+					),
+					0,
+					0,
+				),
+			);
+		}
+		if (this.#provenance)
+			this.addChild(new Text(theme.fg("dim", "Provenance recorded for this generated setup."), 0, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("muted", `Enabled: ${this.#enabled ? "yes" : "no"}`), 0, 0));
+		this.addChild(new Text(theme.fg("muted", "Providers (↑/↓ reorder; x removes; m edits allowlist):"), 0, 0));
+		for (let index = 0; index < this.#draft.providers.length; index++) {
+			const provider = this.#draft.providers[index] ?? "";
+			const prefix = index === this.#providerCursor ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
+			this.addChild(new Text(`${prefix}${displaySafe(provider)}`, 0, 0));
+		}
+		if (this.#draft.providers.length === 0)
+			this.addChild(new Text(theme.fg("error", "  No providers declared."), 0, 0));
+		if (this.#allowlistEditing) {
+			this.addChild(
+				new Text(theme.fg("accent", displaySafe(`Allowlist: ${this.#allowlistBuffer || "(all models)"}`)), 0, 0),
+			);
+			this.addChild(
+				new Text(theme.fg("muted", "  Type provider/model values separated by commas, then Enter."), 0, 0),
+			);
+		} else {
+			this.addChild(
+				new Text(
+					theme.fg(
+						"dim",
+						displaySafe(
+							`Allowlist: ${this.#draft.models && this.#draft.models.length > 0 ? this.#draft.models.join(", ") : "(all labeled models)"}`,
+						),
+					),
+					0,
+					0,
+				),
+			);
+		}
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("muted", "Preview:"), 0, 0));
+		for (const tier of ["fast", "balanced", "strong"] as const) {
+			this.addChild(new Text(`  ${formatTier(tier, this.#preview.tiers)}`, 0, 0));
+		}
+		if (this.#status) this.addChild(new Text(theme.fg("success", displaySafe(this.#status)), 0, 0));
+		if (this.#error) this.addChild(new Text(theme.fg("error", displaySafe(this.#error)), 0, 0));
+		if (this.#confirmation === "clear") {
+			this.addChild(
+				new Text(
+					theme.fg("warning", "Clear generated tiers, setup, and provenance? Enter confirms; Esc cancels."),
+					0,
+					0,
+				),
+			);
+		} else if (this.#confirmation === "hand-edit") {
+			this.addChild(
+				new Text(
+					theme.fg(
+						"warning",
+						"Stored tiers were hand-edited. Regenerate and replace them? Enter confirms; Esc cancels.",
+					),
+					0,
+					0,
+				),
+			);
+		}
+		this.addChild(new Spacer(1));
+		const actions = this.#readOnly ? "Esc: cancel" : "a: apply · r: refresh · t: toggle · c: clear · Esc: cancel";
+		this.addChild(new Text(theme.fg("muted", actions), 0, 0));
+	}
+
+	#recomputePreview(): void {
+		try {
+			this.#preview = clonePreview(this.#generatePreview(this.#draft));
+			this.#error = "";
+		} catch (error) {
+			this.#error = error instanceof Error ? error.message : String(error);
+		}
+	}
+
+	async #emit(intent: SmartRoutingIntent): Promise<void> {
+		if (this.#readOnly || this.#mode === "committing") return;
+		this.#mode = "committing";
+		this.#status = "Committing smart-routing settings…";
+		this.#error = "";
+		this.#confirmation = undefined;
+		this.#render();
+		try {
+			const result = await this.#onSelect(intent);
+			if (intent.kind === "apply") {
+				const appliedPreview = result ?? this.#generatePreview(intent.draft);
+				this.#draft = cloneSetup(appliedPreview.setup);
+				this.#preview = clonePreview(appliedPreview);
+			} else if (intent.kind === "toggle") {
+				this.#enabled = intent.enabled;
+			}
+			this.#mode = "done";
+			this.#status = intent.kind === "clear" ? "Generated setup cleared." : "Smart-routing settings saved.";
+		} catch (error) {
+			const typed = error as { code?: unknown } | undefined;
+			if (typed?.code === "autorouting-hand-edited") {
+				this.#mode = "confirming";
+				this.#confirmation = "hand-edit";
+				// Retain the intent that triggered the guard so confirming replays THAT intent. An Apply
+				// carrying an edited draft must not be silently downgraded to a Refresh, which would
+				// discard the frozen preview and commit the previously recorded setup instead (AC6).
+				this.#pendingIntent = intent;
+				this.#status = "";
+				this.#error = "";
+			} else {
+				this.#mode = "error";
+				this.#error = error instanceof Error ? error.message : String(error);
+				this.#status = "";
+			}
+		}
+		this.#render();
+	}
+
+	#beginClearConfirmation(): void {
+		if (this.#readOnly || this.#mode !== "editing") return;
+		this.#mode = "confirming";
+		this.#confirmation = "clear";
+		this.#render();
+	}
+
+	#commitAllowlistBuffer(): void {
+		const values = this.#allowlistBuffer
+			.split(",")
+			.map(value => value.trim())
+			.filter(value => value.length > 0);
+		this.#draft =
+			values.length > 0
+				? { ...this.#draft, models: [...new Set(values)] }
+				: { schema: 1, providers: [...this.#draft.providers] };
+		this.#allowlistEditing = false;
+		this.#allowlistBuffer = "";
+		this.#recomputePreview();
+		this.#render();
+	}
+
+	handleInput(data: string): void {
+		if (this.#mode === "committing") return;
+		if (this.#mode === "done" || this.#mode === "error") {
+			if (getKeybindings().matches(data, "tui.select.cancel")) this.#onCancel();
+			return;
+		}
+		if (this.#confirmation) {
+			if (getKeybindings().matches(data, "tui.select.cancel")) {
+				this.#confirmation = undefined;
+				this.#pendingIntent = undefined;
+				this.#mode = "editing";
+				this.#render();
+				return;
+			}
+			if (matchesKey(data, "enter") || matchesKey(data, "return") || data === "\n") {
+				void this.#emitConfirmed();
+			}
+			return;
+		}
+		if (this.#allowlistEditing) {
+			if (matchesKey(data, "enter") || matchesKey(data, "return") || data === "\n") {
+				this.#commitAllowlistBuffer();
+				return;
+			}
+			if (getKeybindings().matches(data, "tui.select.cancel")) {
+				this.#allowlistEditing = false;
+				this.#allowlistBuffer = "";
+				this.#render();
+				return;
+			}
+			if (isBackspace(data)) {
+				this.#allowlistBuffer = this.#allowlistBuffer.slice(0, -1);
+				this.#render();
+				return;
+			}
+			if (isPrintable(data)) {
+				this.#allowlistBuffer += data;
+				this.#render();
+			}
+			return;
+		}
+		if (getKeybindings().matches(data, "tui.select.cancel")) {
+			this.#onCancel();
+			return;
+		}
+		if (this.#readOnly) return;
+		if (data === "m" || data === "M") {
+			this.#allowlistEditing = true;
+			this.#allowlistBuffer = this.#draft.models?.join(", ") ?? "";
+			this.#render();
+			return;
+		}
+		if (data === "x" || data === "X") {
+			if (this.#draft.providers.length <= 1) {
+				this.#error = "At least one provider must remain declared.";
+				this.#render();
+				return;
+			}
+			const providers = this.#draft.providers.filter((_, index) => index !== this.#providerCursor);
+			this.#draft = { ...this.#draft, providers };
+			this.#providerCursor = Math.min(this.#providerCursor, providers.length - 1);
+			this.#recomputePreview();
+			this.#render();
+			return;
+		}
+		if (matchesKey(data, "up")) {
+			if (this.#providerCursor > 0) {
+				const providers = [...this.#draft.providers];
+				[providers[this.#providerCursor - 1], providers[this.#providerCursor]] = [
+					providers[this.#providerCursor]!,
+					providers[this.#providerCursor - 1]!,
+				];
+				this.#draft = { ...this.#draft, providers };
+				this.#providerCursor--;
+				this.#recomputePreview();
+				this.#render();
+			}
+			return;
+		}
+		if (matchesKey(data, "down")) {
+			if (this.#providerCursor < this.#draft.providers.length - 1) {
+				const providers = [...this.#draft.providers];
+				[providers[this.#providerCursor], providers[this.#providerCursor + 1]] = [
+					providers[this.#providerCursor + 1]!,
+					providers[this.#providerCursor]!,
+				];
+				this.#draft = { ...this.#draft, providers };
+				this.#providerCursor++;
+				this.#recomputePreview();
+				this.#render();
+			}
+			return;
+		}
+		if (data === "a" || data === "A") {
+			void this.#emit({ kind: "apply", draft: cloneSetup(this.#draft), preview: clonePreview(this.#preview) });
+			return;
+		}
+		if (data === "r" || data === "R") {
+			void this.#emit({ kind: "refresh" });
+			return;
+		}
+		if (data === "t" || data === "T") {
+			void this.#emit({ kind: "toggle", enabled: !this.#enabled });
+			return;
+		}
+		if (data === "c" || data === "C") {
+			this.#beginClearConfirmation();
+		}
+	}
+
+	__testApply(): Promise<void> {
+		return this.#emit({ kind: "apply", draft: cloneSetup(this.#draft), preview: clonePreview(this.#preview) });
+	}
+
+	/** Test hook mirroring an in-panel provider reorder/edit: mutates the draft and re-previews. */
+	__testSetProviders(providers: string[]): void {
+		this.#draft = { ...this.#draft, providers: [...providers] };
+		this.#preview = this.#generatePreview(this.#draft);
+		this.#providerCursor = 0;
+	}
+
+	__testRefresh(confirmHandEdit = false): Promise<void> {
+		return this.#emit({ kind: "refresh", ...(confirmHandEdit ? { confirmHandEdit: true } : {}) });
+	}
+
+	__testToggle(enabled = !this.#enabled): Promise<void> {
+		return this.#emit({ kind: "toggle", enabled });
+	}
+
+	__testClear(): Promise<void> {
+		return this.#emit({ kind: "clear" });
+	}
+
+	__testConfirm(): Promise<void> {
+		return this.#emitConfirmed();
+	}
+
+	/**
+	 * Replay the intent the confirmation was raised for. A `clear` confirmation always emits `clear`;
+	 * a hand-edit confirmation re-emits the ORIGINAL intent with `confirmHandEdit`, so a guarded Apply
+	 * commits its own edited draft instead of being downgraded to a Refresh of the recorded setup.
+	 */
+	#emitConfirmed(): Promise<void> {
+		if (this.#confirmation === "clear") return this.#emit({ kind: "clear" });
+		if (this.#confirmation !== "hand-edit") return Promise.resolve();
+		const pending = this.#pendingIntent;
+		this.#pendingIntent = undefined;
+		if (pending?.kind === "apply")
+			return this.#emit({ kind: "apply", draft: pending.draft, preview: pending.preview, confirmHandEdit: true });
+		return this.#emit({ kind: "refresh", confirmHandEdit: true });
+	}
+}

package/src/modes/components/tool-status-header.ts

@@ -1048,9 +1048,12 @@ export class StatusLineComponent implements Component {
 	render(width: number): string[] {
 		const lines: string[] = [];
 		this.#refreshSkillHudInBackground();
-		const skillHud = this.#settings.showSkillHud === false ? null : renderSkillHudBar(this.#skillHudEntries, width);
-		if (skillHud) {
-			lines.push(skillHud);
+		const skillHudRows =
+			this.#settings.showSkillHud === false ? null : renderSkillHudBar(this.#skillHudEntries, width);
+		if (skillHudRows) {
+			for (const skillHudRow of skillHudRows) {
+				if (skillHudRow) lines.push(truncateToWidth(skillHudRow, width));
+			}
 		}
 
 		const statusRows = this.#buildStatusRows(width, this.#resolveMaxRows());

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

@@ -188,6 +188,10 @@ export class CommandController {
 			const customShare = await loadCustomShare();
 			if (customShare) {
 				const loader = new BorderedLoader(this.ctx.ui, theme, "Sharing...");
+				// The composer is reusable across overlays; detach it before clearing so
+				// clear() disposes only the transient loader, not the editor's
+				// tab-width listener / paste state (disposal is terminal).
+				this.ctx.editorContainer.detachChild(this.ctx.editor);
 				this.ctx.editorContainer.clear();
 				this.ctx.editorContainer.addChild(loader);
 				this.ctx.ui.setFocus(loader);
@@ -244,6 +248,10 @@ export class CommandController {
 			return;
 		}
 
+		// The composer is reusable across overlays; detach it before clearing so
+		// clear() disposes only the transient loader, not the editor's
+		// tab-width listener / paste state (disposal is terminal).
+		this.ctx.editorContainer.detachChild(this.ctx.editor);
 		const loader = new BorderedLoader(this.ctx.ui, theme, "Creating gist...");
 		this.ctx.editorContainer.clear();
 		this.ctx.editorContainer.addChild(loader);
@@ -1153,13 +1161,15 @@ export class CommandController {
 		}
 
 		try {
-			await this.ctx.sessionManager.flush();
-			await this.ctx.sessionManager.moveTo(resolvedPath);
-			setProjectDir(resolvedPath);
-			clearClaudePluginRootsCache(); // re-warms preloadedPluginRoots with new project dir (async)
-			resetCapabilities();
-			await this.ctx.refreshSlashCommandState(resolvedPath);
-			await this.ctx.session.refreshSshTool({ activateIfAvailable: true });
+			await this.ctx.sessionManager.runExclusiveCwdTransition(async () => {
+				await this.ctx.sessionManager.flush();
+				await this.ctx.sessionManager.moveTo(resolvedPath);
+				setProjectDir(resolvedPath);
+				clearClaudePluginRootsCache();
+				resetCapabilities();
+				await this.ctx.refreshSlashCommandState(resolvedPath);
+				await this.ctx.session.refreshSshTool({ activateIfAvailable: true });
+			});
 
 			this.ctx.statusLine.invalidate();
 			this.ctx.updateEditorTopBorder();

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

@@ -15,6 +15,7 @@ import {
 	type ComposerSubmissionOptions,
 	canApplyComposerSubmission,
 	type InteractiveModeContext,
+	stopInteractiveActivityIndicator,
 } from "../../modes/types";
 import type { AgentSessionEvent, QueuedMessageEditEntry } from "../../session/agent-session";
 import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../session/messages";
@@ -219,9 +220,13 @@ export class InputController {
 			case "app.queue.togglePane":
 				return true;
 			case "app.message.sendNow":
+				// `sendNow()` falls back to `getQueuedMessageEntries()[0]`, which returns
+				// only visible steering/follow-up entries, so advertising the action for
+				// hidden next-turn context enabled a keybinding whose only outcome is
+				// "No visible queued message to send".
 				return (
 					this.ctx.session.isStreaming &&
-					(this.ctx.editor.getText().trim().length > 0 || this.ctx.session.queuedMessageCount > 0)
+					(this.ctx.editor.getText().trim().length > 0 || this.ctx.session.drainableQueuedMessageCount > 0)
 				);
 			default:
 				return true;
@@ -356,8 +361,29 @@ export class InputController {
 			if (this.ctx.cancelPendingSubmission()) {
 				return true;
 			}
-			this.restoreQueuedMessagesToEditor({ abort: true });
-			return true;
+			// Only count queues this handler can actually drain. The aggregate
+			// `queuedMessageCount` also counts hidden next-turn context, which
+			// `restoreQueuedMessagesToEditor()` never returns and which survives turn
+			// completion by design, so gating on the aggregate left a permanently
+			// nonzero count that made every press a no-op abort — the #4741 lockout.
+			const hasCancellableWork =
+				this.ctx.hasPendingSubmission() ||
+				this.ctx.session.drainableQueuedMessageCount > 0 ||
+				(this.ctx.compactionQueuedMessages?.length ?? 0) > 0 ||
+				this.ctx.session.isStreaming ||
+				this.ctx.session.isCompacting;
+			if (hasCancellableWork) {
+				this.restoreQueuedMessagesToEditor({ abort: true });
+				return true;
+			}
+			// The loader outlived its turn and no submission is pending (a started
+			// submission still inside prompt preflight stays cancellable above, so
+			// Esc aborts it instead of letting it start later), so nothing is
+			// cancellable even though the busy indicator is still mounted (#4741).
+			// Stop the stale indicator so completed work clears the busy state and
+			// keep evaluating the remaining states; when none match, the key falls
+			// through to idle semantics instead of a no-op abort that swallows it.
+			stopInteractiveActivityIndicator(this.ctx);
 		}
 		if (options.processes && this.ctx.session.isBashRunning) {
 			this.ctx.session.abortBash();
@@ -440,7 +466,7 @@ export class InputController {
 			if (isClearKey && !isInterruptKey) {
 				if (this.#handlePendingSteerInterrupt()) return { consume: true };
 				if (
-					!this.#handleCancellableWorkEscape({
+					this.#handleCancellableWorkEscape({
 						loading: true,
 						processes: true,
 						modes: true,
@@ -449,10 +475,12 @@ export class InputController {
 						streaming: true,
 					})
 				) {
-					return undefined;
+					this.#resetEscapeGestures();
+					return { consume: true };
 				}
-				this.#resetEscapeGestures();
-				return { consume: true };
+				// A stale loader was stopped and nothing else consumed the clear key:
+				// release it to the editor so the idle clear path still runs (#4741).
+				return undefined;
 			}
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				this.#resetEscapeGestures();
@@ -861,8 +889,11 @@ export class InputController {
 			}
 		}
 
-		// Empty submit while streaming with queued messages: flush queues immediately
-		if (!text && this.ctx.session.isStreaming && this.ctx.session.queuedMessageCount > 0) {
+		// Empty submit while streaming with queued messages: flush queues immediately.
+		// Only drainable queues justify the abort — aborting for hidden next-turn
+		// context would kill the live turn without flushing anything, since that
+		// context is not delivered by the resume path this abort relies on.
+		if (!text && this.ctx.session.isStreaming && this.ctx.session.drainableQueuedMessageCount > 0) {
 			// Abort current stream and let queued messages be processed
 			await this.#abortInteractive();
 			return;
@@ -1341,6 +1372,10 @@ export class InputController {
 					),
 			},
 		);
+		// The composer is reusable across overlays; detach it before clearing so
+		// clear() disposes only the transient selector, not the editor's
+		// tab-width listener (disposal is terminal).
+		this.ctx.editorContainer.detachChild(this.ctx.editor);
 		this.ctx.editorContainer.clear();
 		this.ctx.editorContainer.addChild(selector);
 		this.ctx.ui.setFocus(selector);