@gajae-code/coding-agent 0.2.2 → 0.2.4

package/src/internal-urls/memory-protocol.ts

@@ -15,11 +15,12 @@ const MEMORY_NAMESPACE = "root";
  * may see different roots.
  */
 export function memoryRootsFromRegistry(): string[] {
-	const agentDir = getAgentDir();
 	const roots: string[] = [];
 	for (const ref of AgentRegistry.global().list()) {
-		const sm = ref.session?.sessionManager;
+		const session = ref.session;
+		const sm = session?.sessionManager;
 		if (!sm) continue;
+		const agentDir = session.settings?.getAgentDir() ?? getAgentDir();
 		const root = getMemoryRoot(agentDir, sm.getCwd());
 		if (root && !roots.includes(root)) roots.push(root);
 	}

package/src/main.ts

@@ -49,7 +49,7 @@ import { formatModelOnboardingGuidance } from "./setup/model-onboarding-guidance
 import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { resolvePromptInput } from "./system-prompt";
 import type { LspStartupServerInfo } from "./tools";
-import { getChangelogPath, getNewEntries, parseChangelog } from "./utils/changelog";
+import { getDisplayChangelogEntries, getNewEntries } from "./utils/changelog";
 import type { EventBus } from "./utils/event-bus";
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
@@ -341,8 +341,7 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 		return undefined;
 	}
 
