@gajae-code/coding-agent 0.15.2 → 0.15.4

package/src/modes/controllers/goal-mode-controller.ts

@@ -264,12 +264,15 @@ export class GoalModeController {
 			if (this.#enabled || this.#paused) this.ctx.modeGate.enter("goal");
 			if (restored?.goal) {
 				this.#previousTools = this.ctx.session.getActiveToolNames();
-				await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+				if (!this.ctx.session.isExplicitEmptyToolSelection()) {
+					await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+				}
 			}
 			this.#updateStatus();
 			return true;
 		}
 		if (recoveryHydration) return false;
+		if (this.ctx.session.isExplicitEmptyToolSelection()) return false;
 		const pendingGoal = goalEnabled
 			? await consumePendingGoalModeRequest(this.ctx.sessionManager.getCwd(), this.ctx.sessionManager.getSessionId())
 			: null;
@@ -321,7 +324,9 @@ export class GoalModeController {
 					objective: options.objective ?? "",
 					provenance: options.provenance,
 				});
-		await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+		if (!this.ctx.session.isExplicitEmptyToolSelection()) {
+			await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+		}
 		this.ctx.session.setGoalModeState(state);
 		this.#enabled = true;
 		this.#resetContinuationSuppression();

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

@@ -15,6 +15,7 @@ import {
 	type ComposerSubmissionOptions,
 	canApplyComposerSubmission,
 	type InteractiveModeContext,
+	type SubmittedUserInput,
 	stopInteractiveActivityIndicator,
 } from "../../modes/types";
 import type { AgentSessionEvent, QueuedMessageEditEntry } from "../../session/agent-session";
@@ -38,6 +39,7 @@ import { CommandPalette, type CommandPaletteAction, type CommandPaletteEntry } f
 import type { PasteTextContext } from "../components/custom-editor";
 import { QueuePaneComponent } from "../components/queue-pane";
 import { type QueuedMessageMoveDirection, QueuedMessageSelectorComponent } from "../components/queued-message-selector";
