@gajae-code/coding-agent 0.7.3 → 0.7.4

package/src/main.ts

@@ -52,7 +52,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 { getDisplayChangelogEntries, getNewEntries } from "./utils/changelog";
+import { getDisplayChangelogEntries, getInstalledVersionChangelogEntry, getNewEntries } from "./utils/changelog";
 import type { EventBus } from "./utils/event-bus";
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
@@ -407,7 +407,7 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 		if (entries.length > 0) {
 			settings.set("lastChangelogVersion", VERSION);
 			await flushChangelogVersion();
-			return entries.map(e => e.content).join("\n\n");
+			return getInstalledVersionChangelogEntry(entries, VERSION)?.content;
 		}
 	} else {
 		const newEntries = getNewEntries(entries, lastVersion);
@@ -429,7 +429,7 @@ async function flushChangelogVersion(): Promise<void> {
 	}
 }
 
-async function createSessionManager(
+export async function createSessionManager(
 	parsed: Args,
 	cwd: string,
 	activeSettings: Settings = settings,
@@ -482,6 +482,17 @@ async function createSessionManager(
 	if (parsed.sessionDir) {
 		return SessionManager.create(cwd, parsed.sessionDir);
 	}
+	// A lifecycle `/session_create` child must start a FRESH session that adopts
+	// the pre-allocated id (GJC_SESSION_ID), never auto-resume existing history in
+	// the target cwd — otherwise the daemon/tmux id and the session header id
+	// diverge and close/resume-by-create-id break. Resume children are launched
+	// with `--resume <id>` (handled above) and carry no GJC_LIFECYCLE_REQUEST_ID.
+	if (
+		process.env.GJC_LIFECYCLE_REQUEST_ID &&
+		/^[A-Za-z0-9._-]{1,128}$/.test(process.env.GJC_SESSION_ID?.trim() ?? "")
+	) {
+		return undefined;
+	}
 	// Auto-resume: behave like --continue if the setting is enabled and a prior
 	// session exists. When a prior session is resumed, mark parsed.continue so
 	// buildSessionOptions restores the session's model/thinking instead of

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

@@ -66,7 +66,7 @@ export class HookEditorComponent extends Container {
 
 		// Hint
 		const hint = this.#promptStyle
-			? "enter submit  esc cancel  ctrl+g external editor"
+			? "enter submit  shift+enter/ctrl+j newline  esc cancel  ctrl+g external editor"
 			: "ctrl+enter submit  esc cancel  ctrl+g external editor";
 		this.addChild(new Text(theme.fg("dim", hint), 1, 0));
 

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

@@ -28,22 +28,6 @@ import { getEditorCommand, openInEditor } from "../../utils/external-editor";
 import { CountdownTimer } from "./countdown-timer";
 import { DynamicBorder } from "./dynamic-border";
 
-const SGR_MOUSE_PRESS_PATTERN = /^\x1b\[<(\d+);\d+;\d+M$/;
-const MOUSE_WHEEL_TITLE_SCROLL_ROWS = 3;
-
-function getMouseWheelTitleScrollRows(keyData: string): number {
-	const match = SGR_MOUSE_PRESS_PATTERN.exec(keyData);
-	if (!match) return 0;
-
-	const button = Number.parseInt(match[1] ?? "", 10);
-	if (!Number.isFinite(button) || (button & 64) === 0) return 0;
-
-	const wheelDirection = button & 3;
-	if (wheelDirection === 0) return -MOUSE_WHEEL_TITLE_SCROLL_ROWS;
-	if (wheelDirection === 1) return MOUSE_WHEEL_TITLE_SCROLL_ROWS;
-	return 0;
-}
-
 export interface HookSelectorOptions {
 	tui?: TUI;
 	timeout?: number;
@@ -132,26 +116,58 @@ class ScrollableTitle extends Container {
 
 	render(width: number): string[] {
 		const lines = this.#markdown.render(width);
-		const maxScrollOffset = Math.max(0, lines.length - this.#maxRows);
-		this.#lastMaxScrollOffset = maxScrollOffset;
-		this.#scrollOffset = Math.max(0, Math.min(this.#scrollOffset, maxScrollOffset));
+		if (lines.length <= this.#maxRows) {
+			this.#lastMaxScrollOffset = 0;
+			this.#scrollOffset = 0;
+			return lines;
+		}
 
-		const visibleLines = lines.slice(this.#scrollOffset, this.#scrollOffset + this.#maxRows);
-		if (maxScrollOffset === 0 || visibleLines.length === 0) {
+		if (this.#maxRows < 3) {
+			const maxScrollOffset = Math.max(0, lines.length - this.#maxRows);
+			this.#lastMaxScrollOffset = maxScrollOffset;
+			this.#scrollOffset = Math.max(0, Math.min(this.#scrollOffset, maxScrollOffset));
+
+			const visibleLines = lines.slice(this.#scrollOffset, this.#scrollOffset + this.#maxRows);
+			const indicator =
+				this.#scrollOffset === 0
+					? theme.fg("dim", " PgDn↓")
+					: this.#scrollOffset >= maxScrollOffset
+						? theme.fg("dim", " PgUp↑")
+						: theme.fg("dim", " PgUp/PgDn↕");
+			const lastIndex = visibleLines.length - 1;
+			const availableWidth = Math.max(1, width - visibleWidth(indicator));
+			const fittedLine = truncateToWidth(visibleLines[lastIndex] ?? "", availableWidth);
+			visibleLines[lastIndex] = `${fittedLine}${indicator}`;
 			return visibleLines;
 		}
 
-		const indicator =
-			this.#scrollOffset === 0
-				? theme.fg("dim", " PgDn↓")
-				: this.#scrollOffset >= maxScrollOffset
-					? theme.fg("dim", " PgUp↑")
-					: theme.fg("dim", " PgUp/PgDn↕");
-		const lastIndex = visibleLines.length - 1;
-		const availableWidth = Math.max(1, width - visibleWidth(indicator));
-		const fittedLine = truncateToWidth(visibleLines[lastIndex] ?? "", availableWidth);
-		visibleLines[lastIndex] = `${fittedLine}${indicator}`;
-		return visibleLines;
+		let showTopIndicator = this.#scrollOffset > 0;
+		let showBottomIndicator = true;
+		let contentRows = 1;
+		let maxScrollOffset = 0;
+
+		for (let i = 0; i < 4; i++) {
+			contentRows = Math.max(1, this.#maxRows - (showTopIndicator ? 1 : 0) - (showBottomIndicator ? 1 : 0));
+			maxScrollOffset = Math.max(0, lines.length - contentRows);
+			this.#scrollOffset = Math.max(0, Math.min(this.#scrollOffset, maxScrollOffset));
+
+			const nextShowTopIndicator = this.#scrollOffset > 0;
+			const nextShowBottomIndicator = this.#scrollOffset + contentRows < lines.length;
+			if (nextShowTopIndicator === showTopIndicator && nextShowBottomIndicator === showBottomIndicator) {
+				break;
+			}
+			showTopIndicator = nextShowTopIndicator;
+			showBottomIndicator = nextShowBottomIndicator;
+		}
+
+		this.#lastMaxScrollOffset = maxScrollOffset;
+
+		const visibleLines = lines.slice(this.#scrollOffset, this.#scrollOffset + contentRows);
+		const result: string[] = [];
+		if (showTopIndicator) result.push(theme.fg("dim", truncateToWidth("▲ more", width)));
+		result.push(...visibleLines);
+		if (showBottomIndicator) result.push(theme.fg("dim", truncateToWidth("▼ more", width)));
+		return result.slice(0, this.#maxRows);
 	}
 }
 
@@ -454,13 +470,6 @@ export class HookSelectorComponent extends Container {
 		// Reset countdown on any interaction
 		this.#countdown?.reset();
 
-		if (this.#scrollTitleRows !== undefined) {
-			const wheelRows = getMouseWheelTitleScrollRows(keyData);
-			if (wheelRows !== 0) {
-				this.#scrollableTitle?.scrollBy(wheelRows);
-				return;
-			}
-		}
 		if (this.#scrollTitleRows !== undefined && matchesKey(keyData, "pageUp")) {
 			this.#scrollableTitle?.scrollBy(-this.#scrollTitleRows);
 			return;
@@ -469,6 +478,14 @@ export class HookSelectorComponent extends Container {
 			this.#scrollableTitle?.scrollBy(this.#scrollTitleRows);
 			return;
 		}
+		if (!this.#inlineEditor && this.#scrollTitleRows !== undefined && matchesKey(keyData, "ctrl+u")) {
+			this.#scrollableTitle?.scrollBy(-this.#scrollTitleRows);
+			return;
+		}
+		if (!this.#inlineEditor && this.#scrollTitleRows !== undefined && matchesKey(keyData, "ctrl+d")) {
+			this.#scrollableTitle?.scrollBy(this.#scrollTitleRows);
+			return;
+		}
 		if (this.#inlineEditor) {
 			this.#handleInputModeKey(keyData, this.#inlineEditor);
 			return;
@@ -537,16 +554,23 @@ export class HookSelectorComponent extends Container {
 		editor.setBorderVisible(false);
 		editor.setPromptGutter("> ");
 		editor.disableSubmit = true;
+		// Mark the inline editor focused only when mirroring the app's hardware-cursor
+		// mode, so it emits CURSOR_MARKER at the input caret for IME preedit anchoring
+		// without changing legacy non-hardware-cursor layout.
+		const useTerminalCursor = this.#tui?.getShowHardwareCursor() ?? false;
+		editor.focused = useTerminalCursor;
+		editor.setUseTerminalCursor(useTerminalCursor);
 		if (this.#autocompleteProvider) {
 			editor.setAutocompleteProvider(this.#autocompleteProvider);
 		}
 		this.#inlineEditor = editor;
 		this.#inputArea.addChild(new Spacer(1));
 		this.#inputArea.addChild(editor);
-		const scrollHint = this.#scrollTitleRows === undefined ? "" : "  wheel/PgUp/PgDn scroll question";
-		this.#helpTextComponent.setText(
-			theme.fg("dim", `enter submit  esc back to options  ctrl+g external editor${scrollHint}`),
-		);
+		const helpText =
+			this.#scrollTitleRows === undefined
+				? "enter submit  esc back to options  ctrl+g external editor"
+				: "enter submit  esc back to options  PgUp/PgDn: question · Wheel: transcript";
+		this.#helpTextComponent.setText(theme.fg("dim", helpText));
 		this.invalidate();
 	}
 

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

@@ -225,6 +225,7 @@ export class ModelSelectorComponent extends Container {
 	#activeModelProfile?: string;
 	#isFastForProvider: (provider?: string) => boolean = () => false;
 	#isFastForSubagentProvider: (provider?: string) => boolean = () => false;
+	#isCurrentModelFastModeActive: () => boolean = () => false;
 	#pendingActionItem?: ModelItem | CanonicalModelItem;
 	#selectedActionIndex: number = 0;
 	#pendingThinkingChoice?: PendingThinkingChoice;
@@ -260,6 +261,7 @@ export class ModelSelectorComponent extends Container {
 			sessionId?: string;
 			isFastForProvider?: (provider?: string) => boolean;
 			isFastForSubagentProvider?: (provider?: string) => boolean;
+			isCurrentModelFastModeActive?: () => boolean;
 			currentThinkingLevel?: ThinkingLevel;
 			activeModelProfile?: string;
 		},
@@ -279,6 +281,12 @@ export class ModelSelectorComponent extends Container {
 		this.#activeModelProfile = options?.activeModelProfile;
 		this.#isFastForProvider = options?.isFastForProvider ?? (() => false);
 		this.#isFastForSubagentProvider = options?.isFastForSubagentProvider ?? (() => false);
+		// Current-model EFFECTIVE fast state. Defaults to intent for the current
+		// model so existing callers/tests keep prior behavior; production wires the
+		// session's effective predicate so an auto-disabled provider shows no glyph.
+		this.#isCurrentModelFastModeActive =
+			options?.isCurrentModelFastModeActive ??
+			(() => (this.#currentModel ? this.#isFastForProvider(this.#currentModel.provider) : false));
 		const initialSearchInput = options?.initialSearchInput;
 		this.#viewMode = this.#temporaryOnly || initialSearchInput || scopedModels.length > 0 ? "models" : "presets";
 
@@ -381,6 +389,17 @@ export class ModelSelectorComponent extends Container {
 		}
 	}
 
+	refreshRoleAssignments(
+		options: { currentModel?: Model; currentThinkingLevel?: ThinkingLevel; activeModelProfile?: string } = {},
+	): void {
+		if ("currentModel" in options) this.#currentModel = options.currentModel;
+		if ("currentThinkingLevel" in options) this.#currentThinkingLevel = options.currentThinkingLevel;
+		if ("activeModelProfile" in options) this.#activeModelProfile = options.activeModelProfile;
+		this.#roles = {};
+		this.#loadRoleModels();
+		this.#applyTabFilter();
+	}
+
 	#sortModels(models: ModelItem[]): void {
 		// Sort: default-tagged model first, then MRU, then alphabetical
 		const mruOrder = this.#settings.getStorage()?.getModelUsageOrder() ?? [];
@@ -973,32 +992,46 @@ export class ModelSelectorComponent extends Container {
 
 			// Build role badges (inverted: color as background, black text)
 			const roleBadgeTokens: string[] = [];
-			let roleMatched = false;
+			// Whether a non-subagent (modelRoles) badge on the CURRENT model row already
+			// rendered the current-model EFFECTIVE glyph. Only that case should suppress
+			// the standalone current glyph below — a subagent-only match must NOT, since
+			// subagent badges reflect the subagent tier, not the current model.
+			let currentModelEffectiveGlyphRendered = false;
 			for (const role of GJC_MODEL_ASSIGNMENT_TARGET_IDS) {
 				const roleInfo = GJC_MODEL_ASSIGNMENT_TARGETS[role];
 				const assigned = this.#roles[role];
 				if (roleInfo.tag && assigned && modelsAreEqual(assigned.model, item.model)) {
-					roleMatched = true;
 					const badge = makeInvertedBadge(roleInfo.tag, roleInfo.color ?? "muted");
 					const thinkingLabel = getThinkingLevelMetadata(assigned.thinkingLevel).label;
-					// Subagent roles (task.agentModelOverrides) run under task.serviceTier, so
-					// their ⚡ must reflect the effective subagent tier, not the main session tier.
-					const roleFast =
-						roleInfo.settingsPath === "task.agentModelOverrides"
-							? this.#isFastForSubagentProvider(assigned.model.provider)
+
+					// Subagent roles (task.agentModelOverrides) run under task.serviceTier,
+					// so their ⚡ uses the effective subagent tier. A non-subagent
+					// (modelRoles) badge on the CURRENT model row uses the current-model
+					// effective predicate so a provider auto-disable hides the glyph;
+					// other modelRoles rows show pure intent.
+					const isSubagentRole = roleInfo.settingsPath === "task.agentModelOverrides";
+					const isCurrentRow = this.#currentModel !== undefined && modelsAreEqual(this.#currentModel, item.model);
+					const roleFast = isSubagentRole
+						? this.#isFastForSubagentProvider(assigned.model.provider)
+						: isCurrentRow
+							? this.#isCurrentModelFastModeActive()
 							: this.#isFastForProvider(assigned.model.provider);
+					if (roleFast && isCurrentRow && !isSubagentRole) {
+						currentModelEffectiveGlyphRendered = true;
+					}
 					const fastSuffix = roleFast ? ` ${theme.icon.fast}` : "";
 					roleBadgeTokens.push(`${badge} ${theme.fg("dim", `(${thinkingLabel})`)}${fastSuffix}`);
 				}
 			}
 			// Active/current non-role row: show the fast glyph on the session's current
-			// model row even when it carries no role badge. Skip when a role token for
-			// this row already rendered the glyph (duplicate-glyph guard).
+			// model row. Suppress only when a non-subagent current-row badge already
+			// rendered the current-model effective glyph (duplicate-glyph guard) — a
+			// subagent-only match must not hide the current model's own indicator.
 			if (
-				!roleMatched &&
+				!currentModelEffectiveGlyphRendered &&
 				this.#currentModel !== undefined &&
 				modelsAreEqual(this.#currentModel, item.model) &&
-				this.#isFastForProvider(item.model.provider)
+				this.#isCurrentModelFastModeActive()
 			) {
 				roleBadgeTokens.push(theme.icon.fast);
 			}

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

@@ -25,8 +25,6 @@ import type { InteractiveModeContext } from "../../modes/types";
 import { setSessionTerminalTitle, setTerminalTitle } from "../../utils/title-generator";
 
 const MAX_WIDGET_LINES = 10;
-const HOOK_SELECTOR_MOUSE_REPORTING_ENABLE = "\x1b[?1006h\x1b[?1000h";
-const HOOK_SELECTOR_MOUSE_REPORTING_DISABLE = "\x1b[?1000l\x1b[?1006l";
 const HOOK_SELECTOR_CHROME_ROWS = 7;
 const HOOK_SELECTOR_OUTLINE_ROWS = 2;
 const HOOK_SELECTOR_INLINE_INPUT_ROWS = 2;
@@ -35,7 +33,6 @@ export class ExtensionUiController {
 	#extensionTerminalInputUnsubscribers = new Set<() => void>();
 	#hookWidgetsAbove = new Map<string, ExtensionUiComponent>();
 	#hookWidgetsBelow = new Map<string, ExtensionUiComponent>();
-	#hookSelectorMouseReportingEnabled = false;
 	#activeHookCustomComponent?: Component & { dispose?(): void };
 	#activeHookCustomOverlay?: OverlayHandle;
 
@@ -624,9 +621,6 @@ export class ExtensionUiController {
 			this.ctx.ui.terminal.rows - scrollOptionRows - listChromeRows - inlineInputRows - HOOK_SELECTOR_CHROME_ROWS;
 		const scrollTitleRows =
 			requestedTitleRows === undefined ? undefined : Math.max(1, Math.min(requestedTitleRows, availableTitleRows));
-		if (scrollTitleRows !== undefined) {
-			this.#enableHookSelectorMouseReporting();
-		}
 
 		this.ctx.hookSelector = new HookSelectorComponent(
 			title,
@@ -691,31 +685,10 @@ export class ExtensionUiController {
 		return promise;
 	}
 
-	#enableHookSelectorMouseReporting(): void {
-		if (this.#hookSelectorMouseReportingEnabled) return;
-		this.#hookSelectorMouseReportingEnabled = true;
-		this.#writeTerminalControl(HOOK_SELECTOR_MOUSE_REPORTING_ENABLE);
-	}
-
-	#disableHookSelectorMouseReporting(): void {
-		if (!this.#hookSelectorMouseReportingEnabled) return;
-		this.#hookSelectorMouseReportingEnabled = false;
-		this.#writeTerminalControl(HOOK_SELECTOR_MOUSE_REPORTING_DISABLE);
-	}
-
-	#writeTerminalControl(sequence: string): void {
-		try {
-			this.ctx.ui.terminal.write(sequence);
-		} catch {
-			// Terminal teardown can race selector cleanup; normal shutdown restores modes.
-		}
-	}
-
 	/**
 	 * Hide the hook selector.
 	 */
 	hideHookSelector(): void {
-		this.#disableHookSelectorMouseReporting();
 		this.ctx.hookSelector?.dispose();
 		this.ctx.editorContainer.clear();
 		this.ctx.editorContainer.addChild(this.ctx.editor);

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

@@ -4,8 +4,10 @@ import type { OAuthProvider } from "@gajae-code/ai/utils/oauth/types";
 import type { Component, OverlayHandle } from "@gajae-code/tui";
 import { Input, Loader, Spacer, Text } from "@gajae-code/tui";
 import { getAgentDbPath, getProjectDir } from "@gajae-code/utils";
-import { activateModelProfile } from "../../config/model-profile-activation";
+import { activateModelProfile, materializeActiveModelProfileAssignment } from "../../config/model-profile-activation";
 import { recommendModelProfileForProvider } from "../../config/model-profiles";
+import { GJC_MODEL_ASSIGNMENT_TARGETS } from "../../config/model-registry";
+import { formatModelSelectorValue } from "../../config/model-resolver";
 import { settings } from "../../config/settings";
 import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
@@ -663,7 +665,8 @@ export class SelectorController {
 
 	showModelSelector(options?: { temporaryOnly?: boolean }): void {
 		this.showSelector(done => {
-			const selector = new ModelSelectorComponent(
+			let modelSelector: ModelSelectorComponent;
+			modelSelector = new ModelSelectorComponent(
 				this.ctx.ui,
 				this.ctx.session.model,
 				this.ctx.settings,
@@ -697,38 +700,73 @@ export class SelectorController {
 							this.ctx.ui.requestRender();
 							return;
 						}
-						const { model, role, thinkingLevel, selector } = selection;
+						const { model, role, thinkingLevel, selector: selectedSelector } = selection;
 						if (role === null) {
 							// Temporary: update agent state but don't persist to settings
 							await this.ctx.session.setModelTemporary(model, thinkingLevel);
 							this.ctx.statusLine.invalidate();
 							this.ctx.updateEditorBorderColor();
-							this.ctx.showStatus(`Temporary model: ${selector ?? model.id}`);
+							this.ctx.showStatus(`Temporary model: ${selectedSelector ?? model.id}`);
 							done();
 							this.ctx.ui.requestRender();
 						} else if (role === "default") {
 							// Default: update agent state and persist as the active default model.
 							await this.ctx.session.setModel(model, role, {
-								selector,
+								selector: selectedSelector,
 								thinkingLevel,
 							});
+							const value = formatModelSelectorValue(
+								selectedSelector ?? `${model.provider}/${model.id}`,
+								thinkingLevel,
+							);
+							materializeActiveModelProfileAssignment({
+								session: this.ctx.session,
+								settings: this.ctx.settings,
+								role,
+								selector: value,
+							});
 							if (thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit) {
 								this.ctx.session.setThinkingLevel(thinkingLevel);
 							}
+							modelSelector.refreshRoleAssignments({
+								currentModel: this.ctx.session.model,
+								currentThinkingLevel: this.ctx.session.thinkingLevel,
+								activeModelProfile:
+									this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
+							});
 							this.ctx.statusLine.invalidate();
 							this.ctx.updateEditorBorderColor();
-							this.ctx.showStatus(`Default model: ${selector ?? model.id}`);
+							this.ctx.showStatus(`Default model: ${selectedSelector ?? model.id}`);
 							done();
 							this.ctx.ui.requestRender();
 						} else {
-							// Role-agent assignments configure Task dispatch and must not switch the active chat model.
 							const apiKey = await this.ctx.session.modelRegistry.getApiKey(model, this.ctx.session.sessionId);
 							if (!apiKey) {
 								throw new Error(`No API key for ${model.provider}/${model.id}`);
 							}
-							const overrides = this.ctx.settings.get("task.agentModelOverrides");
-							const value = selector ?? `${model.provider}/${model.id}`;
-							this.ctx.settings.set("task.agentModelOverrides", { ...overrides, [role]: value });
+							const value =
+								selectedSelector ?? formatModelSelectorValue(`${model.provider}/${model.id}`, thinkingLevel);
+							const materializedProfile = materializeActiveModelProfileAssignment({
+								session: this.ctx.session,
+								settings: this.ctx.settings,
+								role,
+								selector: value,
+							});
+							if (!materializedProfile) {
+								const target = GJC_MODEL_ASSIGNMENT_TARGETS[role];
+								if (target.settingsPath === "modelRoles") {
+									this.ctx.settings.setModelRole(role, value);
+								} else {
+									const overrides = this.ctx.settings.get("task.agentModelOverrides");
+									this.ctx.settings.set("task.agentModelOverrides", { ...overrides, [role]: value });
+								}
+							}
+							modelSelector.refreshRoleAssignments({
+								currentModel: this.ctx.session.model,
+								currentThinkingLevel: this.ctx.session.thinkingLevel,
+								activeModelProfile:
+									this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
+							});
 							this.ctx.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
 							this.ctx.showStatus(`${role} agent model: ${value}`);
 							done();
@@ -750,9 +788,10 @@ export class SelectorController {
 						this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
 					isFastForProvider: provider => this.ctx.session.isFastForProvider(provider),
 					isFastForSubagentProvider: provider => this.ctx.session.isFastForSubagentProvider(provider),
+					isCurrentModelFastModeActive: () => this.ctx.session.isFastModeActive(),
 				},
 			);
-			return { component: selector, focus: selector };
+			return { component: modelSelector, focus: modelSelector };
 		});
 	}
 

package/src/modes/interactive-mode.ts

@@ -431,6 +431,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#resizeHandler = () => {
 			this.#syncEditorMaxHeight();
 			this.updateEditorChrome();
+			this.editor.invalidate();
+			this.ui.requestRender(true, "resize");
 		};
 		process.stdout.on("resize", this.#resizeHandler);
 		try {

package/src/modes/utils/hotkeys-markdown.ts

@@ -23,7 +23,7 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		"|-----|--------|",
 		"| `Enter` | Send / queue while busy |",
 		`| \`${appKey(bindings, "app.message.queue")}\` | Queue message for next turn |`,
-		"| `Shift+Enter` | New line |",
+		"| `Shift+Enter` / `Ctrl+J` | New line |",
 		"| `Ctrl+W` / `Option+Backspace` | Delete word backwards |",
 		"| `Ctrl+U` | Delete to start of line |",
 		"| `Ctrl+K` | Delete to end of line |",

package/src/notifications/html-format.ts

@@ -349,16 +349,54 @@ export function buttonLabel(label: string, index: number): string {
 	return `${index + 1}. ${stripped}`;
 }
 
+/** Numbered, escaped option list for the Telegram message body. */
+export function numberedOptionList(labels: string[]): string {
+	return labels.map((label, i) => `${i + 1}. ${escapeHtml(label.replace(/^\s*\d+[.)]\s+/, ""))}`).join("\n");
+}
+
+/** Compact numeric button label; full option text belongs in the message body. */
+export function choiceButtonLabel(index: number): string {
+	return String(index + 1);
+}
+
 export interface InlineButton {
 	text: string;
 	callback_data: string;
 }
 
+const COMPACT_BUTTONS_PER_ROW = 5;
+
 /** A prefixed button label is "long" when it is wide or contains a newline. */
 function isLongLabel(label: string): boolean {
 	return label.length > 18 || /[\r\n]/.test(label);
 }
 
+/**
+ * Lay out option callbacks as compact numeric buttons. Telegram mobile clients
+ * ellipsize long inline-keyboard labels and tall keyboards can be obscured by
+ * the composer, so the full choice text is rendered in the message body while
+ * the keyboard keeps only stable one-based tap targets.
+ */
+export function buildCompactChoiceGrid(
+	labels: string[],
+	callbackForIndex: (index: number) => string,
+): InlineButton[][] {
+	const rows: InlineButton[][] = [];
+	let run: InlineButton[] = [];
+	const flush = () => {
+		if (run.length) {
+			rows.push(run);
+			run = [];
+		}
+	};
+	labels.forEach((_label, i) => {
+		run.push({ text: choiceButtonLabel(i), callback_data: callbackForIndex(i) });
+		if (run.length === COMPACT_BUTTONS_PER_ROW) flush();
+	});
+	flush();
+	return rows;
+}
+
 /**
  * Lay out option labels as a numbered button grid. Long buttons take a
  * full-width row; runs of short buttons are packed into rows of up to 3. The