-	const changelogPath = getChangelogPath();
-	const entries = await parseChangelog(changelogPath);
+	const entries = getDisplayChangelogEntries();
 
 	if (!lastVersion) {
 		if (entries.length > 0) {

package/src/memories/index.ts

@@ -12,6 +12,7 @@ import consolidationTemplate from "../prompts/memories/consolidation.md" with {
 import readPathTemplate from "../prompts/memories/read-path.md" with { type: "text" };
 import stageOneInputTemplate from "../prompts/memories/stage_one_input.md" with { type: "text" };
 import stageOneSystemTemplate from "../prompts/memories/stage_one_system.md" with { type: "text" };
+import unavailableTemplate from "../prompts/memories/unavailable.md" with { type: "text" };
 import type { AgentSession } from "../session/agent-session";
 import {
 	claimStage1Jobs,
@@ -149,23 +150,24 @@ export function startMemoryStartupTask(options: {
 export async function buildMemoryToolDeveloperInstructions(
 	agentDir: string,
 	settings: Settings,
+	session?: AgentSession,
 ): Promise<string | undefined> {
 	const cfg = loadMemoryConfig(settings);
 	if (!cfg.enabled) return undefined;
-	const memoryRoot = getMemoryRoot(agentDir, settings.getCwd());
+	const memoryRoot = getMemoryRoot(agentDir, session?.sessionManager?.getCwd() ?? settings.getCwd());
 	const summaryPath = path.join(memoryRoot, "memory_summary.md");
 
 	let text: string;
 	try {
 		text = await Bun.file(summaryPath).text();
 	} catch {
-		return undefined;
+		return unavailableTemplate;
 	}
 
 	const summary = text.trim();
-	if (!summary) return undefined;
+	if (!summary) return unavailableTemplate;
 	const truncated = truncateByApproxTokens(summary, cfg.summaryInjectionTokenLimit);
-	if (!truncated.trim()) return undefined;
+	if (!truncated.trim()) return unavailableTemplate;
 
 	return prompt.render(readPathTemplate, {
 		memory_summary: truncated,

package/src/memory-backend/local-backend.ts

@@ -9,22 +9,30 @@ import type { MemoryBackend } from "./types";
 /**
  * Wraps the existing `memories/` module as a `MemoryBackend`.
  *
- * No behavioural change — every call delegates to the legacy entry points so
- * the local memory pipeline (rollout summarisation → SQLite → memory_summary.md)
- * keeps working exactly as before.
+ * The local pipeline owns rollout summarisation, SQLite retention, and
+ * `memory_summary.md`. Prompt reads use the live session cwd when available so
+ * manual enqueue/rebuild and startup hydration address the same memory root.
  */
 export const localBackend: MemoryBackend = {
 	id: "local",
 	start(options) {
 		startMemoryStartupTask(options);
 	},
-	async buildDeveloperInstructions(agentDir, settings) {
-		return buildMemoryToolDeveloperInstructions(agentDir, settings);
+	async buildDeveloperInstructions(agentDir, settings, session) {
+		return buildMemoryToolDeveloperInstructions(agentDir, settings, session);
 	},
 	async clear(agentDir, cwd) {
 		await clearMemoryData(agentDir, cwd);
 	},
-	async enqueue(agentDir, cwd) {
+	async enqueue(agentDir, cwd, session) {
 		enqueueMemoryConsolidation(agentDir, cwd);
+		if (!session) return;
+		startMemoryStartupTask({
+			session,
+			settings: session.settings,
+			modelRegistry: session.modelRegistry,
+			agentDir,
+			taskDepth: session.taskDepth,
+		});
 	},
 };

package/src/modes/components/hook-selector.ts

@@ -14,6 +14,7 @@ import {
 	type TUI,
 	truncateToWidth,
 	visibleWidth,
+	wrapTextWithAnsi,
 } from "@gajae-code/tui";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { matchesAppExternalEditor, matchesSelectCancel } from "../../modes/utils/keybinding-matchers";
@@ -31,6 +32,13 @@ export interface HookSelectorOptions {
 	onRight?: () => void;
 	onExternalEditor?: () => void;
 	helpText?: string;
+	/**
+	 * When true, the focused option's label wraps across multiple rows so the
+	 * full text is visible. Non-focused options remain single-row with the
+	 * existing `…` truncation hint. When unset/false, rendering is
+	 * byte-identical to the previous implementation for all consumers.
+	 */
+	wrapFocused?: boolean;
 }
 
 class OutlinedList extends Container {
@@ -55,12 +63,140 @@ class OutlinedList extends Container {
 	}
 }
 
+/**
+ * Width-aware list child that owns wrapped focused-option layout.
+ *
+ * Single layout owner for the `wrapFocused` branch: row budgeting, sibling
+ * selection, marker placement, and finalized row construction all happen
+ * inside `render(width)` using the actual incoming width. The outer host
+ * (`HookSelectorComponent`) feeds it `options`, `selectedIndex`, and
+ * `maxVisibleRows`; everything that depends on terminal width is recomputed
+ * on each render so resize Just Works.
+ *
+ * `maxVisibleRows` is a sibling budget before it is a hard cap: surrounding
+ * options shrink first so the focused option is never clipped. The single
+ * allowed overflow exception is when the focused option's wrapped block
+ * alone exceeds the budget — in that case the focused option is rendered
+ * fully with zero siblings.
+ */
+class FocusAwareList extends Container {
+	#options: string[] = [];
+	#selectedIndex = 0;
+	#maxVisibleRows = 0;
+	#outline: boolean;
+
+	constructor(outline: boolean) {
+		super();
+		this.#outline = outline;
+	}
+
+	setState(options: string[], selectedIndex: number, maxVisibleRows: number): void {
+		this.#options = options;
+		this.#selectedIndex = Math.max(0, Math.min(selectedIndex, options.length - 1));
+		this.#maxVisibleRows = Math.max(1, maxVisibleRows);
+		this.invalidate();
+	}
+
+	render(width: number): string[] {
+		if (this.#options.length === 0) return this.#outline ? this.#wrapOutline([], width) : [];
+
+		const mdTheme = getMarkdownTheme();
+		const innerWidth = this.#outline ? Math.max(1, width - 2) : Math.max(1, width);
+
+		// Selected/non-selected prefixes mirror the legacy `#updateList` shape.
+		const styledSelectedPrefix = theme.fg("accent", `${theme.nav.cursor} `);
+		const nonSelectedPrefix = "  ";
+		const prefixWidth = visibleWidth(styledSelectedPrefix);
+		const continuationPrefix = " ".repeat(prefixWidth);
+		const availableLabelWidth = Math.max(1, innerWidth - prefixWidth);
+
+		// Render the focused label up front so we can measure how many rows it
+		// will consume at the current width and budget siblings accordingly.
+		const focusedLabel = renderInlineMarkdown(this.#options[this.#selectedIndex] ?? "", mdTheme, t =>
+			theme.fg("accent", t),
+		);
+		const focusedWrappedSegments = wrapTextWithAnsi(focusedLabel, availableLabelWidth);
+		const focusedRows = Math.max(1, focusedWrappedSegments.length);
+
+		// Decide whether the position marker is going to be shown. We make a
+		// pessimistic first pass assuming the marker is needed; if the window
+		// ends up covering every option we drop it.
+		const totalOptions = this.#options.length;
+		const willHaveSiblings = totalOptions > 1;
+		const wouldNeedMarker = willHaveSiblings; // tentative; refined below
+		const markerSlot = wouldNeedMarker ? 1 : 0;
+
+		// Sibling budget. If the focused block alone is over budget, render it
+		// fully with zero siblings (only allowed overflow exception).
+		const siblingBudget = Math.max(0, this.#maxVisibleRows - focusedRows - markerSlot);
+
+		// Distribute sibling slots around focus, preferring closest options.
+		const availableAbove = this.#selectedIndex;
+		const availableBelow = totalOptions - this.#selectedIndex - 1;
+		let above = Math.min(availableAbove, Math.floor(siblingBudget / 2));
+		let below = Math.min(availableBelow, siblingBudget - above);
+		// Transfer unused quota across the focus when one side has fewer
+		// options than its share.
+		const unusedBelow = siblingBudget - above - below;
+		if (unusedBelow > 0) above = Math.min(availableAbove, above + unusedBelow);
+		const unusedAbove = siblingBudget - above - below;
+		if (unusedAbove > 0) below = Math.min(availableBelow, below + unusedAbove);
+
+		const startIndex = this.#selectedIndex - above;
+		const endIndex = this.#selectedIndex + below + 1;
+		const showMarker = startIndex > 0 || endIndex < totalOptions;
+
+		const rows: string[] = [];
+		for (let i = startIndex; i < endIndex; i++) {
+			if (i === this.#selectedIndex) {
+				// Emit focused wrapped rows. Cursor only on row 0; continuation
+				// rows are whitespace-aligned under the label start.
+				for (let r = 0; r < focusedWrappedSegments.length; r++) {
+					const segment = focusedWrappedSegments[r] ?? "";
+					rows.push(r === 0 ? styledSelectedPrefix + segment : continuationPrefix + segment);
+				}
+			} else {
+				const label = renderInlineMarkdown(this.#options[i] ?? "", mdTheme, t => theme.fg("text", t));
+				// Non-focused rows stay single-line. Truncate here so the
+				// outline (post-padded by `#wrapOutline`) and non-outline
+				// paths render the same `…` hint for over-wide labels.
+				const fittedLabel = truncateToWidth(label, availableLabelWidth);
+				rows.push(nonSelectedPrefix + fittedLabel);
+			}
+		}
+
+		if (showMarker) {
+			rows.push(theme.fg("dim", `  (${this.#selectedIndex + 1}/${totalOptions})`));
+		}
+
+		return this.#outline ? this.#wrapOutline(rows, width) : rows;
+	}
+
+	#wrapOutline(rows: string[], width: number): string[] {
+		// Mirror the outline border drawn by `OutlinedList.render(width)`. The
+		// rows passed in are already constrained to `innerWidth` by
+		// `wrapTextWithAnsi`, so we only normalize tabs and pad — no further
+		// truncation, which would clip wrapped focused labels.
+		const borderColor = (text: string) => theme.fg("border", text);
+		const horizontal = borderColor(theme.boxSharp.horizontal.repeat(Math.max(1, width)));
+		const innerWidth = Math.max(1, width - 2);
+		const content = rows.map(line => {
+			const normalized = replaceTabs(line);
+			const fitted = truncateToWidth(normalized, innerWidth);
+			const pad = Math.max(0, innerWidth - visibleWidth(fitted));
+			return `${borderColor(theme.boxSharp.vertical)}${fitted}${padding(pad)}${borderColor(theme.boxSharp.vertical)}`;
+		});
+		return [horizontal, ...content, horizontal];
+	}
+}
+
 export class HookSelectorComponent extends Container {
 	#options: string[];
 	#selectedIndex: number;
 	#maxVisible: number;
 	#listContainer: Container | undefined;
 	#outlinedList: OutlinedList | undefined;
+	#focusAwareList: FocusAwareList | undefined;
 	#onSelectCallback: (option: string) => void;
 	#onCancelCallback: () => void;
 	#titleComponent: Markdown;
@@ -69,6 +205,8 @@ export class HookSelectorComponent extends Container {
 	#onLeftCallback: (() => void) | undefined;
 	#onRightCallback: (() => void) | undefined;
 	#onExternalEditorCallback: (() => void) | undefined;
+	#wrapFocused: boolean;
+	#outline: boolean;
 	constructor(
 		title: string,
 		options: string[],
@@ -87,6 +225,8 @@ export class HookSelectorComponent extends Container {
 		this.#onLeftCallback = opts?.onLeft;
 		this.#onRightCallback = opts?.onRight;
 		this.#onExternalEditorCallback = opts?.onExternalEditor;
+		this.#wrapFocused = opts?.wrapFocused === true;
+		this.#outline = opts?.outline === true;
 
 		this.addChild(new DynamicBorder());
 		this.addChild(new Spacer(1));
@@ -113,7 +253,13 @@ export class HookSelectorComponent extends Container {
 			);
 		}
 
-		if (opts?.outline) {
+		if (this.#wrapFocused) {
+			// Width-aware child owns wrapped layout. It handles both outline
+			// and non-outline rendering paths internally so the cursor signal
+			// + continuation indent are identical across branches.
+			this.#focusAwareList = new FocusAwareList(this.#outline);
+			this.addChild(this.#focusAwareList);
+		} else if (this.#outline) {
 			this.#outlinedList = new OutlinedList();
 			this.addChild(this.#outlinedList);
 		} else {
@@ -130,6 +276,15 @@ export class HookSelectorComponent extends Container {
 	}
 
 	#updateList(): void {
+		if (this.#wrapFocused && this.#focusAwareList) {
+			this.#focusAwareList.setState(this.#options, this.#selectedIndex, this.#maxVisible);
+			return;
+		}
+
+		// Legacy branch — byte-identical to the previous implementation. Any
+		// change here is a regression against
+		// `BASELINE_OUTLINED_RENDER_80_STRIPPED` in
+		// `packages/coding-agent/test/hook-selector-overflow.test.ts`.
 		const lines: string[] = [];
 		const startIndex = Math.max(
 			0,

package/src/modes/components/settings-selector.ts

@@ -200,8 +200,10 @@ export interface StatusLinePreviewSettings {
 export interface SettingsCallbacks {
 	/** Called when any setting value changes */
 	onChange: (path: SettingPath, newValue: unknown) => void;
-	/** Called for theme preview while browsing */
+	/** Called for theme preview while browsing theme settings */
 	onThemePreview?: (theme: string) => void | Promise<void>;
+	/** Called to restore the rendered theme when theme settings preview is cancelled */
+	onThemePreviewCancel?: (theme: string) => void | Promise<void>;
 	/** Called for status line preview while configuring */
 	onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
 	/** Get current rendered status line for inline preview */
@@ -219,7 +221,6 @@ export interface SettingsCallbacks {
 export class SettingsSelectorComponent extends Container {
 	#tabBar: TabBar;
 	#currentList: SettingsList | null = null;
-	#currentSubmenu: Container | null = null;
 	#pluginComponent: PluginSettingsComponent | null = null;
 	#statusPreviewContainer: Container | null = null;
 	#statusPreviewText: Text | null = null;
@@ -376,13 +377,13 @@ export class SettingsSelectorComponent extends Container {
 		let onPreview: ((value: string) => void | Promise<void>) | undefined;
 		let onPreviewCancel: (() => void) | undefined;
 
-		const activeThemeBeforePreview = getCurrentThemeName() ?? currentValue;
 		if (def.path === "theme.dark" || def.path === "theme.light") {
+			const activeThemeBeforePreview = getCurrentThemeName() ?? currentValue;
 			onPreview = value => {
 				return this.callbacks.onThemePreview?.(value);
 			};
 			onPreviewCancel = () => {
-				this.callbacks.onThemePreview?.(activeThemeBeforePreview);
+				return this.callbacks.onThemePreviewCancel?.(activeThemeBeforePreview);
 			};
 		} else if (def.path === "statusLine.preset") {
 			onPreview = value => {
@@ -619,17 +620,20 @@ export class SettingsSelectorComponent extends Container {
 			return;
 		}
 
-		// Escape at top level cancels
-		if (matchesAppInterrupt(data) && !this.#currentSubmenu) {
-			this.callbacks.onCancel();
-			return;
-		}
-
-		// Pass to current content
+		// Pass to current content. SettingsList owns Escape routing so open
+		// submenus can run their cancel/restore callbacks before closing.
 		if (this.#currentList) {
 			this.#currentList.handleInput(data);
-		} else if (this.#pluginComponent) {
+			return;
+		}
+		if (this.#pluginComponent) {
 			this.#pluginComponent.handleInput(data);
+			return;
+		}
+
+		// Fallback for future top-level content that does not own cancellation.
+		if (matchesAppInterrupt(data)) {
+			this.callbacks.onCancel();
 		}
 	}
 }

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

@@ -42,7 +42,7 @@ import type { NewSessionOptions } from "../../session/session-manager";
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
 import { replaceTabs } from "../../tools/render-utils";
-import { getChangelogPath, parseChangelog } from "../../utils/changelog";
+import { getDisplayChangelogEntries } from "../../utils/changelog";
 import { copyToClipboard } from "../../utils/clipboard";
 import { openPath } from "../../utils/open";
 import { setSessionTerminalTitle } from "../../utils/title-generator";
@@ -525,8 +525,7 @@ export class CommandController {
 	}
 
 	async handleChangelogCommand(showFull = false): Promise<void> {
-		const changelogPath = getChangelogPath();
-		const allEntries = await parseChangelog(changelogPath);
+		const allEntries = getDisplayChangelogEntries();
 		// Default to showing only the latest 3 versions unless --full is specified
 		// allEntries comes from parseChangelog with newest first, reverse to show oldest->newest
 		const entriesToShow = showFull ? allEntries : allEntries.slice(0, 3);
@@ -586,7 +585,7 @@ export class CommandController {
 		if (action === "view") {
 			const payload = await backend.buildDeveloperInstructions(agentDir, this.ctx.settings, this.ctx.session);
 			if (!payload) {
-				this.ctx.showWarning("Memory payload is empty (memory backend off, disabled, or no memory available).");
+				this.ctx.showWarning("Memory payload is empty; durable memory is unavailable or unconfirmed.");
 				return;
 			}
 			this.ctx.chatContainer.addChild(new Spacer(1));

package/src/modes/controllers/extension-ui-controller.ts

@@ -623,6 +623,7 @@ export class ExtensionUiController {
 				onTimeout: dialogOptions?.onTimeout,
 				tui: this.ctx.ui,
 				outline: dialogOptions?.outline,
+				wrapFocused: dialogOptions?.wrapFocused,
 				maxVisible,
 			},
 		);

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

@@ -17,8 +17,11 @@ import {
 } from "../../extensibility/plugins/marketplace";
 import {
 	getAvailableThemes,
+	getCurrentThemeName,
+	getDetectedThemeSettingsPath,
 	getSymbolTheme,
 	previewTheme,
+	restoreThemePreview,
 	setColorBlindMode,
 	setSymbolPreset,
 	setTheme,
@@ -29,6 +32,7 @@ import { type SessionInfo, SessionManager } from "../../session/session-manager"
 import { FileSessionStorage } from "../../session/session-storage";
 import {
 	MODEL_ONBOARDING_API_PROVIDER_COMMAND,
+	MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND,
 	MODEL_ONBOARDING_SETUP_COMMAND,
 } from "../../setup/model-onboarding-guidance";
 import { isSearchProviderPreference, setPreferredImageProvider, setPreferredSearchProvider } from "../../tools";
@@ -47,6 +51,7 @@ import {
 import { SessionObserverOverlayComponent } from "../components/session-observer-overlay";
 import { SessionSelectorComponent } from "../components/session-selector";
 import { SettingsSelectorComponent } from "../components/settings-selector";
+import { ThemeSelectorComponent } from "../components/theme-selector";
 import { ToolExecutionComponent } from "../components/tool-execution";
 import { TreeSelectorComponent } from "../components/tree-selector";
 import { UserMessageSelectorComponent } from "../components/user-message-selector";
@@ -62,9 +67,15 @@ const CALLBACK_SERVER_PROVIDERS = new Set<OAuthProvider>([
 
 const MANUAL_LOGIN_TIP = "Tip: You can complete pairing with /login <redirect URL>.";
 
+function isThemePreviewSuperseded(result: { success: boolean; error?: string }): boolean {
+	return !result.success && result.error?.includes("superseded by a newer request") === true;
+}
+
 function formatProviderOnboardingCommandGuide(): string {
 	return [
-		"API-compatible provider setup:",
+		"Provider preset setup:",
+		MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND,
+		"Custom API-compatible provider setup:",
 		MODEL_ONBOARDING_API_PROVIDER_COMMAND,
 		MODEL_ONBOARDING_SETUP_COMMAND,
 	].join("\n");
@@ -132,14 +143,21 @@ export class SelectorController {
 					},
 					{
 						onChange: (id, value) => this.handleSettingChange(id, value),
-						onThemePreview: async themeName => {
-							const result = await previewTheme(themeName);
-							if (result.success) {
-								this.ctx.statusLine.invalidate();
-								this.ctx.updateEditorTopBorder();
-								this.ctx.ui.invalidate();
-								this.ctx.ui.requestRender();
-							}
+						onThemePreview: themeName => {
+							return previewTheme(themeName).then(result => {
+								if (!result.success && result.error && !isThemePreviewSuperseded(result)) {
+									this.ctx.showError(`Failed to preview theme: ${result.error}`);
+								}
+								this.#refreshThemeUi();
+							});
+						},
+						onThemePreviewCancel: themeName => {
+							return restoreThemePreview(themeName).then(result => {
+								if (!result.success && result.error && !isThemePreviewSuperseded(result)) {
+									this.ctx.showError(`Failed to restore theme preview: ${result.error}`);
+								}
+								this.#refreshThemeUi();
+							});
 						},
 						onStatusLinePreview: previewSettings => {
 							// Update status line with preview settings
@@ -184,6 +202,48 @@ export class SelectorController {
 		});
 	}
 
+	#refreshThemeUi(): void {
+		this.ctx.statusLine.invalidate();
+		this.ctx.updateEditorTopBorder();
+		this.ctx.ui.requestRender();
+	}
+
+	showThemeSelector(): void {
+		getAvailableThemes().then(availableThemes => {
+			const initialTheme = getCurrentThemeName() ?? "red-claw";
+			this.showSelector(done => {
+				const selector = new ThemeSelectorComponent(
+					initialTheme,
+					availableThemes,
+					themeName => {
+						const settingPath = getDetectedThemeSettingsPath();
+						settings.set(settingPath, themeName);
+						this.#refreshThemeUi();
+						done();
+					},
+					() => {
+						void restoreThemePreview(initialTheme).then(result => {
+							if (!result.success && result.error) {
+								this.ctx.showError(`Failed to restore theme preview: ${result.error}`);
+							}
+							this.#refreshThemeUi();
+						});
+						done();
+					},
+					themeName => {
+						void previewTheme(themeName).then(result => {
+							if (!result.success && result.error) {
+								this.ctx.showError(`Failed to preview theme: ${result.error}`);
+							}
+							this.#refreshThemeUi();
+						});
+					},
+				);
+				return { component: selector, focus: selector };
+			});
+		});
+	}
+
 	showHistorySearch(): void {
 		const historyStorage = this.ctx.historyStorage;
 		if (!historyStorage) return;

package/src/modes/interactive-mode.ts

@@ -1281,7 +1281,16 @@ export class InteractiveMode implements InteractiveModeContext {
 		reason?: "completed" | "paused" | "dropped";
 	}): Promise<void> {
 		const previousTools = this.#goalModePreviousTools;
-		if (this.goalModeEnabled && previousTools) {
+		// Drop keeps the `goal` tool callable so the agent can immediately create a new
+		// goal in the same session without a leader-side cleanup. Complete (and pause)
+		// exit goal mode and restore the pre-goal tool set even when the goal_updated
+		// event has already cleared goalModeEnabled (see #completeGoalFromTool emitting
+		// state.enabled = false before #exitGoalMode runs). Spec: deep-interview-ultragoal-goal-tool-wiring AC1+AC2.
+		const shouldRestoreTools =
+			previousTools &&
+			options?.reason !== "dropped" &&
+			(this.goalModeEnabled || options?.reason === "completed" || options?.paused === true);
+		if (shouldRestoreTools) {
 			await this.session.setActiveToolsByName(previousTools);
 		}
 		const currentState = this.session.getGoalModeState();
@@ -2339,6 +2348,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showSettingsSelector();
 	}
 
+	showThemeSelector(): void {
+		this.#selectorController.showThemeSelector();
+	}
+
 	showHistorySearch(): void {
 		this.#selectorController.showHistorySearch();
 	}