+import { matchesAppInterrupt } from "../utils/keybinding-matchers";
 
 const QUEUE_SELECTOR_NAVIGATION_ACTIONS = [
 	"tui.select.up",
@@ -46,6 +48,23 @@ const QUEUE_SELECTOR_NAVIGATION_ACTIONS = [
 	"tui.select.pageDown",
 ] as const;
 
+/**
+ * Navigation actions that already carry a registry callback and an availability
+ * predicate but shipped with no curated command-palette entry and no key
+ * dispatch, leaving them unreachable from the palette. They opt into
+ * availability gating so an unavailable id is not listed, and each gets a remap
+ * dispatch loop while keeping `defaultKeys: []` -- inert at defaults, but a user
+ * binding now dispatches instead of only being rendered by the selector.
+ */
+export const AVAILABILITY_GATED_NAV_PALETTE_ACTIONS = [
+	"app.session.dashboard",
+	"app.transcript.browse",
+	"app.transcript.prevTurn",
+	"app.transcript.nextTurn",
+	"app.queue.togglePane",
+	"app.message.sendNow",
+] as const satisfies readonly AppKeybinding[];
+
 interface Expandable {
 	setExpanded(expanded: boolean): void;
 	setManuallyExpanded?(expanded: boolean): void;
@@ -75,6 +94,11 @@ function isExpandable(obj: unknown): obj is Expandable {
 export class InputController {
 	readonly actionRegistry: ActionRegistry<void>;
 	readonly #loadPastedImageBatch: typeof loadPastedImageBatch;
+	#deferredSubmission?: {
+		text: string;
+		images?: InteractiveModeContext["pendingImages"];
+		composer: ComposerSubmissionOptions;
+	};
 	#imagePlaceholderDeletionUndo?: {
 		beforeText: string;
 		afterText: string;
@@ -91,6 +115,7 @@ export class InputController {
 			showError: actionId => this.ctx.showError(actionId),
 		});
 		this.#registerActions();
+		this.#installOAuthCopyListener();
 	}
 
 	#registerActions(): void {
@@ -122,6 +147,7 @@ export class InputController {
 			},
 			"app.clipboard.copyLine": () => this.handleCopyCurrentLine(),
 			"app.clipboard.copyPrompt": () => this.handleCopyPrompt(),
+			"app.clipboard.copyOAuthUrl": () => this.ctx.copyOAuthUrl(),
 			"app.session.new": async () => {
 				await this.ctx.handleClearCommand();
 			},
@@ -142,6 +168,7 @@ export class InputController {
 			"app.transcript.prevTurn": () => this.#jumpTranscriptTurn(-1),
 			"app.transcript.nextTurn": () => this.#jumpTranscriptTurn(1),
 			"app.tasks.toggle": () => this.ctx.showTasksPane(),
+			"app.todo.toggle": () => this.ctx.toggleTodoExpansion(),
 			"app.queue.togglePane": () => this.toggleQueuePane(),
 			"app.message.sendNow": () => this.sendNow(),
 		};
@@ -166,7 +193,7 @@ export class InputController {
 			case "app.thinking.toggle":
 				return Boolean(this.ctx.session.model?.reasoning);
 			case "app.commandPalette.open":
-				return this.ctx.editor.getText().trim().length === 0;
+				return true;
 			case "app.model.cycleForward":
 			case "app.model.cycleBackward":
 				return this.ctx.session.getRoleModelCycleCandidateCount() > 1;
@@ -197,6 +224,8 @@ export class InputController {
 				);
 			case "app.clipboard.copyPrompt":
 				return this.ctx.editor.getText().length > 0;
+			case "app.clipboard.copyOAuthUrl":
+				return this.ctx.hasOAuthUrlForCopy();
 			case "app.session.tree":
 			case "app.session.fork":
 				return this.ctx.session.messages.length > 0;
@@ -217,6 +246,8 @@ export class InputController {
 					!this.ctx.goalModeController.enabled &&
 					!this.ctx.goalModeController.paused
 				);
+			case "app.todo.toggle":
+				return this.ctx.todoPhases.some(phase => phase.tasks.length > 0);
 			case "app.queue.togglePane":
 				return true;
 			case "app.message.sendNow":
@@ -234,7 +265,7 @@ export class InputController {
 	}
 
 	#executeAction(id: (typeof APP_ACTION_METADATA)[number]["id"]): void {
-		void this.actionRegistry.execute(id);
+		void this.actionRegistry.executeFresh(id);
 	}
 
 	#transcriptTurnAnchorIds: readonly string[] = [];
@@ -281,17 +312,30 @@ export class InputController {
 	 *  so abort cleanup going idle cannot turn the second Esc into an idle action. */
 	#steerConsumePending = false;
 	#commandPaletteActions = new Map<AppKeybinding, CommandPaletteAction>();
+	/** Opt-in subset of `#commandPaletteActions` whose listing is filtered by the
+	 *  action registry's availability predicate. Deliberately a sibling set rather
+	 *  than a blanket filter over every curated entry: filtering all of them would
+	 *  change visible palette contents for pre-existing thinking, model-cycle,
+	 *  editor, copy, queue, and session actions, which is a separate reviewed
+	 *  migration and not this change. */
+	readonly #availabilityGatedPaletteActions = new Set<AppKeybinding>();
 	#paletteCommandInFlight = false;
 
-	#registerCommandPaletteAction(action: AppKeybinding, handler: () => void | Promise<void>): void {
+	#registerCommandPaletteAction(
+		action: AppKeybinding,
+		handler: () => void | Promise<void>,
+		availabilityGated = false,
+	): void {
 		this.#commandPaletteActions.set(action, {
 			id: action,
 			label: KEYBINDINGS[action].description,
 			handler,
 		});
+		if (availabilityGated) this.#availabilityGatedPaletteActions.add(action);
 	}
 
 	#globalInterruptUnsubscribe: (() => void) | undefined;
+	#oauthCopyUnsubscribe: (() => void) | undefined;
 	#draftClearEscapeText: string | undefined;
 
 	#resetEscapeGestures(): void {
@@ -300,6 +344,21 @@ export class InputController {
 		this.#draftClearEscapeText = undefined;
 	}
 
+	#installOAuthCopyListener(): void {
+		if (typeof this.ctx.ui?.addInputListener !== "function") return;
+		this.#oauthCopyUnsubscribe?.();
+		this.#oauthCopyUnsubscribe = this.ctx.ui.addInputListener(data => {
+			if (this.ctx.hasOAuthUrlForCopy?.() !== true) return;
+			// Focused overlays own cancellation. In particular, a user remap of
+			// copyOAuthUrl to Ctrl+C/Escape must not steal the wizard's interrupt.
+			if (data === "\x03" || matchesAppInterrupt(data)) return;
+			if (this.ctx.keybindings.getKeys("app.clipboard.copyOAuthUrl").some(key => matchesKey(data, key))) {
+				this.#executeAction("app.clipboard.copyOAuthUrl");
+				return { consume: true };
+			}
+		});
+	}
+
 	#armDraftClearEscape(text: string, now: number): void {
 		this.ctx.lastEscapeTime = 0;
 		this.ctx.lastComposerClearEscapeTime = now;
@@ -548,6 +607,7 @@ export class InputController {
 			return bypassAutocomplete;
 		};
 		this.#installGlobalInterruptListener();
+		this.#installOAuthCopyListener();
 
 		// An open btw panel must stay dismissable with Esc even while another
 		// controller (auto-compaction, auto-retry, manual compaction, etc.) has
