@gajae-code/coding-agent 0.2.1 → 0.2.3

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

@@ -149,10 +149,11 @@ 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;

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

@@ -21,7 +21,7 @@ import type {
 	StatusLineSeparatorStyle,
 } from "../../config/settings-schema";
 import { SETTING_TABS, TAB_METADATA } from "../../config/settings-schema";
-import { getCurrentThemeName, getSelectListTheme, getSettingsListTheme, theme } from "../../modes/theme/theme";
+import { getSelectListTheme, getSettingsListTheme, theme } from "../../modes/theme/theme";
 import { matchesAppInterrupt } from "../../modes/utils/keybinding-matchers";
 import { getTabBarTheme } from "../shared";
 import { DynamicBorder } from "./dynamic-border";
@@ -200,8 +200,6 @@ export interface StatusLinePreviewSettings {
 export interface SettingsCallbacks {
 	/** Called when any setting value changes */
 	onChange: (path: SettingPath, newValue: unknown) => void;
-	/** Called for theme preview while browsing */
-	onThemePreview?: (theme: string) => void | Promise<void>;
 	/** Called for status line preview while configuring */
 	onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
 	/** Get current rendered status line for inline preview */
@@ -376,15 +374,10 @@ 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") {
-			onPreview = value => {
-				return this.callbacks.onThemePreview?.(value);
-			};
-			onPreviewCancel = () => {
-				this.callbacks.onThemePreview?.(activeThemeBeforePreview);
-			};
-		} else if (def.path === "statusLine.preset") {
+		// Theme selection is confirm-only: moving through the list must not mutate
+		// the rendered theme while the displayed/persisted setting still names
+		// the previous value. Confirmation persists through Settings hooks.
+		if (def.path === "statusLine.preset") {
 			onPreview = value => {
 				const presetDef = getPreset(
 					value as "default" | "minimal" | "compact" | "full" | "nerd" | "ascii" | "custom",

package/src/modes/components/skill-hud/render.ts

@@ -1,4 +1,5 @@
 import type { SkillActiveEntry, WorkflowHudChip } from "../../../skill-state/active-state";
+import { workflowReceiptStatus } from "../../../skill-state/workflow-state-contract";
 
 const ANSI_RESET_FG = "\x1b[39m";
 const ANSI_RESET_BOLD = "\x1b[22m";
@@ -60,6 +61,9 @@ function formatEntry(entry: SkillActiveEntry): string {
 		.map(formatChip)
 		.filter((chip): chip is string => Boolean(chip));
 	if (entry.stale === true) chips.unshift("warn:stale");
+	const receiptStatus = workflowReceiptStatus(entry.receipt);
+	if (receiptStatus === "stale") chips.unshift("warn:receipt=stale");
+	if (receiptStatus === "fresh") chips.push("receipt=fresh");
 	const summary = sanitizeHudPart(entry.hud?.summary);
 	return [base, summary, ...chips].filter(Boolean).join(" ");
 }

package/src/modes/components/status-line/segments.ts

@@ -110,10 +110,9 @@ const modelSegment: StatusLineSegment = {
 	},
 };
 
-function formatGoalBudget(current: number, budget?: number): string {
+function formatGoalUsage(current: number): string {
 	const used = formatNumber(current);
-	if (budget === undefined) return used;
-	return `${used}/${formatNumber(budget)}`;
+	return used;
 }
 
 function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: boolean }): RenderedSegment {
@@ -131,10 +130,6 @@ function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: b
 			icon = theme.symbol("status.success");
 			color = "success";
 			break;
-		case "budget-limited":
-			icon = theme.symbol("status.warning");
-			color = "warning";
-			break;
 		case "dropped":
 			icon = theme.symbol("status.aborted");
 			color = "dim";
@@ -144,9 +139,9 @@ function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: b
 	}
 
 	const parts: string[] = [withIcon(icon, "Goal")];
-	const showBudget = ctx.session.settings.get("goal.statusInFooter") === true;
-	if (showBudget && goal) {
-		parts.push(formatGoalBudget(goal.tokensUsed, goal.tokenBudget));
+	const showUsage = ctx.session.settings.get("goal.statusInFooter") === true;
+	if (showUsage && goal) {
+		parts.push(formatGoalUsage(goal.tokensUsed));
 	}
 	return { content: theme.fg(color, parts.join(" ")), visible: true };
 }
@@ -169,12 +164,6 @@ const modeSegment: StatusLineSegment = {
 			return renderGoalMode(ctx, goal);
 		}
 
-		const loop = ctx.loopMode;
-		if (loop?.enabled) {
-			const content = withIcon(theme.icon.loop, "Loop");
-			return { content: theme.fg("customMessageLabel", content), visible: true };
-		}
-
 		return { content: "", visible: false };
 	},
 };

package/src/modes/components/status-line/types.ts

@@ -24,9 +24,6 @@ export interface SegmentContext {
 		enabled: boolean;
 		paused: boolean;
 	} | null;
-	loopMode: {
-		enabled: boolean;
-	} | null;
 	goalMode: {
 		enabled: boolean;
 		paused: boolean;

package/src/modes/components/status-line.ts

@@ -155,7 +155,6 @@ export class StatusLineComponent implements Component {
 	#subagentCount: number = 0;
 	#sessionStartTime: number = Date.now();
 	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
-	#loopModeStatus: { enabled: boolean } | null = null;
 	#goalModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#skillHudEntries: SkillActiveEntry[] = [];
 	#skillHudLastFetch = 0;
@@ -229,10 +228,6 @@ export class StatusLineComponent implements Component {
 		this.#planModeStatus = status ?? null;
 	}
 
-	setLoopModeStatus(status: { enabled: boolean } | undefined): void {
-		this.#loopModeStatus = status ?? null;
-	}
-
 	setGoalModeStatus(status: { enabled: boolean; paused: boolean } | undefined): void {
 		this.#goalModeStatus = status ?? null;
 	}
@@ -611,7 +606,6 @@ export class StatusLineComponent implements Component {
 			width,
 			options: this.#resolveSettings().segmentOptions ?? {},
 			planMode: this.#planModeStatus,
-			loopMode: this.#loopModeStatus,
 			goalMode: this.#goalModeStatus,
 			usageStats,
 			contextPercent,

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);
@@ -1248,7 +1247,31 @@ export class CommandController {
 			this.ctx.statusContainer.clear();
 			this.ctx.editor.onEscape = originalOnEscape;
 		}
-		this.ctx.ui.requestRender();
+	}
+
+	async handleContributionPrepCommand(customInstructions?: string): Promise<void> {
+		this.ctx.editor.setText("");
+		try {
+			const result = await this.ctx.session.prepareContributionPrep({ customInstructions, spawnWorker: true });
+			this.ctx.showStatus(
+				[
+					"Contribution prep artifacts written.",
+					`Manifest: ${result.manifestPath}`,
+					`Worker prompt: ${result.workerPromptPath}`,
+				].join("\n"),
+			);
+			this.ctx.chatContainer.addChild(
+				new Text(
+					`${theme.fg("accent", `${theme.status.success} Contribution prep ready`)}\nManifest: ${result.manifestPath}`,
+					1,
+					1,
+				),
+			);
+			this.ctx.ui.requestRender();
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.ctx.showError(`Contribution prep failed: ${message}`);
+		}
 	}
 }
 

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/input-controller.ts

@@ -51,15 +51,6 @@ export class InputController {
 					this.ctx.retryEscapeHandler,
 			);
 		this.ctx.editor.onEscape = () => {
-			if (this.ctx.loopModeEnabled) {
-				this.ctx.pauseLoop();
-				if (this.ctx.session.isStreaming) {
-					void this.#abortInteractive();
-				} else {
-					this.ctx.cancelPendingSubmission();
-				}
-				return;
-			}
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				return;
 			}
@@ -292,12 +283,6 @@ export class InputController {
 				}
 			}
 
-			// While loop mode is on, every user-typed prompt becomes the new loop
-			// prompt that auto-resubmits after each yield.
-			if (this.ctx.loopModeEnabled) {
-				this.ctx.loopPrompt = text;
-			}
-
 			// Queue input during compaction
 			if (this.ctx.session.isCompacting) {
 				if (this.ctx.pendingImages.length > 0) {

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

@@ -18,7 +18,6 @@ import {
 import {
 	getAvailableThemes,
 	getSymbolTheme,
-	previewTheme,
 	setColorBlindMode,
 	setSymbolPreset,
 	setTheme,
@@ -29,6 +28,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";
@@ -64,7 +64,9 @@ const MANUAL_LOGIN_TIP = "Tip: You can complete pairing with /login <redirect UR
 
 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,15 +134,6 @@ 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();
-							}
-						},
 						onStatusLinePreview: previewSettings => {
 							// Update status line with preview settings
 							this.ctx.statusLine.updateSettings({