@sayknow-cli/coding-agent 0.4.7 → 0.5.1

package/src/modes/irc-observation-ledger.ts

@@ -4,9 +4,26 @@ import type { ParsedIrcMessage } from "./utils/irc-message";
 
 type InlineMode = "persistent" | "ephemeral";
 
-const MAX_RECORDS = 10_000;
-const MAX_RETAINED_UTF8_BYTES = 16 * 1024 * 1024;
-const MAX_SEEN_IDENTITIES = 100_000;
+export const IRC_OBSERVATION_LEDGER_MAX_RECORDS = 10_000;
+export const IRC_OBSERVATION_LEDGER_MAX_RETAINED_UTF8_BYTES = 16 * 1024 * 1024;
+export const IRC_OBSERVATION_LEDGER_MAX_SEEN_IDENTITIES = 100_000;
+
+export const __ircLedgerPerfCounters = {
+	enabled: false,
+	epochAdvances: 0,
+	snapshot() {
+		return { epochAdvances: this.epochAdvances };
+	},
+	enable(): void {
+		this.enabled = true;
+	},
+	disable(): void {
+		this.enabled = false;
+	},
+	reset(): void {
+		this.epochAdvances = 0;
+	},
+};
 
 export type IrcObservationRecord = Readonly<
 	ParsedIrcMessage & {
@@ -22,7 +39,7 @@ function measureRetainedUtf8Bytes(message: ParsedIrcMessage): number {
 	let bytes = 4;
 	for (const value of [message.observationId, message.from, message.to, message.text, message.kind]) {
 		bytes += Buffer.byteLength(value, "utf8");
-		if (bytes > MAX_RETAINED_UTF8_BYTES) return bytes;
+		if (bytes > IRC_OBSERVATION_LEDGER_MAX_RETAINED_UTF8_BYTES) return bytes;
 	}
 	return bytes;
 }
@@ -43,12 +60,28 @@ export class IrcObservationLedger {
 	#nextSequence = 0;
 	#seenObservationIdentities = new Set<string>();
 	#identityCapacityExhausted = false;
+	#retiredSessionIdentities = new Set<string>();
 	#evictedObservationIds = new Set<string>();
+	#mutationEpoch = 0;
+
+	get mutationEpoch(): number {
+		return this.#mutationEpoch;
+	}
+
+	#advanceMutationEpoch(): void {
+		this.#mutationEpoch++;
+		if (__ircLedgerPerfCounters.enabled) __ircLedgerPerfCounters.epochAdvances++;
+	}
 
 	#rememberObservationIdentity(observationId: string): boolean {
 		const identity = tombstoneIdentity(observationId);
-		if (this.#seenObservationIdentities.has(identity) || this.#identityCapacityExhausted) return false;
-		if (this.#seenObservationIdentities.size >= MAX_SEEN_IDENTITIES) {
+		if (
+			this.#seenObservationIdentities.has(identity) ||
+			this.#retiredSessionIdentities.has(identity) ||
+			this.#identityCapacityExhausted
+		)
+			return false;
+		if (this.#seenObservationIdentities.size >= IRC_OBSERVATION_LEDGER_MAX_SEEN_IDENTITIES) {
 			this.#identityCapacityExhausted = true;
 			return false;
 		}
@@ -56,6 +89,18 @@ export class IrcObservationLedger {
 		return true;
 	}
 
+	#retireCurrentSessionIdentities(): void {
+		for (const identity of this.#seenObservationIdentities) {
+			this.#retiredSessionIdentities.delete(identity);
+			this.#retiredSessionIdentities.add(identity);
+			while (this.#retiredSessionIdentities.size > IRC_OBSERVATION_LEDGER_MAX_SEEN_IDENTITIES) {
+				const oldest = this.#retiredSessionIdentities.values().next().value;
+				if (oldest === undefined) break;
+				this.#retiredSessionIdentities.delete(oldest);
+			}
+		}
+	}
+
 	#evict(observationId: string): void {
 		const record = this.#records.get(observationId);
 		if (!record) return;
@@ -65,7 +110,10 @@ export class IrcObservationLedger {
 	}
 
 	#enforceBounds(): void {
-		while (this.#records.size > MAX_RECORDS || this.#retainedUtf8Bytes > MAX_RETAINED_UTF8_BYTES) {
+		while (
+			this.#records.size > IRC_OBSERVATION_LEDGER_MAX_RECORDS ||
+			this.#retainedUtf8Bytes > IRC_OBSERVATION_LEDGER_MAX_RETAINED_UTF8_BYTES
+		) {
 			const oldestObservationId = this.#records.keys().next().value;
 			if (oldestObservationId === undefined) return;
 			this.#evict(oldestObservationId);
@@ -76,10 +124,9 @@ export class IrcObservationLedger {
 	observe(message: ParsedIrcMessage, panelVisibleAtObservation: boolean): IrcObservationRecord | undefined {
 		const existing = this.#records.get(message.observationId);
 		if (existing) return existing;
-		if (!this.#rememberObservationIdentity(message.observationId)) return undefined;
-
 		const estimatedBytes = measureRetainedUtf8Bytes(message);
-		if (estimatedBytes > MAX_RETAINED_UTF8_BYTES) return undefined;
+		if (estimatedBytes > IRC_OBSERVATION_LEDGER_MAX_RETAINED_UTF8_BYTES) return undefined;
+		if (!this.#rememberObservationIdentity(message.observationId)) return undefined;
 
 		const observedAt = Date.now();
 		const mode: InlineMode = panelVisibleAtObservation ? "ephemeral" : "persistent";
@@ -94,6 +141,7 @@ export class IrcObservationLedger {
 		this.#records.set(record.observationId, record);
 		this.#retainedUtf8Bytes += estimatedBytes;
 		this.#enforceBounds();
+		this.#advanceMutationEpoch();
 		return this.#records.get(record.observationId);
 	}
 
@@ -116,12 +164,20 @@ export class IrcObservationLedger {
 		return observationIds;
 	}
 
-	reset(): void {
-		for (const observationId of this.#records.keys()) {
-			this.#evictedObservationIds.add(observationId);
+	reset(options?: { retireCurrentSessionIdentities?: boolean }): void {
+		const retainedRecordsChanged = this.#records.size > 0;
+		if (options?.retireCurrentSessionIdentities) this.#retireCurrentSessionIdentities();
+		else this.#retiredSessionIdentities.clear();
+		if (retainedRecordsChanged) {
+			for (const observationId of this.#records.keys()) {
+				this.#evictedObservationIds.add(observationId);
+			}
+			this.#records.clear();
+			this.#retainedUtf8Bytes = 0;
 		}
-		this.#records.clear();
-		this.#retainedUtf8Bytes = 0;
 		this.#nextSequence = 0;
+		this.#seenObservationIdentities.clear();
+		this.#identityCapacityExhausted = false;
+		if (retainedRecordsChanged) this.#advanceMutationEpoch();
 	}
 }

package/src/modes/prompt-action-autocomplete.ts

@@ -3,12 +3,10 @@ import {
 	type AutocompleteProvider,
 	CombinedAutocompleteProvider,
 	extractSlashCommandTokenPrefix,
-	getKeybindings,
 	getSlashCommandMatchRank,
 	type SlashCommand,
 } from "@sayknow-cli/tui";
 import type { KeybindingsManager } from "../config/keybindings";
-import { formatKeyHints } from "../config/keybindings";
 import { isSettingsInitialized, settings } from "../config/settings";
 import { applyEmojiCompletion, getEmojiSuggestions, isEmojiPrefix, tryEmojiInlineReplace } from "./emoji-autocomplete";
 
@@ -44,6 +42,11 @@ interface PromptActionAutocompleteOptions {
 	moveCursorToMessageStart: () => void;
 	moveCursorToLineStart: () => void;
 	moveCursorToLineEnd: () => void;
+	/**
+	 * Ghost-text next-prompt prediction shown in the empty composer as a dim
+	 * inline hint (Tab accepts it via the editor's onTab handler).
+	 */
+	getPromptSuggestion?: () => string | null;
 }
 
 function fuzzyMatch(query: string, target: string): boolean {
@@ -186,11 +189,18 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	#baseProvider: CombinedAutocompleteProvider;
 	#actions: PromptActionDefinition[];
 	#commands: SlashCommand[];
-
-	constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[]) {
+	#getPromptSuggestion: (() => string | null) | undefined;
+
+	constructor(
+		commands: SlashCommand[],
+		basePath: string,
+		actions: PromptActionDefinition[],
+		getPromptSuggestion?: () => string | null,
+	) {
 		this.#baseProvider = new CombinedAutocompleteProvider(commands, basePath);
 		this.#actions = actions;
 		this.#commands = commands;
+		this.#getPromptSuggestion = getPromptSuggestion;
 	}
 
 	async getSuggestions(
@@ -309,6 +319,11 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	}
 
 	getInlineHint(lines: string[], cursorLine: number, cursorCol: number): string | null {
+		// An empty composer renders the pending prompt suggestion as ghost text.
+		if (lines.every(line => line === "")) {
+			const suggestion = this.#getPromptSuggestion?.();
+			if (suggestion) return suggestion;
+		}
 		return this.#baseProvider.getInlineHint?.(lines, cursorLine, cursorCol) ?? null;
 	}
 	trySyncSlashCompletion(textBeforeCursor: string): { items: AutocompleteItem[]; prefix: string } | null {
@@ -382,12 +397,11 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 export function createPromptActionAutocompleteProvider(
 	options: PromptActionAutocompleteOptions,
 ): PromptActionAutocompleteProvider {
-	const editorKeybindings = getKeybindings();
 	const actions: PromptActionDefinition[] = [
 		{
 			id: "new-session",
 			label: "Start new session",
-			description: formatKeyHints(options.keybindings.getKeys("app.session.new")) || "/new",
+			description: options.keybindings.getDisplayString("app.session.new"),
 			keywords: ["new", "session", "fresh", "clear", "start", "conversation"],
 			execute: options.newSession,
 		},
@@ -401,21 +415,21 @@ export function createPromptActionAutocompleteProvider(
 		{
 			id: "copy-line",
 			label: "Copy current line",
-			description: formatKeyHints(options.keybindings.getKeys("app.clipboard.copyLine")),
+			description: options.keybindings.getDisplayString("app.clipboard.copyLine"),
 			keywords: ["copy", "line", "clipboard", "current"],
 			execute: options.copyCurrentLine,
 		},
 		{
 			id: "copy-prompt",
 			label: "Copy whole prompt",
-			description: formatKeyHints(options.keybindings.getKeys("app.clipboard.copyPrompt")),
+			description: options.keybindings.getDisplayString("app.clipboard.copyPrompt"),
 			keywords: ["copy", "prompt", "clipboard", "message"],
 			execute: options.copyPrompt,
 		},
 		{
 			id: "paste-image",
 			label: "Paste image from clipboard",
-			description: formatKeyHints(options.keybindings.getKeys("app.clipboard.pasteImage")),
+			description: options.keybindings.getDisplayString("app.clipboard.pasteImage"),
 			keywords: ["paste", "image", "clipboard", "screenshot", "attach", "vision"],
 			execute: options.pasteImage,
 		},
@@ -429,7 +443,7 @@ export function createPromptActionAutocompleteProvider(
 		{
 			id: "undo",
 			label: "Undo",
-			description: formatKeyHints(editorKeybindings.getKeys("tui.editor.undo")),
+			description: options.keybindings.getDisplayString("tui.editor.undo"),
 			keywords: ["undo", "revert", "edit", "history"],
 			execute: options.undo,
 		},
@@ -450,18 +464,23 @@ export function createPromptActionAutocompleteProvider(
 		{
 			id: "cursor-line-start",
 			label: "Move cursor to beginning of line",
-			description: formatKeyHints(editorKeybindings.getKeys("tui.editor.cursorLineStart")),
+			description: options.keybindings.getDisplayString("tui.editor.cursorLineStart"),
 			keywords: ["move", "cursor", "line", "start", "beginning", "home"],
 			execute: options.moveCursorToLineStart,
 		},
 		{
 			id: "cursor-line-end",
 			label: "Move cursor to end of line",
-			description: formatKeyHints(editorKeybindings.getKeys("tui.editor.cursorLineEnd")),
+			description: options.keybindings.getDisplayString("tui.editor.cursorLineEnd"),
 			keywords: ["move", "cursor", "line", "end"],
 			execute: options.moveCursorToLineEnd,
 		},
 	];
 
-	return new PromptActionAutocompleteProvider(options.commands, options.basePath, actions);
+	return new PromptActionAutocompleteProvider(
+		options.commands,
+		options.basePath,
+		actions,
+		options.getPromptSuggestion,
+	);
 }

package/src/modes/prompt-suggestion-controller.ts

@@ -0,0 +1,96 @@
+import { logger } from "@sayknow-cli/utils";
+import { generatePromptSuggestion } from "../utils/prompt-suggestion";
+import type { InteractiveModeContext } from "./types";
+
+/**
+ * Owns the ghost-text next-prompt prediction lifecycle for interactive mode.
+ *
+ * After each agent turn ends (and only when `promptSuggestions` is enabled
+ * and the composer is empty), a smol-model prediction of the user's next
+ * prompt is generated in the background. The result renders as dim ghost
+ * text in the empty composer via the autocomplete provider's inline hint;
+ * Tab accepts it, typing dismisses it, and a new turn clears it.
+ */
+export class PromptSuggestionController {
+	#ctx: InteractiveModeContext;
+	#current: string | null = null;
+	/** Monotonic token; bumping it invalidates any in-flight generation. */
+	#generation = 0;
+
+	constructor(ctx: InteractiveModeContext) {
+		this.#ctx = ctx;
+	}
+
+	/** Current suggestion to render as ghost text, or null. */
+	get current(): string | null {
+		return this.#current;
+	}
+
+	/** Drop the current suggestion and invalidate any in-flight generation. */
+	clear(): void {
+		this.#generation++;
+		if (this.#current === null) return;
+		this.#current = null;
+		this.#ctx.ui.requestRender();
+	}
+
+	/** A new agent turn started; any pending suggestion is stale. */
+	onAgentStart(): void {
+		this.clear();
+	}
+
+	/**
+	 * Editor content changed. A non-empty composer means the user is writing
+	 * their own prompt: dismiss the suggestion and cancel pending generation.
+	 */
+	notifyEditorChanged(text: string): void {
+		if (text.length > 0) this.clear();
+	}
+
+	/**
+	 * Agent turn ended; kick off background generation when the feature is
+	 * enabled and the composer is idle and empty.
+	 */
+	onAgentEnd(): void {
+		if (!this.#ctx.settings.get("promptSuggestions")) return;
+		if (this.#ctx.shutdownRequested) return;
+		if (this.#ctx.session.isStreaming) return;
+		if (this.#ctx.editor.getText().trim() !== "") return;
+
+		const generation = ++this.#generation;
+		void generatePromptSuggestion(
+			this.#ctx.session.messages,
+			this.#ctx.session.modelRegistry,
+			this.#ctx.settings,
+			this.#ctx.session.sessionId,
+			this.#ctx.session.model,
+			provider => this.#ctx.session.agent.metadataForProvider(provider),
+		)
+			.then(suggestion => {
+				if (generation !== this.#generation) return;
+				if (!suggestion) return;
+				// The world may have moved on while the model was thinking.
+				if (this.#ctx.session.isStreaming) return;
+				if (this.#ctx.editor.getText().trim() !== "") return;
+				this.#current = suggestion;
+				this.#ctx.ui.requestRender();
+			})
+			.catch(error => {
+				logger.debug("prompt-suggestion: generation failed", { error: String(error) });
+			});
+	}
+
+	/**
+	 * Tab handler for the composer: accept the suggestion when the composer
+	 * is empty. Returns true when Tab was consumed.
+	 */
+	tryAcceptOnTab(text: string): boolean {
+		const suggestion = this.#current;
+		if (!suggestion || text.trim() !== "") return false;
+		// setText fires onChange with non-empty text, which clears #current.
+		this.#ctx.editor.setText(suggestion);
+		this.clear();
+		this.#ctx.ui.requestRender();
+		return true;
+	}
+}

package/src/modes/runtime-init.ts

@@ -115,6 +115,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
 			clearContext: () => session.clearContext(),
 			cycleModel: () => session.cycleModel(),
+			setModelProfile: name => session.activateModelProfileForControl(name),
 			cycleThinkingLevel: () => session.cycleThinkingLevel(),
 			setQueueMode: (kind, mode) => {
 				if (kind === "steering" && (mode === "all" || mode === "one-at-a-time")) {
@@ -131,7 +132,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 				}
 				return false;
 			},
-			invokeSkill: (name, args) => session.invokeSkill(name, args),
+			invokeSkill: (name, args, options) => session.invokeSkill(name, args, options),
 			setPlanMode: on => session.setSdkPlanMode(on),
 			operateGoal: (op, objective) => session.operateGoal(op, objective),
 			getSkillState: () => session.skills.map(skill => ({ name: skill.name, description: skill.description })),
@@ -379,7 +380,24 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 						const disabled = [...(session.settings.get("disabledExtensions") ?? [])];
 						const on = input.on === true;
 						const next = on ? disabled.filter(value => value !== id) : [...new Set([...disabled, id])];
-						session.settings.set("disabledExtensions", next);
+						if (!session.settings.canWriteDurableConfig()) {
+							throw Object.assign(
+								new Error(
+									"Cannot change settings while config.yml has invalid YAML syntax. Repair config.yml and reload settings.",
+								),
+								{ code: "invalid_request" },
+							);
+						}
+						try {
+							session.settings.set("disabledExtensions", next);
+						} catch (error) {
+							if (!session.settings.canWriteDurableConfig()) {
+								throw Object.assign(new Error(error instanceof Error ? error.message : String(error)), {
+									code: "invalid_request",
+								});
+							}
+							throw error;
+						}
 						return { changed: true, enabled: on };
 					}
 					case "session.delete":

package/src/modes/shared/agent-wire/command-dispatch.ts

@@ -219,9 +219,9 @@ export async function dispatchRpcCommand(
 			case "set_host_tools": {
 				const tools = normalizeHostToolDefinitions(command.tools);
 				const rpcTools = hostToolRegistry.setTools(tools);
-			// TODO(upstream-v0.11): AgentSession.refreshRpcHostTools was removed; the host-tool
-			// registry already holds the updated set via hostToolRegistry.setTools above.
-			void rpcTools;
+				// TODO(upstream-v0.11): AgentSession.refreshRpcHostTools was removed; the host-tool
+				// registry already holds the updated set via hostToolRegistry.setTools above.
+				void rpcTools;
 				return rpcSuccess(id, "set_host_tools", { toolNames: tools.map(tool => tool.name) });
 			}
 

package/src/modes/shared/agent-wire/workflow-gate-broker.ts

@@ -95,7 +95,7 @@ export interface AskSelectedAckRecoveryParticipant {
 
 /** SDK-native surface for emitting a workflow gate and awaiting its answer. */
 export interface WorkflowGateEmitter {
-	isUnattended(): boolean;
+	supportsRemoteGateAnswers(): boolean;
 	emitGate(input: OpenGateInput): Promise<unknown>;
 	onGateEmitted?(listener: (gate: WorkflowGate) => void): () => void;
 	resolveGate?(response: WorkflowGateResponse): Promise<WorkflowGateResolution>;
@@ -167,7 +167,7 @@ export class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
 		});
 	}
 
-	isUnattended(): boolean {
+	supportsRemoteGateAnswers(): boolean {
 		return true;
 	}
 	setRuntimeTurnProvider(provider: (() => string | undefined) | null): void {

package/src/modes/types.ts

@@ -32,6 +32,7 @@ import type { ToolExecutionHandle } from "./components/tool-execution";
 import type { StatusLineComponent } from "./components/tool-status-header";
 import type { IrcObservationLedger } from "./irc-observation-ledger";
 import type { OAuthManualInputManager } from "./oauth-manual-input";
+import type { PromptSuggestionController } from "./prompt-suggestion-controller";
 import type { Theme } from "./theme/theme";
 import type { ParsedIrcMessage } from "./utils/irc-message";
 
@@ -156,6 +157,8 @@ export interface InteractiveModeContext {
 	skillCommands: Map<string, Skill>;
 	oauthManualInput: OAuthManualInputManager;
 	todoPhases: TodoPhase[];
+	/** Ghost-text next-prompt prediction; absent in ACP/lightweight test contexts. */
+	promptSuggestion?: PromptSuggestionController;
 
 	// Lifecycle
 	init(): Promise<void>;
@@ -245,6 +248,8 @@ export interface InteractiveModeContext {
 	getAssistantViewportAnchorId?(message: AssistantMessage): string;
 	findLastAssistantMessage(): AssistantMessage | undefined;
 	extractAssistantText(message: AssistantMessage): string;
+	/** Records one semantic visible-transcript mutation for the sticky viewport. */
+	recordVisibleTranscriptMutation?(): void;
 	updateEditorTopBorder(): void;
 	updateEditorBorderColor(): void;
 	rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;
@@ -338,6 +343,7 @@ export interface InteractiveModeContext {
 	handleBackgroundCommand(): void;
 	handleImagePaste(): Promise<boolean>;
 	handleBtwCommand(question: string): Promise<void>;
+	handleBtwFollowUp(question: string): Promise<"accepted" | "busy" | "closed" | "rejected">;
 	hasActiveBtw(): boolean;
 	handleBtwEscape(): boolean;
 	cycleThinkingLevel(): void;

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

@@ -1,60 +1,88 @@
+import type { Keybinding } from "@sayknow-cli/tui";
 import type { AppKeybinding, KeybindingsManager } from "../../config/keybindings";
 
 export interface HotkeysMarkdownBindings {
-	keybindings: Pick<KeybindingsManager, "getDisplayString">;
+	keybindings: Pick<KeybindingsManager, "formatAccessibleKeyHint" | "getAccessibleDisplayString">;
+}
+
+function key(bindings: HotkeysMarkdownBindings, action: Keybinding): string {
+	return bindings.keybindings.getAccessibleDisplayString(action) || "Disabled";
 }
 
 function appKey(bindings: HotkeysMarkdownBindings, action: AppKeybinding): string {
-	return bindings.keybindings.getDisplayString(action) || "Disabled";
+	return key(bindings, action);
+}
+
+export function formatHotkeyMarkdownCode(label: string, escapeTablePipes = true): string {
+	const escaped = escapeTablePipes ? label.replace(/\|/g, "\\|") : label;
+	let longestBacktickRun = 0;
+	for (const match of escaped.matchAll(/`+/g)) {
+		longestBacktickRun = Math.max(longestBacktickRun, match[0].length);
+	}
+	const fence = "`".repeat(longestBacktickRun + 1);
+	const padding = escaped.startsWith("`") || escaped.endsWith("`") ? " " : "";
+	return `${fence}${padding}${escaped}${padding}${fence}`;
 }
 
 export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string {
+	const displayKey = (action: Keybinding): string => formatHotkeyMarkdownCode(key(bindings, action));
+	const displayAppKey = (action: AppKeybinding): string => formatHotkeyMarkdownCode(appKey(bindings, action));
+	const displayKeys = (...labels: string[]): string => formatHotkeyMarkdownCode(labels.join("/"));
+	const formatFixedKey = (key: string): string => bindings.keybindings.formatAccessibleKeyHint(key);
+	const displayKeyWithFixed = (action: Keybinding, fixedKey: string): string => {
+		const configured = key(bindings, action);
+		const fixed = formatFixedKey(fixedKey);
+		const labels = configured.split("/");
+		if (!labels.includes(fixed)) labels.push(fixed);
+		return displayKeys(...labels);
+	};
+
 	return [
 		"**Navigation**",
 		"| Key | Action |",
 		"|-----|--------|",
-		"| `Arrow keys` | Move cursor / browse history (Up when empty) |",
-		"| `Option+Left/Right` | Move by word |",
-		"| `Ctrl+A` / `Home` / `Cmd+Left` | Start of line |",
-		"| `Ctrl+E` / `End` / `Cmd+Right` | End of line |",
+		`| ${displayKeys(key(bindings, "tui.editor.cursorUp"), key(bindings, "tui.editor.cursorDown"))} | Move cursor / browse history (Up when empty) |`,
+		`| ${displayKeys(key(bindings, "tui.editor.cursorWordLeft"), key(bindings, "tui.editor.cursorWordRight"))} | Move by word |`,
+		`| ${displayKeyWithFixed("tui.editor.cursorLineStart", "ctrl+a")} | Start of line |`,
+		`| ${displayKeyWithFixed("tui.editor.cursorLineEnd", "ctrl+e")} | End of line |`,
 		"",
 		"**Editing**",
 		"| Key | Action |",
 		"|-----|--------|",
-		"| `Enter` | Send / queue while busy |",
-		`| \`${appKey(bindings, "app.message.queue")}\` | Queue message for next turn |`,
-		`| \`${appKey(bindings, "app.message.dequeue")}\` | Select queued message to edit |`,
-		"| `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 |",
-		`| \`${appKey(bindings, "app.clipboard.copyLine")}\` | Copy current line |`,
-		`| \`${appKey(bindings, "app.clipboard.copyPrompt")}\` | Copy whole prompt |`,
+		`| ${displayKey("tui.input.submit")} | Send / queue while busy |`,
+		`| ${displayAppKey("app.message.queue")} | Queue message for next turn |`,
+		`| ${displayAppKey("app.message.dequeue")} | Select queued message to edit |`,
+		`| ${displayKeys(key(bindings, "tui.input.newLine"), formatFixedKey("ctrl+j"))} | New line |`,
+		`| ${displayKeys(formatFixedKey("ctrl+w"), formatFixedKey("alt+backspace"))} | Delete word backwards |`,
+		`| ${displayKeys(formatFixedKey("ctrl+u"))} | Delete to start of line |`,
+		`| ${displayKeys(formatFixedKey("ctrl+k"))} | Delete to end of line |`,
+		`| ${displayAppKey("app.clipboard.copyLine")} | Copy current line |`,
+		`| ${displayAppKey("app.clipboard.copyPrompt")} | Copy whole prompt |`,
 		"",
 		"**Other**",
 		"| Key | Action |",
 		"|-----|--------|",
-		"| `Tab` | Path completion / accept autocomplete |",
-		`| \`${appKey(bindings, "app.interrupt")}\` | Cancel autocomplete / interrupt active work |`,
-		`| \`${appKey(bindings, "app.clear")}\` | Clear editor (first) / exit (second) |`,
-		`| \`${appKey(bindings, "app.exit")}\` | Exit (when editor is empty) |`,
-		`| \`${appKey(bindings, "app.suspend")}\` | Suspend to background |`,
-		`| \`${appKey(bindings, "app.commandPalette.open")}\` | Open command palette |`,
-		`| \`${appKey(bindings, "app.session.new")}\` | Start a fresh session |`,
-		`| \`${appKey(bindings, "app.thinking.cycle")}\` | Cycle thinking level |`,
-		`| \`${appKey(bindings, "app.model.cycleForward")}\` | Cycle configured model roles |`,
-		`| \`${appKey(bindings, "app.model.cycleBackward")}\` | Cycle configured model roles temporarily |`,
-		`| \`${appKey(bindings, "app.model.selectTemporary")}\` | Select model (temporary) |`,
-		`| \`${appKey(bindings, "app.model.select")}\` | Select default model |`,
-		`| \`${appKey(bindings, "app.plan.toggle")}\` | Toggle plan mode |`,
-		`| \`${appKey(bindings, "app.history.search")}\` | Search prompt history |`,
-		`| \`${appKey(bindings, "app.tools.expand")}\` | Toggle tool output expansion |`,
-		`| \`${appKey(bindings, "app.tool.backgroundFold")}\` twice | Fold supported foreground bash into a background job |`,
-		`| \`${appKey(bindings, "app.thinking.toggle")}\` | Toggle thinking block visibility |`,
-		`| \`${appKey(bindings, "app.editor.external")}\` | Edit message in external editor |`,
-		`| \`${appKey(bindings, "app.clipboard.pasteImage")}\` | Paste image from clipboard |`,
-		`| \`${appKey(bindings, "app.stt.toggle")}\` | Toggle speech-to-text recording |`,
-		`| \`${appKey(bindings, "app.irc.sidebar.toggle")}\` | Toggle IRC sidebar |`,
+		`| ${displayKey("tui.input.tab")} | Path completion / accept autocomplete |`,
+		`| ${displayAppKey("app.interrupt")} | Cancel autocomplete / interrupt active work |`,
+		`| ${displayAppKey("app.clear")} | Clear editor (first) / exit (second) |`,
+		`| ${displayAppKey("app.exit")} | Exit (when editor is empty) |`,
+		`| ${displayAppKey("app.suspend")} | Suspend to background |`,
+		`| ${displayAppKey("app.commandPalette.open")} | Open command palette |`,
+		`| ${displayAppKey("app.session.new")} | Start a fresh session |`,
+		`| ${displayAppKey("app.thinking.cycle")} | Cycle thinking level |`,
+		`| ${displayAppKey("app.model.cycleForward")} | Cycle configured model roles |`,
+		`| ${displayAppKey("app.model.cycleBackward")} | Cycle configured model roles temporarily |`,
+		`| ${displayAppKey("app.model.selectTemporary")} | Select model (temporary) |`,
+		`| ${displayAppKey("app.model.select")} | Select default model |`,
+		`| ${displayAppKey("app.plan.toggle")} | Toggle plan mode |`,
+		`| ${displayAppKey("app.history.search")} | Search prompt history |`,
+		`| ${displayAppKey("app.tools.expand")} | Toggle tool output expansion |`,
+		`| ${displayAppKey("app.tool.backgroundFold")} twice | Fold supported foreground bash into a background job |`,
+		`| ${displayAppKey("app.thinking.toggle")} | Toggle thinking block visibility |`,
+		`| ${displayAppKey("app.editor.external")} | Edit message in external editor |`,
+		`| ${displayAppKey("app.clipboard.pasteImage")} | Paste image from clipboard |`,
+		`| ${displayAppKey("app.stt.toggle")} | Toggle speech-to-text recording |`,
+		`| ${displayAppKey("app.irc.sidebar.toggle")} | Toggle IRC sidebar |`,
 		"| `?` | Show help / shortcuts |",
 		"| `#` | Prompt actions (command-palette style actions) |",
 		"| `/` | Slash commands (try `/help` or `/new`) |",