@@ -695,6 +755,7 @@ export class InputController {
 		);
 		this.ctx.editor.onCopyPrompt = () => this.#executeAction("app.clipboard.copyPrompt");
 		this.#registerCommandPaletteAction("app.clipboard.copyPrompt", copyPrompt);
+		this.#registerCommandPaletteAction("app.clipboard.copyOAuthUrl", () => this.ctx.copyOAuthUrl(), true);
 		this.ctx.editor.onPasteText = (text, context) => this.handleTextPaste(text, context);
 		this.ctx.editor.onPastePendingInputCleared = (reason, restoredInputCount) => {
 			const reasonText = reason === "timeout" ? "timed out" : "exceeded the input queue limit";
@@ -710,10 +771,10 @@ export class InputController {
 		this.ctx.editor.setActionKeys("app.message.dequeue", this.ctx.keybindings.getKeys("app.message.dequeue"));
 		this.ctx.editor.onDequeue = () => this.#executeAction("app.message.dequeue");
 		this.#registerCommandPaletteAction("app.message.dequeue", dequeue);
-		const queue = () => this.handleQueueSubmit();
+		const queue = () => this.#executeAction("app.message.queue");
 		this.ctx.editor.setActionKeys("app.message.queue", this.ctx.keybindings.getKeys("app.message.queue"));
 		this.ctx.editor.onQueue = () => this.#executeAction("app.message.queue");
-		this.#registerCommandPaletteAction("app.message.queue", queue);
+		this.#registerCommandPaletteAction("app.message.queue", queue, true);
 
 		this.ctx.editor.onViewportPageScroll = direction => this.ctx.ui.scrollViewportPages(direction);
 		this.ctx.editor.onViewportFollowLive = () => {
@@ -788,6 +849,21 @@ export class InputController {
 				return true;
 			});
 		}
+		// Six navigation actions that shipped with a registry callback and an
+		// availability predicate but no curated palette entry and no key dispatch.
+		// The palette handler routes through `#executeAction` so the registry's
+		// availability check is enforced on selection as well as on listing, and
+		// `defaultKeys` stays `[]` per the settled no-new-defaults boundary.
+		for (const id of AVAILABILITY_GATED_NAV_PALETTE_ACTIONS) {
+			this.#registerCommandPaletteAction(id, () => this.#executeAction(id), true);
+			for (const key of this.ctx.keybindings.getKeys(id)) {
+				this.ctx.editor.setCustomKeyHandler(key, () => {
+					if (!this.actionRegistry.isAvailable(id)) return false;
+					this.#executeAction(id);
+					return true;
+				});
+			}
+		}
 		for (const key of this.ctx.keybindings.getKeys("app.message.followUp")) {
 			this.ctx.editor.setCustomKeyHandler(key, () => {
 				if (!this.actionRegistry.isAvailable("app.message.followUp")) return false;
@@ -822,6 +898,17 @@ export class InputController {
 				return true;
 			});
 		}
+		// The todo HUD renders a `+N more` row but had no way to expand it:
+		// `toggleTodoExpansion()` had no caller anywhere in src/. The palette entry
+		// opts into availability gating so it is not offered with an empty model.
+		this.#registerCommandPaletteAction("app.todo.toggle", () => this.#executeAction("app.todo.toggle"), true);
+		for (const key of this.ctx.keybindings.getKeys("app.todo.toggle")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => {
+				if (!this.actionRegistry.isAvailable("app.todo.toggle")) return false;
+				this.#executeAction("app.todo.toggle");
+				return true;
+			});
+		}
 		for (const key of this.ctx.keybindings.getKeys("app.tool.backgroundFold")) {
 			this.ctx.editor.setCustomKeyHandler(key, () => {
 				if (!this.actionRegistry.isAvailable("app.tool.backgroundFold")) return false;
@@ -1104,12 +1191,48 @@ export class InputController {
 			const submission = this.ctx.startPendingSubmission({ text, images }, composer);
 
 			this.ctx.onInputCallback(submission);
+		} else if (!this.#deferredSubmission) {
+			const images = inputImages && inputImages.length > 0 ? [...inputImages] : undefined;
+			this.#deferredSubmission = { text, images, composer };
+			if (this.#canModifyComposer(composer)) {
+				this.ctx.editor.setText("");
+				this.#clearPendingImagesIfOwnedBy(pendingImages, composer);
+				this.ctx.editor.addToHistory(text);
+			}
+			return;
+		} else {
+			this.ctx.showStatus("Your previous message is waiting to be sent. Keep this draft and send it again shortly.");
+			return;
 		}
 		if (this.#canModifyComposer(composer)) {
 			this.ctx.editor.addToHistory(text);
 		}
 	}
 
+	takeDeferredSubmission(): SubmittedUserInput | undefined {
+		const deferredSubmission = this.#deferredSubmission;
+		if (!deferredSubmission) return undefined;
+		this.#deferredSubmission = undefined;
+		return this.ctx.startPendingSubmission(
+			{ text: deferredSubmission.text, images: deferredSubmission.images },
+			{ ownsComposer: false, editor: deferredSubmission.composer.editor },
+		);
+	}
+
+	takeDeferredSubmissionForShutdown(): { text: string; images?: InteractiveModeContext["pendingImages"] } | undefined {
+		const deferredSubmission = this.#deferredSubmission;
+		if (!deferredSubmission) return undefined;
+		this.#deferredSubmission = undefined;
+		return {
+			text: deferredSubmission.text,
+			images: deferredSubmission.images,
+		};
+	}
+
+	discardDeferredSubmission(): void {
+		this.#deferredSubmission = undefined;
+	}
+
 	handleCtrlC(): void {
 		const now = Date.now();
 		if (now - this.ctx.lastSigintTime < 500) {
@@ -2109,7 +2232,18 @@ export class InputController {
 			return;
 		}
 
-		const actions = [...this.#commandPaletteActions.values()];
+		const actions = [...this.#commandPaletteActions.entries()]
+			.filter(([id]) => !this.#availabilityGatedPaletteActions.has(id) || this.actionRegistry.isAvailable(id))
+			.map(([id, action]) =>
+				this.#availabilityGatedPaletteActions.has(id)
+					? {
+							...action,
+							handler: async () => {
+								await this.actionRegistry.executeFresh(id);
+							},
+						}
+					: action,
+			);
 		const slashCommands = [...(this.ctx.getSlashCommands?.() ?? this.#slashCommands)];
 		if (!this.ctx.showCommandPalette) {
 			let overlayHandle: ReturnType<typeof this.ctx.ui.showOverlay> | undefined;
@@ -2129,7 +2263,7 @@ export class InputController {
 						keybinding: action.bindingId
 							? this.ctx.keybindings.getKeys(action.bindingId).join(", ") || undefined
 							: undefined,
-						handler: () => this.actionRegistry.execute(action.id),
+						handler: () => this.actionRegistry.executeFresh(action.id),
 					})),
 				...slashCommands.map(command => ({
 					id: `slash:/${command.name}`,

package/src/modes/controllers/plan-mode-controller.ts

@@ -98,6 +98,7 @@ export class PlanModeController {
 	}
 
 	async restoreFromSession(sessionContext: SessionContext): Promise<void> {
+		if (this.ctx.session.isExplicitEmptyToolSelection()) return;
 		if (!this.ctx.session.settings.get("plan.enabled")) {
 			if (sessionContext.mode === "plan" || sessionContext.mode === "plan_paused")
 				this.ctx.sessionManager.appendModeChange("none");
@@ -115,6 +116,10 @@ export class PlanModeController {
 
 	async enter(options?: { planFilePath?: string; workflow?: "parallel" | "iterative" }): Promise<void> {
 		if (this.#enabled) return;
+		if (this.ctx.session.isExplicitEmptyToolSelection()) {
+			this.ctx.showWarning("Plan mode requires built-in tools and is unavailable in a --no-tools session.");
+			return;
+		}
 		if (!this.ctx.modeGate.enter("plan")) return this.ctx.showWarning("Exit goal mode first.");
 		this.#paused = false;
 		const planFilePath = options?.planFilePath ?? "local://PLAN.md";
@@ -122,9 +127,12 @@ export class PlanModeController {
 		this.#previousTools = previousTools;
 		this.#planFilePath = planFilePath;
 		this.#enabled = true;
-		await this.ctx.session.setActiveToolsByName(
-			this.ctx.session.getToolByName("resolve") ? [...new Set([...previousTools, "resolve"])] : previousTools,
-		);
+		const planTools = this.ctx.session.isExplicitEmptyToolSelection()
+			? previousTools
+			: this.ctx.session.getToolByName("resolve")
+				? [...new Set([...previousTools, "resolve"])]
+				: previousTools;
+		await this.ctx.session.setActiveToolsByName(planTools);
 		this.ctx.session.setPlanModeState({
 			enabled: true,
 			planFilePath,
@@ -143,7 +151,7 @@ export class PlanModeController {
 	async exit(options?: { silent?: boolean; paused?: boolean }): Promise<void> {
 		if (!this.#enabled) return;
 		await this.ctx.session.abort({ timeoutMs: ABORT_TIMEOUT_MS });
-		if (this.#previousTools?.length) await this.ctx.session.setActiveToolsByName(this.#previousTools);
+		if (this.#previousTools !== undefined) await this.ctx.session.setActiveToolsByName(this.#previousTools);
 		if (this.#providerSessionScope && !this.ctx.session.isStreaming) {
 			if (await this.ctx.session.restoreTemporaryProviderSessionScope(this.#providerSessionScope))
 				this.#providerSessionScope = undefined;