dsh-code 1.0.7 → 1.3.0

package/src/app.ts

@@ -26,18 +26,29 @@ import type { AskUserQuestionAnswerItem, AskUserQuestionItem } from '@deepseek-a
 import type { AuthorizationInteraction, AuthorizationStatus } from '@deepseek-ai/dsh-authorization'
 import {
   dim,
+  diffBackground,
+  promptRowTokens,
+  rowBackground,
+  FLOW_ANCHORS,
   getPalette,
   getTheme,
   inkColor,
+  isPrismatic,
+  isRainbow,
+  themeFlow,
   setTheme,
   type RgbTriple,
   type ThemeName,
 } from './theme.ts'
+import { panelAccent } from './panel-accent.ts'
+import { parseRainbowArgument, rainbowRoll, rainbowSeedLabel, rerollRainbow } from './rainbow.ts'
 import { ThemePanel } from './theme-panel.ts'
-import { UpdatePanel } from './update-panel.ts'
+import { LanguagePanel } from './language-panel.ts'
+import { getLanguage, parseLanguageName, t, type LanguageName, type MessageKey } from './i18n.ts'
+import { UpdatePanel, subscribeUpdateApplyRunning } from './update-panel.ts'
 import type { LauncherUpdateStatus } from './update.ts'
 import { WHALE_GLYPH, WHALE_GLYPH_COLUMNS } from './whale-glyph.ts'
-import { DSH_CODE_VERSION, dshKernelVersion } from './version.ts'
+import { dshKernelVersion, headerBrandTitle } from './version.ts'
 import type { TranscriptStore } from './store.ts'
 import { DEFAULT_TERMINAL_TITLE, sanitizeTerminalTitle, terminalTitleSequence, useTerminalTitle } from './terminal-title.ts'
 import { settledEntryCount, type TranscriptEntry } from './render/projection.ts'
@@ -59,9 +70,14 @@ import {
   deepseekWaveWordVisible,
   deepDivingGradientColor,
   deepDivingSparkColor,
+  flowColor,
   effortAboveHigh,
   isOfficialDeepSeekLabel,
   parseAnimationsArgument,
+  RAINBOW_BURST_DURATION_MS,
+  RAINBOW_BURST_TICK_MS,
+  rainbowBurstColumnBg,
+  rainbowSpectrumHue,
   type DeepseekWaveStyle,
   type DeepseekWaveTier,
 } from './render/animations.ts'
@@ -84,7 +100,8 @@ import type { QuestionSnapshot, QuestionStore } from './questions.ts'
 import type { SkillsView, SkillRow } from './skills.ts'
 import { isPathLikeMentionQuery, type MentionCandidate } from './mentions.ts'
 import type { SubagentFeedView, SubagentRow } from './subagents.ts'
-import { AgentsPanel, editQuery, EffortPanel, HistoryPanel, JobsPanel, ModePanel, PermissionPanel, PluginPanel, ResumePanel, SchedulePanel, StatuslinePanel, runClock, SubagentPanel, type JobRow } from './kernel-panels.ts'
+import type { UsageView } from './render/usage.ts'
+import { AgentsPanel, editQuery, EffortPanel, HistoryPanel, JobsPanel, ModePanel, PermissionPanel, PluginPanel, ResumePanel, ReviewPickerPanel, SchedulePanel, SearchPanel, StatuslinePanel, runClock, SubagentPanel, UsagePanel, type JobRow, type SearchRow } from './kernel-panels.ts'
 import type { PresetRow } from './presets.ts'
 import type { PermissionRow } from './permissions.ts'
 import type { PluginRow } from './plugin-inventory.ts'
@@ -95,9 +112,10 @@ import {
   recallOlder,
   recordLocalEntry,
   type RecallState,
+  appendRecall,
 } from './history.ts'
 import type { SessionDirectoryOptions, SessionRow } from './session-directory.ts'
-import type { GitDiffView } from './git-workflow.ts'
+import { parseReviewArgument, type GitDiffView, type ReviewBranch, type ReviewCommit, type ReviewSelection } from './git-workflow.ts'
 import {
   authorizationForProvider,
   providerAuthorizationStatus,
@@ -108,6 +126,7 @@ import { ProviderAuthorizationLogoutPanel, ProviderAuthorizationPanel } from './
 import {
   looksLikeImagePath,
   parsePastedAttachmentPaths,
+  looksLikePathDraft,
   type FilePathInspection,
   type ImagePathInspection,
 } from './attachments.ts'
@@ -141,6 +160,12 @@ function readSettledRowCap(): number {
 
 /** Reset region/style, clear the visible screen and scrollback, then home. */
 const RESIZE_REFLOW_CLEAR = '\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H'
+/**
+ * Same as {@link RESIZE_REFLOW_CLEAR} without wiping native scrollback.
+ * History-cap trims remount `<Static>` but must not `\x1b[3J` a user who is
+ * reading earlier messages above the fold.
+ */
+const TRIM_REFLOW_CLEAR = '\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[H'
 /** Ask terminals supporting DEC synchronized updates to hold the frame. */
 const SYNCHRONIZED_UPDATE_BEGIN = '\x1b[?2026h'
 /** Release the held frame after Ink has replayed the source-backed Static rows. */
@@ -148,7 +173,7 @@ const SYNCHRONIZED_UPDATE_END = '\x1b[?2026l'
 import {
   layoutStatusBar,
   parseStatuslineItems,
-  STATUS_CYCLE_HINT,
+  statusCycleHint,
   STATUS_GROUP_SEPARATOR,
   STATUS_ITEM_SEPARATOR,
   STATUS_ROW2_INDENT,
@@ -175,6 +200,7 @@ import {
   followInspectorCursor,
   inspectorViewport,
   layoutGutterRows,
+  liveRegionBudget,
   moveScroll,
   panelViewport,
   revealRow,
@@ -182,6 +208,8 @@ import {
 } from './render/inspector.ts'
 import {
   clampLiveAllocation,
+  diffLineStyle,
+  fillDiffLineBars,
   lineSegment,
   markdownLines,
   settledEntryLines,
@@ -224,39 +252,69 @@ import {
 export type NoticeTone = 'info' | 'warning' | 'error'
 
 /** One source of truth for TUI-owned slash commands in completion and `/help`. */
-const LOCAL_COMMANDS = [
-  { label: '/help', description: 'show this overlay' },
-  { label: '/model', description: 'switch the model and manage providers' },
-  { label: '/effort', description: 'adjust reasoning effort for the current model' },
-  { label: '/mode', description: 'inspect or select the agent preset (/mode [preset])' },
-  { label: '/permission', description: 'inspect or select the permission preset (/permission [preset])' },
-  { label: '/new', description: 'create and switch to a fresh session (/new [preset])' },
-  { label: '/fork', description: 'fork at the latest completed turn (/fork [event-seq])' },
-  { label: '/resume', description: 'browse or switch root sessions (/resume [id|prefix])' },
-  { label: '/plugin', description: 'inspect the live plugin composition' },
-  { label: '/update', description: 'update dsh-code, the harness host, and profile plugins in one aligned step' },
-  { label: '/jobs', description: 'inspect background jobs' },
-  { label: '/schedule', description: 'inspect active reminders (created through schedule tools)' },
-  { label: '/statusline', description: 'customize the status line items' },
-  { label: '/theme', description: 'switch the color theme' },
-  { label: '/animation', description: 'toggle timed animations (/animation [on|off])' },
-  { label: '/history', description: 'search and recall past prompts' },
-  { label: '/agents', description: 'inspect subagent sessions of this conversation' },
-  { label: '/todos', description: 'inspect the full todo list' },
-  { label: '/subagent', description: 'choose the model delegated subagents run on' },
-  { label: '/vscode-keys', description: 'pass ctrl+r through the vs code terminal' },
-  { label: '/delete', description: 'delete a session and its subagent threads' },
-  { label: '/clear', description: 'clear the screen' },
-  { label: '/export', description: 'export the transcript to markdown (/export [path])' },
-  { label: '/title', description: 'rename this session (/title <text>)' },
-  { label: '/copy', description: 'copy the latest assistant response' },
-  { label: '/diff', description: 'inspect Git changes (/diff [--staged|ref])' },
-  { label: '/review', description: 'review Git changes under read-only permissions' },
-  { label: '/quit', description: 'exit' },
+/** One TUI-owned slash command: label plus its i18n description key. */
+interface LocalCommand { readonly label: string; readonly descriptionKey: MessageKey }
+
+const LOCAL_COMMANDS: readonly LocalCommand[] = [
+  { label: '/help', descriptionKey: 'cmd.help' },
+  { label: '/model', descriptionKey: 'cmd.model' },
+  { label: '/effort', descriptionKey: 'cmd.effort' },
+  { label: '/mode', descriptionKey: 'cmd.mode' },
+  { label: '/permission', descriptionKey: 'cmd.permission' },
+  { label: '/new', descriptionKey: 'cmd.new' },
+  { label: '/fork', descriptionKey: 'cmd.fork' },
+  { label: '/resume', descriptionKey: 'cmd.resume' },
+  { label: '/search', descriptionKey: 'cmd.search' },
+  { label: '/plugin', descriptionKey: 'cmd.plugin' },
+  { label: '/update', descriptionKey: 'cmd.update' },
+  { label: '/jobs', descriptionKey: 'cmd.jobs' },
+  { label: '/schedule', descriptionKey: 'cmd.schedule' },
+  { label: '/statusline', descriptionKey: 'cmd.statusline' },
+  { label: '/theme', descriptionKey: 'cmd.theme' },
+  { label: '/language', descriptionKey: 'cmd.language' },
+  { label: '/rainbow', descriptionKey: 'cmd.rainbow' },
+  { label: '/animation', descriptionKey: 'cmd.animation' },
+  { label: '/history', descriptionKey: 'cmd.history' },
+  { label: '/queue', descriptionKey: 'cmd.queue' },
+  { label: '/usage', descriptionKey: 'cmd.usage' },
+  { label: '/agents', descriptionKey: 'cmd.agents' },
+  { label: '/todos', descriptionKey: 'cmd.todos' },
+  { label: '/subagent', descriptionKey: 'cmd.subagent' },
+  { label: '/vscode-keys', descriptionKey: 'cmd.vscode-keys' },
+  { label: '/delete', descriptionKey: 'cmd.delete' },
+  { label: '/clear', descriptionKey: 'cmd.clear' },
+  { label: '/export', descriptionKey: 'cmd.export' },
+  { label: '/title', descriptionKey: 'cmd.title' },
+  { label: '/copy', descriptionKey: 'cmd.copy' },
+  { label: '/diff', descriptionKey: 'cmd.diff' },
+  { label: '/review', descriptionKey: 'cmd.review' },
+  { label: '/quit', descriptionKey: 'cmd.quit' },
 ] as const
 
 const LOCAL_COMMAND_NAMES = new Set(LOCAL_COMMANDS.map(command => command.label.slice(1)))
 
+/**
+ * TUI-local commands that take no input. Extra tokens used to fall through
+ * as a prompt (`/queue clear` reached the model); they now surface usage.
+ */
+const BARE_LOCAL_COMMANDS = new Set([
+  'quit', 'help', 'clear', 'copy', 'update', 'schedule', 'statusline', 'theme',
+  'history', 'queue', 'usage', 'agents', 'todos', 'subagent',
+])
+
+/** Split a slash line into the command name and any trailing input. */
+function slashNameAndArgs(text: string): { readonly name: string; readonly args: string } | undefined {
+  const match = /^\/([a-z][a-z0-9_-]*)(?:$|[\t ](.*))$/u.exec(text)
+  if (match === null || match[1] === undefined) return undefined
+  return { name: match[1], args: (match[2] ?? '').trim() }
+}
+
+/** One mutation the terminal may request for a pending next-turn inbox item. */
+export type QueueMutation =
+  | { readonly kind: 'remove' }
+  | { readonly kind: 'edit'; readonly text: string }
+  | { readonly kind: 'steer' }
+
 /** Props the runner hands the app; callbacks stay owned by the runner. */
 export interface AppProps {
   /** Event-fed transcript store for the live session. */
@@ -295,133 +353,151 @@ export interface AppProps {
    * an attachment prepare resolves after the app remounted onto another
    * session, and the runner drops the stale delivery then.
    */
-  dispatch(text: string, attachments?: readonly ContentBlock[], origin?: string): void
-  /** Submit steering, with the same stale-delivery guard as {@link dispatch}. */
-  steer(text: string, attachments?: readonly ContentBlock[], origin?: string): void
+  dispatch: (text: string, attachments?: readonly ContentBlock[], origin?: string) => void
+  /**
+   * Submit one line as steering: it joins the turn already running at its next
+   * step boundary instead of waiting for the next turn. Same stale-delivery
+   * guard as {@link dispatch}.
+   */
+  steer: (text: string, attachments?: readonly ContentBlock[], origin?: string) => void
   /**
    * The FULL current session identity ('' while the first session is pending)
    * — the stale-delivery origin above. Distinct from the short display id.
    */
   sessionKey: string
   /** Interrupt the running turn (Esc); true when a turn was cancelled. */
-  interrupt(): boolean
+  interrupt: () => boolean
   /** Quit: unmount, flush, and request process exit. */
-  quit(): void
+  quit: () => void
   /** Load the selectable model directory (called when /model opens). */
-  loadModels(): Promise<ModelDirectory>
+  loadModels: () => Promise<ModelDirectory>
   /** Load @mention candidates for the typed query (files + sessions). */
-  loadMentions(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>
+  loadMentions: (query: string, signal?: AbortSignal) => Promise<readonly MentionCandidate[]>
   /** Validate draft image paths without committing attachment objects. */
-  inspectImages(paths: readonly string[]): Promise<readonly ImagePathInspection[]>
+  inspectImages: (paths: readonly string[]) => Promise<readonly ImagePathInspection[]>
   /** Validate, normalize and persist images immediately before submission. */
-  prepareImages(paths: readonly string[], signal?: AbortSignal): Promise<readonly ImageBlock[]>
+  prepareImages: (paths: readonly string[], signal?: AbortSignal) => Promise<readonly ImageBlock[]>
   /** Validate draft non-image file paths without committing attachment objects. */
-  inspectFiles(paths: readonly string[]): Promise<readonly FilePathInspection[]>
+  inspectFiles: (paths: readonly string[]) => Promise<readonly FilePathInspection[]>
   /** Persist non-image files immediately before submission as durable file blocks. */
-  prepareFiles(paths: readonly string[], signal?: AbortSignal): Promise<readonly FileBlock[]>
+  prepareFiles: (paths: readonly string[], signal?: AbortSignal) => Promise<readonly FileBlock[]>
   /** Apply one /model selection (with an advertised reasoning effort, when picked); returns the display label. */
-  selectModel(row: ModelRow, effortId?: string): string
+  selectModel: (row: ModelRow, effortId?: string) => string
   /** The /subagent override label, '' when delegated agents follow the current model. */
   subagentModel: string
   /** Apply one /subagent model pick; returns the override label. */
-  setSubagentModel(row: ModelRow, effortId?: string): string
+  setSubagentModel: (row: ModelRow, effortId?: string) => string
   /** Drop the /subagent override (delegated agents follow the current model). */
-  clearSubagentModel(): void
+  clearSubagentModel: () => void
   /** Delete one session subtree; resolves with the outcome line. */
-  deleteSession(id: string): Promise<string>
+  deleteSession: (id: string) => Promise<string>
   /** Load provider/settings/credential facts for the optional /model provider stage. */
-  loadModelProviders?(): Promise<ProviderSettingsDirectory>
+  loadModelProviders?: () => Promise<ProviderSettingsDirectory>
   /** Subscribe to Harness credential/settings/adapter invalidations while /model is open. */
-  subscribeModelProviders?(listener: () => void): () => void
+  subscribeModelProviders?: (listener: () => void) => () => void
   /** Store or rotate one provider credential through the Harness credential service. */
-  saveModelProviderCredential?(target: ProviderTargetView, key: string): Promise<void>
+  saveModelProviderCredential?: (target: ProviderTargetView, key: string) => Promise<void>
   /** Remove one writable provider credential without removing its settings profile. */
-  unsetModelProviderCredential?(target: ProviderTargetView): Promise<void>
+  unsetModelProviderCredential?: (target: ProviderTargetView) => Promise<void>
   /** Remove one user-owned provider profile and its page-managed credential. */
-  removeModelProvider?(target: ProviderTargetView): Promise<void>
+  removeModelProvider?: (target: ProviderTargetView) => Promise<void>
   /** Save endpoint and explicit model capacities through the provider profile. */
-  saveModelProviderConfiguration?(target: ProviderTargetView, configuration: ProviderConfiguration): Promise<void>
+  saveModelProviderConfiguration?: (target: ProviderTargetView, configuration: ProviderConfiguration) => Promise<void>
   /**
    * Interrogate the provider's real endpoint (typed key wins over the stored
    * credential) for the models it actually serves — the discovery stage of
    * the provider setup page.
    */
-  discoverModelProvider?(
+  discoverModelProvider?: (
     target: ProviderTargetView,
     request: { readonly apiKey?: string; readonly baseURL?: string },
     signal?: AbortSignal,
-  ): Promise<readonly DiscoveredModelView[]>
+  ) => Promise<readonly DiscoveredModelView[]>
   /** Provider authorization flows and value-free stored-record facts. */
-  loadProviderAuthorizations?(): Promise<ProviderAuthorizationDirectory>
-  subscribeProviderAuthorizations?(listener: () => void): () => void
-  beginProviderAuthorization?(
+  loadProviderAuthorizations?: () => Promise<ProviderAuthorizationDirectory>
+  subscribeProviderAuthorizations?: (listener: () => void) => () => void
+  beginProviderAuthorization?: (
     row: ProviderAuthorizationRow,
     method: string,
     interaction: AuthorizationInteraction,
     signal: AbortSignal,
-  ): Promise<AuthorizationStatus>
-  cancelProviderAuthorization?(row: ProviderAuthorizationRow): void
-  logoutProviderAuthorization?(row: ProviderAuthorizationRow): Promise<void>
-  openAuthorizationUrl?(url: string): boolean
-  copyTextValue?(text: string): Promise<void>
+  ) => Promise<AuthorizationStatus>
+  cancelProviderAuthorization?: (row: ProviderAuthorizationRow) => void
+  logoutProviderAuthorization?: (row: ProviderAuthorizationRow) => Promise<void>
+  openAuthorizationUrl?: (url: string) => boolean
+  copyTextValue?: (text: string) => Promise<void>
   /** Cycle to the next mode station (Shift+Tab): a permission preset or a plan switch; returns the notice label. */
-  cycleMode(): string
+  cycleMode: () => string
   /** Pre-session plan choice: shows the plan badge before the first session exists. */
   pendingPlan?: boolean
   /** Select or inspect a permission preset without requiring a pre-existing session. */
-  setPermission(id: string): string
+  setPermission: (id: string) => string
   /** Export the transcript to a markdown file (/export [path]); reports via notices. */
-  exportTranscript(argument: string): Promise<void>
+  exportTranscript: (argument: string) => Promise<void>
   /** Rename the session (/title <text>); returns the outcome line for the notice. */
-  renameTitle(argument: string): string
+  renameTitle: (argument: string) => string
   /** Copy the latest complete assistant response; resolves to notice text. */
-  copyLastResponse(): Promise<string>
+  copyLastResponse: () => Promise<string>
   /** Load a complete read-only Git diff for the file-oriented viewport. */
-  loadGitDiff(argument: string): Promise<GitDiffView>
+  loadGitDiff: (argument: string) => Promise<GitDiffView>
+  /** Local branches for the /review picker (absent: the picker hides the branch phase's list). */
+  listReviewBranches?: (signal?: AbortSignal) => Promise<readonly ReviewBranch[]>
+  /** Recent commits on the current branch for the /review picker. */
+  listReviewCommits?: (signal?: AbortSignal) => Promise<readonly ReviewCommit[]>
   /** Start a model review after applying the read-only permission preset. */
-  reviewChanges(argument: string): void
+  reviewChanges: (selection: ReviewSelection) => void
   /** Preset/session/plugin kernel operations. */
-  loadPresets(): Promise<readonly PresetRow[]>
-  switchMode(id: string): Promise<string>
+  loadPresets: () => Promise<readonly PresetRow[]>
+  switchMode: (id: string) => Promise<string>
   /** Load the switchable permission presets for the /permission panel. */
-  loadPermissions(): Promise<readonly PermissionRow[]>
-  createSession(mode?: string): void
+  loadPermissions: () => Promise<readonly PermissionRow[]>
+  createSession: (mode?: string) => void
   /** Fork the active session at a completed-turn boundary. */
-  forkSession(argument: string): void
-  loadSessions(options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]>
-  loadSessionTranscript(id: string, signal?: AbortSignal): Promise<string>
+  forkSession: (argument: string) => void
+  loadSessions: (options: SessionDirectoryOptions, signal?: AbortSignal) => Promise<readonly SessionRow[]>
+  loadSessionTranscript: (id: string, signal?: AbortSignal) => Promise<string>
+  /** Read the current session's usage blocks (projections plus per-turn fold). */
+  loadUsage: () => Promise<UsageView>
+  /**
+   * Full-text search over every persisted session (the in-process
+   * session-query engine). Absent when the deployment disabled the row;
+   * /search degrades to a notice instead of opening the panel.
+   */
+  searchSessions?: (query: string, signal?: AbortSignal) => Promise<readonly SearchRow[]>
   /** Load this session's subagent conversations (children by lineage). */
-  loadSubagents(): Promise<readonly SessionRow[]>
-  switchSession(row: SessionRow): void
-  cancelSessionSwitch(): boolean
-  loadPlugins(): readonly PluginRow[]
+  loadSubagents: () => Promise<readonly SessionRow[]>
+  switchSession: (row: SessionRow) => void
+  cancelSessionSwitch: () => boolean
+  loadPlugins: () => readonly PluginRow[]
   /** Caller-visible background jobs (the host jobs registry, read-only). */
-  loadJobs(): readonly JobRow[]
+  loadJobs: () => readonly JobRow[]
   /** Probe the launcher's aligned update plan (read-only; never installs). */
-  probeUpdate(): Promise<LauncherUpdateStatus>
+  probeUpdate: () => Promise<LauncherUpdateStatus>
   /** Run the launcher's aligned update; streams sanitized lines; resolves with the exit code. */
-  applyUpdate(onLine: (line: string) => void): Promise<number>
+  applyUpdate: (onLine: (line: string) => void, plan?: { readonly dshSpec: string; readonly codeSpec: string; readonly pluginSpecs: readonly string[] }) => Promise<number>
   /** Registers the app's notice channel with the runner (called once on mount). */
-  onBridgeReady(bridge: { notify(text: string, tone?: NoticeTone): void }): void
+  onBridgeReady: (bridge: { notify: (text: string, tone?: NoticeTone) => void }) => void
   /** Ordered enabled status items (/statusline config); the runner owns persistence. */
   statusline: readonly string[]
   /** Persist a new statusline item set; the runner surfaces IO failures as notices. */
-  saveStatusline(items: readonly string[]): void
+  saveStatusline: (items: readonly string[]) => void
+  /** Apply and persist one /language selection; the runner owns the language.json file. */
+  saveLanguage: (name: LanguageName) => void
   /** Apply and persist one /theme selection; the runner owns the theme.json file. */
-  saveTheme?(name: ThemeName): void
+  saveTheme?: (name: ThemeName) => void
   /** Whether timed animations run at startup (animations.json; on by default
    * — like parseAnimationsPref, only an explicit false disables them). */
   animations?: boolean
   /** Apply and persist one /animation toggle; the runner owns the file. */
-  saveAnimations?(enabled: boolean): void
+  saveAnimations?: (enabled: boolean) => void
   /** Persistent cross-session input history (oldest first); the runner owns the file. */
   history: readonly string[]
   /** Persist one submitted prompt to the global history file. */
-  recordHistory(text: string): void
-  /** Cancel one queued inbox message by identity (Delete on the empty composer). */
-  cancelQueued(messageId: string): void
+  recordHistory: (text: string) => void
+  /** Mutate one next-turn inbox message; durable inbox splices reconcile the result. */
+  updateQueued?: (messageId: string, action: QueueMutation) => void
   /** Apply the Ctrl+R terminal passthrough to the detected editor (/vscode-keys); resolves to a one-line summary. */
-  applyEditorKeys(): Promise<string>
+  applyEditorKeys: () => Promise<string>
 }
 
 /** Pad text with spaces to a visible-column target (menu name column). */
@@ -475,7 +551,13 @@ function useStableInput(handler: (input: string, key: Key) => void, active: bool
  */
 function BusyChase({ animated = true }: { animated?: boolean }): ReactElement {
   const tick = useFrames(BUSY_CHASE_TICK_MS, animated)
-  return createElement(Text, { color: inkColor(getPalette().brandBright) }, busyChaseFrame(tick) + ' ')
+  // Flowing themes (prismatic, rainbow) ride their anchor walk while busy;
+  // every other theme (and the frozen state) keeps the palette's live accent.
+  const flow = themeFlow()
+  const marker = flow !== undefined && animated
+    ? flowColor(tick * BUSY_CHASE_TICK_MS + flow.phaseMs, flow.anchors)
+    : getPalette().brandBright
+  return createElement(Text, { color: inkColor(marker) }, busyChaseFrame(tick) + ' ')
 }
 
 /** Blinking block caret appended to streaming text; solid when frozen. */
@@ -485,7 +567,7 @@ function Caret({ animated = true }: { animated?: boolean }): ReactElement {
 }
 
 /** One resettable input-caret phase shared by the entire composer. */
-function useCursorBlink(active: boolean): { visible: boolean; reset(): void } {
+function useCursorBlink(active: boolean): { visible: boolean; reset: () => void } {
   const [epoch, setEpoch] = useState(0)
   const [visible, setVisible] = useState(true)
   useEffect(() => {
@@ -514,6 +596,13 @@ function useCursorBlink(active: boolean): { visible: boolean; reset(): void } {
 function ShimmerLine({ text, animated = true }: { text: string; animated?: boolean }): ReactElement {
   const tick = useFrames(DEEP_DIVING_SHIMMER_TICK_MS, animated)
   const palette = getPalette()
+  // Flowing themes walk their anchors for the shimmer highlight so
+  // streaming text glows along the spectrum; other themes keep the bright
+  // accent.
+  const flow = themeFlow()
+  const highlight = flow !== undefined && animated
+    ? flowColor(tick * DEEP_DIVING_SHIMMER_TICK_MS + flow.phaseMs, flow.anchors)
+    : palette.brandBright
   const graphemes = splitGraphemes(text)
   return createElement(
     Text,
@@ -527,8 +616,8 @@ function ShimmerLine({ text, animated = true }: { text: string; animated?: boole
           color: inkColor(!animated
             ? (sparkle ? palette.brandBright : palette.brandDeep)
             : sparkle
-              ? deepDivingSparkColor(tick, palette.brandDeep, palette.brandBright)
-              : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, palette.brandBright)),
+              ? deepDivingSparkColor(tick, palette.brandDeep, highlight)
+              : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, highlight)),
           bold: sparkle || undefined,
         },
         grapheme.text,
@@ -556,27 +645,33 @@ function DeepDivingLine({ since, animated = true }: { since: number; animated?:
  * cap counts explicit newlines and terminal wrapping, slicing from the END so
  * the freshest tokens stay visible while a long reply streams; the complete
  * text lands in the flushed scrollback once the turn assembles it.
+ *
+ * Body wrap width for a streaming tail. `rowColumns` is the same width
+ * passed to `transcriptEntryLines` (terminal minus the last-column safety);
+ * the hanging prefix then shrinks the body so streamed text and settled
+ * markdown wrap on the same column.
  */
-function StreamTail({ text, dim, maxRows, prefix = '', continuationPrefix = prefix, children }: {
+export function streamTailBodyColumns(rowColumns: number, prefix: string, continuationPrefix = prefix): number {
+  const width = Math.max(1, Math.floor(rowColumns))
+  const prefixColumns = Math.max(visibleColumns(prefix), visibleColumns(continuationPrefix))
+  return Math.max(1, width - prefixColumns)
+}
+
+function StreamTail({ text, dim, maxRows, prefix = '', continuationPrefix = prefix, children, columns }: {
   text: string
   dim: boolean
   maxRows: number
   prefix?: string
   continuationPrefix?: string
   children?: ReactElement
+  /** Same physical row width `transcriptEntryLines` uses (terminal minus 2). */
+  columns: number
 }): ReactElement {
-  const columns = useStdout().stdout?.columns ?? 80
   const safeRows = Math.max(1, maxRows)
-  // The final extra column keeps a caret from wrapping onto an unbudgeted
-  // row. Both prefixes participate because every physical row repeats its
-  // hanging indent.
-  const prefixColumns = Math.max(visibleColumns(prefix), visibleColumns(continuationPrefix))
-  // Content takes the full physical row minus prefixes and the final wrap
-  // column — a forced 10-column FLOOR on a narrower terminal made every row
-  // autowrap onto a second, unbudgeted row (the live budget then
-  // under-counted and the tree overflowed), so the width now shrinks with
-  // the real terminal instead of flooring at 10.
-  const contentColumns = Math.max(1, columns - 1 - prefixColumns)
+  // Both prefixes participate because every physical row repeats its hanging
+  // indent. The wrap matches settled markdown (row width minus prefix), so
+  // the flush at turn end does not reflow the last paragraph.
+  const contentColumns = streamTailBodyColumns(columns, prefix, continuationPrefix)
   const initial = displayTail(text, contentColumns, safeRows)
   // Reserve one row for the omission marker only when a marker is needed.
   const tail = initial.truncated && safeRows > 1
@@ -625,6 +720,18 @@ function segmentProps(style: MdSegment['style']): {
       return { color: undefined, bold: true, italic: true, strikethrough: undefined }
     case 'strike':
       return { color: inkColor(getPalette().dim), bold: undefined, italic: undefined, strikethrough: true }
+    case 'diffAdd':
+    case 'diffDel':
+      // Inline-markdown twin of lineStyleProps' diff cases: tinted rows for
+      // ```diff fences rendered through the markdown span path. The diff
+      // foreground tokens stay AA-legible both on the row tints (when the
+      // background rides along) and on the plain terminal background.
+      return {
+        color: inkColor(style === 'diffAdd' ? getPalette().diffAddFg : getPalette().diffDelFg),
+        bold: undefined,
+        italic: undefined,
+        strikethrough: undefined,
+      }
     default:
       return { color: undefined, bold: undefined, italic: undefined, strikethrough: undefined }
   }
@@ -637,20 +744,46 @@ function lineStyleProps(style: LineStyle): {
   italic: boolean | undefined
   strikethrough: boolean | undefined
   dimColor: boolean | undefined
+  backgroundColor: string | undefined
 } {
   switch (style) {
     case 'brand':
-      return { color: inkColor(getPalette().brandBright), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined }
+      return { color: inkColor(getPalette().brandBright), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined, backgroundColor: undefined }
     case 'success':
-      return { color: inkColor(getPalette().success), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined }
+      return { color: inkColor(getPalette().success), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined, backgroundColor: undefined }
     case 'error':
-      return { color: inkColor(getPalette().error), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined }
+      return { color: inkColor(getPalette().error), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined, backgroundColor: undefined }
     case 'warn':
-      return { color: inkColor(getPalette().warn), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined }
+      return { color: inkColor(getPalette().warn), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined, backgroundColor: undefined }
     case 'dimItalic':
-      return { color: inkColor(getPalette().dim), bold: undefined, italic: true, strikethrough: undefined, dimColor: undefined }
+      return { color: inkColor(getPalette().dim), bold: undefined, italic: true, strikethrough: undefined, dimColor: undefined, backgroundColor: undefined }
+    // Codex diff rendering: added/removed lines carry a theme tint behind
+    // the sign and text, with the AA-tuned diff foreground tokens on top; the
+    // depth gate turns this into plain foreground styling on 16-color
+    // terminals.
+    case 'diffAdd':
+      return { color: inkColor(getPalette().diffAddFg), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined, backgroundColor: diffBackground('diffAdd') }
+    case 'diffDel':
+      return { color: inkColor(getPalette().diffDelFg), bold: undefined, italic: undefined, strikethrough: undefined, dimColor: undefined, backgroundColor: diffBackground('diffDel') }
+    // Prompt rows: one full-width bar per delivery kind. The tint comes from
+    // the row token and the foreground from its AA-tuned twin; the depth gate
+    // inside rowBackground degrades this to foreground-only on 16-color
+    // terminals, matching the diff rows.
+    case 'promptRow':
+    case 'promptQueuedRow':
+    case 'promptSteeredRow': {
+      const tokens = promptRowTokens(style === 'promptQueuedRow' ? 'queued' : style === 'promptSteeredRow' ? 'steered' : undefined)
+      return {
+        color: inkColor(getPalette()[tokens.fg]),
+        bold: undefined,
+        italic: undefined,
+        strikethrough: undefined,
+        dimColor: undefined,
+        backgroundColor: rowBackground(tokens.fg),
+      }
+    }
     default:
-      return { ...segmentProps(style), dimColor: undefined }
+      return { ...segmentProps(style), dimColor: undefined, backgroundColor: undefined }
   }
 }
 
@@ -674,7 +807,7 @@ function StyledRows({ lines }: { lines: readonly StyledLine[] }): ReactElement {
 }
 
 /** File-oriented, color-coded unified diff viewport. */
-function DiffPanel({ view, onClose }: { view: GitDiffView; onClose(): void }): ReactElement {
+function DiffPanel({ view, onClose }: { view: GitDiffView; onClose: () => void }): ReactElement {
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
   const [fileIndex, setFileIndex] = useState(0)
@@ -682,15 +815,7 @@ function DiffPanel({ view, onClose }: { view: GitDiffView; onClose(): void }): R
   const file = view.files[fileIndex]
   const lines = useMemo(() => {
     if (file === undefined) return textLines('  (no changes)', viewport.contentColumns, 'dim')
-    return file.lines.flatMap(line => styledLines([
-      lineSegment(line, line.startsWith('+') && !line.startsWith('+++')
-        ? 'success'
-        : line.startsWith('-') && !line.startsWith('---')
-          ? 'error'
-          : line.startsWith('@@') || line.startsWith('diff --git') || line.startsWith('index ')
-            ? 'brand'
-            : 'dim'),
-    ], viewport.contentColumns))
+    return fillDiffLineBars(file.lines.flatMap(line => styledLines([lineSegment(line, diffLineStyle(line))], viewport.contentColumns)), viewport.contentColumns)
   }, [file, viewport.contentColumns])
   const visibleScroll = clampScroll(scroll, lines.length, viewport.bodyRows)
   useInput((input, key) => {
@@ -709,15 +834,16 @@ function DiffPanel({ view, onClose }: { view: GitDiffView; onClose(): void }): R
     else if (key.pageUp) setScroll(current => moveScroll(current, -viewport.bodyRows, lines.length, viewport.bodyRows))
     else if (key.pageDown) setScroll(current => moveScroll(current, viewport.bodyRows, lines.length, viewport.bodyRows))
   })
-  if (viewport.compact) return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`${view.title} · ${view.files.length} files · esc/q close`, viewport.contentColumns))
+  if (viewport.compact) return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.diff.compact', { title: view.title, files: view.files.length }), viewport.contentColumns))
+  const accent = panelAccent('diff', getPalette().dim, getPalette().brand)
   return createElement(
     Box,
-    { flexDirection: 'column', borderStyle: 'round', borderColor: inkColor(getPalette().dim), paddingX: 1 },
-    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns(`${view.title} · ${view.files.length === 0 ? 'no files' : `${fileIndex + 1}/${view.files.length} ${file?.path ?? ''}`} · rows ${lines.length === 0 ? 0 : visibleScroll + 1}-${Math.min(lines.length, visibleScroll + viewport.bodyRows)}/${lines.length}`, viewport.contentColumns)),
+    { flexDirection: 'column', borderStyle: 'round', borderColor: inkColor(accent.border), paddingX: 1 },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(`${view.title} · ${view.files.length === 0 ? t('panel.diff.noFiles') : `${fileIndex + 1}/${view.files.length} ${file?.path ?? ''}`} · rows ${lines.length === 0 ? 0 : visibleScroll + 1}-${Math.min(lines.length, visibleScroll + viewport.bodyRows)}/${lines.length}`, viewport.contentColumns)),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     createElement(StyledRows, { lines: lines.slice(visibleScroll, visibleScroll + viewport.bodyRows) }),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('↑/↓ scroll · g/G ends · esc/q close', viewport.contentColumns)),
+    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(t('panel.diff.footer'), viewport.contentColumns)),
   )
 }
 
@@ -735,6 +861,32 @@ function PanelGap({ visible }: { visible: boolean }): ReactElement | undefined {
  * keeps its historical three lines. Short or narrow terminals keep a one-line
  * form without the kernel line.
  */
+/**
+ * One whale-glyph row painted as a frozen seven-color spectrum (column 0
+ * red, column 25 violet). Spaces stay uncolored so the silhouette punches
+ * through; adjacent same-hue blocks merge into one span.
+ */
+function rainbowGlyphRow(row: string, rowKey: number): ReactElement {
+  const span = Math.max(1, WHALE_GLYPH_COLUMNS - 1)
+  const children: ReactElement[] = []
+  let start = 0
+  while (start < row.length) {
+    if (row[start] === ' ') {
+      let end = start + 1
+      while (end < row.length && row[end] === ' ') end += 1
+      children.push(createElement(Text, { key: start }, row.slice(start, end)))
+      start = end
+      continue
+    }
+    const color = inkColor(rainbowSpectrumHue(start / span))
+    let end = start + 1
+    while (end < row.length && row[end] !== ' ' && inkColor(rainbowSpectrumHue(end / span)) === color) end += 1
+    children.push(createElement(Text, { key: start, color }, row.slice(start, end)))
+    start = end
+  }
+  return createElement(Text, { key: rowKey }, ...children)
+}
+
 function Header({ resumed }: { resumed: boolean }): ReactElement {
   const stdout = useStdout().stdout
   const rows = stdout?.rows ?? 40
@@ -743,13 +895,13 @@ function Header({ resumed }: { resumed: boolean }): ReactElement {
     const version = dshKernelVersion()
     return version === undefined ? undefined : `dsh-v${version}`
   })()
-  const title = `DeepSeek Harness · v${DSH_CODE_VERSION}`
+  const title = headerBrandTitle()
   const slogan = 'Into the Unknown  探索未至之境'
-  const hint = resumed ? 'resumed · /help · Esc interrupt' : '/help · Esc interrupt · Ctrl+C quit'
+  const hint = resumed ? t('header.hintResumed') : t('header.hint')
   const copyWidths = [visibleColumns(title), visibleColumns(slogan), visibleColumns(hint)]
   if (kernelLine !== undefined) copyWidths.push(visibleColumns(kernelLine))
   const copyColumns = Math.max(...copyWidths)
-  const compact = `${title} · ${hint}`
+  const compact = kernelLine === undefined ? `${title} · ${hint}` : `${title} · ${kernelLine} · ${hint}`
   if (rows < 20 || columns < WHALE_GLYPH_COLUMNS + copyColumns + 10) {
     return createElement(
       Box,
@@ -768,7 +920,10 @@ function Header({ resumed }: { resumed: boolean }): ReactElement {
     createElement(
       Box,
       { flexDirection: 'column', width: WHALE_GLYPH_COLUMNS, justifyContent: 'center' },
-      ...WHALE_GLYPH.map((row, index) => createElement(Text, { key: index, color: inkColor(getPalette().brand) }, row)),
+      ...WHALE_GLYPH.map((row, index) =>
+        isRainbow()
+          ? rainbowGlyphRow(row, index)
+          : createElement(Text, { key: index, color: inkColor(getPalette().brand) }, row)),
     ),
     createElement(
       Box,
@@ -803,7 +958,7 @@ function todoMark(status: TodoItem['status']): string {
 function AgentsLine({ rows, total }: { rows: readonly SubagentRow[]; total: number }): ReactElement | undefined {
   if (rows.length === 0) return undefined
   const running = rows.filter(row => row.state !== 'done').length
-  const newest = [...rows].sort((left, right) => right.updatedAt - left.updatedAt)[0]!
+  const newest = [...rows].sort((left, right) => right.updatedAt - left.updatedAt)[0]
   const mark = newest.state === 'done' ? '✓' : newest.state === 'idle' ? '⏸' : '●'
   return createElement(
     Box,
@@ -856,7 +1011,7 @@ function TodoListPanel({ todos, onClose }: { todos: readonly TodoItem[]; onClose
   const inProgress = todos.filter(todo => todo.status === 'in_progress').length
   const pending = todos.length - completed - inProgress
   const rows = todos.length === 0
-    ? [createElement(Text, { key: 'empty', dimColor: true, wrap: 'truncate-end' }, '  no todos yet')]
+    ? [createElement(Text, { key: 'empty', dimColor: true, wrap: 'truncate-end' }, `  ${t('panel.todos.empty')}`)]
     : todos.map(todo => createElement(
       Text,
       { key: todo.content, dimColor: true, wrap: 'truncate-end' },
@@ -885,40 +1040,202 @@ function TodoListPanel({ todos, onClose }: { todos: readonly TodoItem[]; onClose
   })
 
   if (viewport.maxHeight === 0 || viewport.compact) {
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('todos · esc/q close', viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.todos.compact'), viewport.contentColumns))
   }
 
+  const accent = panelAccent('todos', getPalette().brand)
   return createElement(
     Box,
-    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().brand) },
-    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns(`todos · ${completed}/${todos.length} done · ${inProgress} active · ${pending} pending · rows ${rows.length === 0 ? 0 : visibleScroll + 1}-${Math.min(rows.length, visibleScroll + viewport.bodyRows)}/${rows.length}`, viewport.contentColumns)),
+    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.todos.title', { done: completed, total: todos.length, active: inProgress, pending, from: rows.length === 0 ? 0 : visibleScroll + 1, to: Math.min(rows.length, visibleScroll + viewport.bodyRows), rows: rows.length }), viewport.contentColumns)),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     ...rows.slice(visibleScroll, visibleScroll + viewport.bodyRows),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, dim(truncateColumns('↑↓ scroll · pgup/pgdn page · g/G ends · esc/q close', viewport.contentColumns))),
+    createElement(Text, { wrap: 'truncate-end' }, dim(truncateColumns(t('panel.todos.footer'), viewport.contentColumns))),
   )
 }
 
 const MemoTodoListPanel = memo(TodoListPanel)
 
+/** Rows in the exact next-turn inbox order, never transcript append order. */
+export function queuedInboxRows(
+  entries: readonly TranscriptEntry[],
+  ids: readonly string[],
+): readonly Extract<TranscriptEntry, { kind: 'pending' }>[] {
+  const byId = new Map<string, Extract<TranscriptEntry, { kind: 'pending' }>>()
+  for (const entry of entries) {
+    if (entry.kind === 'pending' && entry.target === 'next-turn') byId.set(entry.messageId, entry)
+  }
+  return ids.flatMap(id => {
+    const row = byId.get(id)
+    return row === undefined ? [] : [row]
+  })
+}
+
+/** A bounded, keyboard-owned management surface for the durable next-turn inbox. */
+function QueuePanel({ rows, busy, update, onClose }: {
+  rows: readonly Extract<TranscriptEntry, { kind: 'pending' }>[]
+  busy: boolean
+  update?: (messageId: string, action: QueueMutation) => void
+  onClose: () => void
+}): ReactElement {
+  const stdout = useStdout().stdout
+  const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
+  const [selected, setSelected] = useState(0)
+  const [scroll, setScroll] = useState(0)
+  const [editing, setEditing] = useState<{ messageId: string; text: string; cursor: number } | undefined>(undefined)
+  // Ink can deliver a following key before its effect swaps the input
+  // listener after an edit-mode render; this ref keeps the editor's key
+  // stream coherent while the visible state catches up.
+  const editingRef = useRef(editing)
+  const current = rows[selected]
+  const visibleScroll = revealRow(clampScroll(scroll, rows.length, viewport.bodyRows), selected, rows.length, viewport.bodyRows)
+  const move = (delta: number): void => {
+    setSelected(current => Math.max(0, Math.min(rows.length - 1, current + delta)))
+  }
+
+  useEffect(() => {
+    setSelected(current => Math.max(0, Math.min(rows.length - 1, current)))
+    if (editing !== undefined && !rows.some(row => row.messageId === editing.messageId)) {
+      editingRef.current = undefined
+      setEditing(undefined)
+    }
+  }, [rows, editing])
+  useEffect(() => {
+    if (visibleScroll !== scroll) setScroll(visibleScroll)
+  }, [visibleScroll, scroll])
+
+  useStableInput((input, key) => {
+    const activeEdit = editingRef.current
+    if (activeEdit !== undefined) {
+      if (key.escape) {
+        editingRef.current = undefined
+        setEditing(undefined)
+        return
+      }
+      if (key.return) {
+        if (activeEdit.text.trim() !== '') update?.(activeEdit.messageId, { kind: 'edit', text: activeEdit.text })
+        editingRef.current = undefined
+        setEditing(undefined)
+        return
+      }
+      if (key.leftArrow) {
+        const next = { ...activeEdit, cursor: moveCursorBy(activeEdit.text, activeEdit.cursor, -1) }
+        editingRef.current = next
+        setEditing(next)
+        return
+      }
+      if (key.rightArrow) {
+        const next = { ...activeEdit, cursor: moveCursorBy(activeEdit.text, activeEdit.cursor, 1) }
+        editingRef.current = next
+        setEditing(next)
+        return
+      }
+      // Ink 5 reports 0x7F (backspace) and the forward-delete sequence as the
+      // same `key.delete`, so a bare Delete binding here would erase on a
+      // habitual Backspace. This management surface keeps `d` as its only
+      // removal key instead of guessing which byte arrived.
+      if (key.backspace || key.delete) {
+        const edit = deleteBackward(activeEdit.text, activeEdit.cursor)
+        const next = { ...activeEdit, text: edit.value, cursor: edit.cursor }
+        editingRef.current = next
+        setEditing(next)
+        return
+      }
+      if (input !== '' && !key.ctrl && !key.meta) {
+        const edit = insertText(activeEdit.text, activeEdit.cursor, input)
+        const next = { ...activeEdit, text: edit.value, cursor: edit.cursor }
+        editingRef.current = next
+        setEditing(next)
+      }
+      return
+    }
+    if (key.escape || input === 'q') {
+      onClose()
+      return
+    }
+    if (key.upArrow) move(-1)
+    else if (key.downArrow) move(1)
+    else if (key.pageUp) move(-Math.max(1, viewport.bodyRows - 1))
+    else if (key.pageDown) move(Math.max(1, viewport.bodyRows - 1))
+    else if (input === 'g') setSelected(0)
+    else if (input === 'G') setSelected(Math.max(0, rows.length - 1))
+    else if (input === 'e' && current !== undefined) {
+      // Text is editable on every row: an edit rewrites what the user typed
+      // and carries the row's attachments through untouched, which is exactly
+      // what the row's read-only attachment marker promises.
+      const next = { messageId: current.messageId, text: current.text, cursor: current.text.length }
+      editingRef.current = next
+      setEditing(next)
+    }
+    else if (input === 'd' && current !== undefined) update?.(current.messageId, { kind: 'remove' })
+    else if (key.return && current !== undefined && busy) update?.(current.messageId, { kind: 'steer' })
+  }, true)
+
+  if (viewport.maxHeight === 0 || viewport.compact) {
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.queue.compact'), viewport.contentColumns))
+  }
+  const body = rows.length === 0
+    ? [createElement(Text, { key: 'empty', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(t('panel.queue.empty'), viewport.contentColumns))]
+    : rows.map((row, index) => {
+      const selectedRow = index === selected
+      const suffix = (row.images?.length ?? 0) + (row.files?.length ?? 0) > 0 ? ` ${t('panel.queue.attachments')}` : ''
+      if (editing?.messageId === row.messageId) {
+        const before = editing.text.slice(0, editing.cursor)
+        const caret = editing.text.slice(editing.cursor, editing.cursor + 1) || ' '
+        const after = editing.text.slice(editing.cursor + caret.length)
+        return createElement(Text, { key: row.messageId, color: inkColor(getPalette().brandBright), wrap: 'truncate-end' }, truncateColumns(`✎ ${before}[${caret}]${after}`, viewport.contentColumns))
+      }
+      return createElement(Text, { key: row.messageId, color: inkColor(selectedRow ? getPalette().brandBright : getPalette().dim), bold: selectedRow || undefined, wrap: 'truncate-end' }, truncateColumns(`${selectedRow ? '›' : ' '} ${index + 1}. ${singleLineText(row.text)}${suffix}`, viewport.contentColumns))
+    })
+  const footer = editing !== undefined
+    ? t('panel.queue.editFooter')
+    : busy
+      ? t('panel.queue.footerBusy')
+      : t('panel.queue.footerIdle')
+  const accent = panelAccent('queue', getPalette().brand)
+  return createElement(
+    Box,
+    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.queue.title', { count: rows.length, from: rows.length === 0 ? 0 : visibleScroll + 1, to: Math.min(rows.length, visibleScroll + viewport.bodyRows) }), viewport.contentColumns)),
+    createElement(PanelGap, { visible: viewport.gapRows > 0 }),
+    ...body.slice(visibleScroll, visibleScroll + viewport.bodyRows),
+    createElement(PanelGap, { visible: viewport.gapRows > 0 }),
+    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(footer, viewport.contentColumns)),
+  )
+}
+
 /**
  * Ink props for one status tone: the Codex status-line accent mapping over
  * the DeepSeek palette, all blue by design — the status bar speaks only in
  * degrees of blue (deep accent, primary figures, model identity, sky
  * paths and done states), with amber/red reserved for warnings and errors.
  */
-function statusToneProps(tone: StatusTone): {
+function statusToneProps(tone: StatusTone, flowMs?: number): {
   color: string | undefined
   bold: boolean | undefined
   dimColor: boolean | undefined
 } {
+  if (isRainbow()) {
+    // Carnival roll: every tone carries its rolled color (adjacent tones in
+    // canonical on-screen order never match, the row boundary included);
+    // the live dot rides the flow walk while busy. Bold emphasis carries
+    // the semantic hierarchy so randomness never hides importance.
+    const emphasized = tone === 'model' || tone === 'success' || tone === 'plan' || tone === 'warn' || tone === 'error'
+    const color = tone === 'live' && flowMs !== undefined
+      ? flowColor(flowMs, themeFlow()?.anchors ?? FLOW_ANCHORS)
+      : rainbowRoll().toneColors[tone]
+    return { color: inkColor(color), bold: emphasized || undefined, dimColor: undefined }
+  }
   switch (tone) {
     case 'model':
       // Same tone as the working-directory segment: the model name reads as
       // a path fact, not a brand accent.
       return { color: inkColor(getPalette().code), bold: true, dimColor: undefined }
     case 'live':
-      return { color: inkColor(getPalette().brandBright), bold: undefined, dimColor: undefined }
+      // With a flow sample (flowing theme while busy), the live dot rides
+      // the anchor walk; otherwise the palette's live accent.
+      return { color: inkColor(flowMs === undefined ? getPalette().brandBright : flowColor(flowMs, themeFlow()?.anchors ?? FLOW_ANCHORS)), bold: undefined, dimColor: undefined }
     case 'path':
       return { color: inkColor(getPalette().code), bold: undefined, dimColor: undefined }
     case 'branch':
@@ -980,12 +1297,22 @@ function statusToneProps(tone: StatusTone): {
  * the prompt keeps is always hues[0]. */
 function deepseekWaveHues(tier: DeepseekWaveTier): readonly [RgbTriple, RgbTriple, RgbTriple] {
   const palette = getPalette()
+  // Rainbow waves pick three SPECTRALLY SPREAD anchors from the rolled
+  // pool — spectral neighbors would wash into one hue across the band.
+  if (isRainbow()) {
+    const anchors = rainbowRoll().flowAnchors
+    const stride = Math.max(1, Math.floor(anchors.length / 3))
+    return [anchors[0], anchors[stride], anchors[stride * 2]]
+  }
+  // Prismatic waves ride the flow anchors for both tiers — the model-switch
+  // easter egg becomes a violet→fuchsia→cyan sweep.
+  if (isPrismatic()) return [FLOW_ANCHORS[0], FLOW_ANCHORS[1], FLOW_ANCHORS[2]]
   return tier === 'flash'
     ? [palette.brandBright, palette.brand, palette.brandMid]
     : [palette.brandBright, palette.code, palette.brandMid]
 }
 
-function StatusLine({ facts, stats, busy, columns, items, onRows }: {
+function StatusLine({ facts, stats, busy, columns, items, onRows, animated }: {
   facts: StatusFacts
   stats: Parameters<typeof layoutStatusBar>[1]
   busy: boolean
@@ -994,30 +1321,35 @@ function StatusLine({ facts, stats, busy, columns, items, onRows }: {
   /** Reports the footer's exact physical row count (1 or 2) so the IME
    * anchor ledger below the composer stays exact. */
   onRows?: (rows: 1 | 2) => void
+  /** Whether timed animations run (the persisted preference). */
+  animated: boolean
 }): ReactElement {
-  const layout = useMemo(() => layoutStatusBar(facts, stats, Math.max(8, columns - 2), {
-    busy,
-    items,
-    // Match the composer content budget: border + horizontal padding are
-    // already excluded, and layoutStatusBar shrinks this ceiling as needed.
-    contextWidth: Math.max(5, columns - 6),
-  }), [
-    facts.model,
-    facts.mode,
-    facts.cwd,
-    facts.branch,
-    facts.sessionId,
-    facts.title,
-    facts.sandbox,
-    facts.plan,
-    facts.permission,
-    facts.goal?.phase,
-    facts.goal?.rounds,
-    facts.goal?.max,
+  // Flowing-theme busy flow: the identity cluster's live dot cycles the
+  // anchor walk while a turn runs; static themes never start the timer.
+  const flow = themeFlow()
+  const flowActive = animated && busy && flow !== undefined
+  const flowTick = useFrames(BUSY_CHASE_TICK_MS, flowActive)
+  const flowMs = flowActive ? flowTick * BUSY_CHASE_TICK_MS + (flow?.phaseMs ?? 0) : undefined
+  const language = getLanguage()
+  const layout = useMemo(() => {
+    // The layout reads translations through t(); naming the current language
+    // here makes that external store value an explicit cache invalidator.
+    void language
+    return layoutStatusBar(facts, stats, Math.max(8, columns - 2), {
+      busy,
+      items,
+      // Match the composer content budget: border + horizontal padding are
+      // already excluded, and layoutStatusBar shrinks this ceiling as needed.
+      contextWidth: Math.max(5, columns - 6),
+    })
+  }, [
+    facts,
     stats,
     busy,
     columns,
     items,
+    // Labels come from t(); a language switch must rebuild the rows.
+    language,
   ])
   // The IME anchor below the composer counts every row between the caret and
   // Ink's parked cursor, so the footer reports its exact row count one-way
@@ -1036,7 +1368,7 @@ function StatusLine({ facts, stats, busy, columns, items, onRows }: {
       group.spans.forEach((span, spanIndex) => {
         leftParts.push(createElement(
           Text,
-          { key: key + 'g' + groupIndex + 's' + spanIndex, wrap: 'truncate-end', ...statusToneProps(span.tone) },
+          { key: key + 'g' + groupIndex + 's' + spanIndex, wrap: 'truncate-end', ...statusToneProps(span.tone, flowMs) },
           span.text,
         ))
       })
@@ -1048,12 +1380,12 @@ function StatusLine({ facts, stats, busy, columns, items, onRows }: {
       }
       rightParts.push(createElement(
         Text,
-        { key: key + 'r' + index, wrap: 'truncate-end', ...statusToneProps(span.tone) },
+        { key: key + 'r' + index, wrap: 'truncate-end', ...statusToneProps(span.tone, flowMs) },
         span.text,
       ))
     })
     if (row.hint) {
-      rightParts.push(createElement(Text, { key: key + 'hint', color: inkColor(getPalette().dim) }, STATUS_CYCLE_HINT))
+      rightParts.push(createElement(Text, { key: key + 'hint', color: inkColor(getPalette().dim) }, statusCycleHint()))
     }
     // Each row already fits the column budget; truncate-end stays as the
     // terminal-measurement backstop so a drifting cell count clips instead
@@ -1131,9 +1463,9 @@ const APPROVAL_OPTIONS: readonly ApprovalOption[] = [
 function ApprovalBar({ snapshot, locked, notify, interrupt, summarize }: {
   snapshot: ApprovalSnapshot
   locked: boolean
-  notify(text: string, tone?: NoticeTone): void
+  notify: (text: string, tone?: NoticeTone) => void
   /** Cancel the running turn (Ctrl+C), matching the composer's busy branch. */
-  interrupt(): boolean
+  interrupt: () => boolean
   /** Render as the bounded one-line form even on tall terminals (another
    * human-asked surface already owns the full panel budget). */
   summarize?: boolean
@@ -1160,7 +1492,7 @@ function ApprovalBar({ snapshot, locked, notify, interrupt, summarize }: {
     }
     ask.answer('rejected')
     if (option.key === 'reject-note') {
-      notify('rejected — type below what it should do differently (it steers the next step)', 'warning')
+      notify(t('notice.rejected'), 'warning')
     }
   }
 
@@ -1184,35 +1516,35 @@ function ApprovalBar({ snapshot, locked, notify, interrupt, summarize }: {
       return
     }
     if (key.return) {
-      decide(APPROVAL_OPTIONS[cursor]!)
+      decide(APPROVAL_OPTIONS[cursor])
       return
     }
     if (key.escape) {
-      decide(APPROVAL_OPTIONS[2]!)
+      decide(APPROVAL_OPTIONS[2])
       return
     }
     if (input === 'y' || input === 'Y') {
-      decide(APPROVAL_OPTIONS[0]!)
+      decide(APPROVAL_OPTIONS[0])
       return
     }
     if (input === 'n' || input === 'N') {
-      decide(APPROVAL_OPTIONS[1]!)
+      decide(APPROVAL_OPTIONS[1])
       return
     }
     if (input === 'd' || input === 'D') {
-      decide(APPROVAL_OPTIONS[2]!)
+      decide(APPROVAL_OPTIONS[2])
       return
     }
     if (/^[1-9]$/u.test(input)) {
       const index = Number(input) - 1
-      if (index < APPROVAL_OPTIONS.length) decide(APPROVAL_OPTIONS[index]!)
+      if (index < APPROVAL_OPTIONS.length) decide(APPROVAL_OPTIONS[index])
     }
   }, { isActive: active })
 
   if (pending === undefined) return undefined
   const queuedSuffix = snapshot.queued > 0 ? ` · +${snapshot.queued} queued` : ''
   if (viewport.maxHeight === 0 || viewport.compact || summarize === true) {
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`approval${queuedSuffix} · enter/y allow · esc/n reject`, viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('approval.compact', { queued: queuedSuffix }), viewport.contentColumns))
   }
   // Body budget: title + options + footer consume fixed rows; the command
   // preview shrinks with an explicit overflow marker (Codex's "[… N lines]").
@@ -1231,7 +1563,7 @@ function ApprovalBar({ snapshot, locked, notify, interrupt, summarize }: {
     createElement(PanelGap, { visible: viewport.gapRows > 0 && body.length > 0 }),
     ...visibleBody.map((line, index) => createElement(StyledRows, { key: `body-${index}`, lines: [line] })),
     ...(overflow > 0
-      ? [createElement(Text, { key: 'overflow', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`… +${overflow} more lines · ctrl+o shows the full call in the transcript`, viewport.contentColumns))]
+      ? [createElement(Text, { key: 'overflow', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(t('approval.overflow', { count: overflow }), viewport.contentColumns))]
       : []),
     ...(body.length > 0 ? [createElement(PanelGap, { visible: viewport.gapRows > 0 })] : []),
     ...APPROVAL_OPTIONS.map((option, index) => {
@@ -1248,8 +1580,8 @@ function ApprovalBar({ snapshot, locked, notify, interrupt, summarize }: {
       )
     }),
     createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(snapshot.answered
-      ? 'submitted…'
-      : '↑↓ choose · enter confirm · y/n/d quick · esc reject', viewport.contentColumns)),
+      ? t('approval.submitted')
+      : t('approval.footer'), viewport.contentColumns)),
   )
 }
 
@@ -1332,7 +1664,7 @@ function QuestionBar({ store, snapshot, locked }: { store: QuestionStore; snapsh
   }, [request])
 
   const question = pending?.request.questions[index]
-  const options = question?.options ?? []
+  const options = useMemo(() => question?.options ?? [], [question])
   const isPlan = question?.intent?.kind === 'plan-review'
   const isMulti = question?.multiSelect === true
   const currentDraft = drafts[index] ?? initialQuestionDraft(question)
@@ -1622,21 +1954,21 @@ function QuestionBar({ store, snapshot, locked }: { store: QuestionStore; snapsh
 
   if (pending === undefined || question === undefined) return undefined
   if (viewport.maxHeight === 0 || viewport.compact) {
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(isPlan ? 'plan review · esc cancel' : 'question · esc cancel', viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(isPlan ? t('question.compact.plan') : t('question.compact.normal'), viewport.contentColumns))
   }
   const footerBase = submitted
-    ? 'submitted…'
+    ? t('question.submitted')
     : mode === 'custom'
       ? options.length === 0
-        ? '↑↓/pgup/pgdn scroll · type answer · enter submit · esc interrupt'
-        : '↑↓/pgup/pgdn scroll · type answer · enter submit · tab/esc or empty backspace: options'
+        ? t('question.customNoOptions')
+        : t('question.customOptions')
       : options.length === 0
-        ? '↑↓/pgup/pgdn scroll · type answer · enter submit · esc interrupt'
+        ? t('question.customNoOptions')
       : isMulti
-        ? '↑↓ choose · pgup/pgdn scroll · space/1-9 toggle · enter submit · c custom · esc interrupt'
-        : '↑↓ choose · pgup/pgdn scroll · 1-9 pick · enter submit · c custom · esc interrupt'
+        ? t('question.multiOptions')
+        : t('question.singleOptions')
   const footer = pending.request.questions.length > 1 && !submitted
-    ? `${footerBase} · ←→/ctrl+p/n switch question`
+    ? `${footerBase}${t('question.switch')}`
     : footerBase
   return createElement(
     Box,
@@ -1644,12 +1976,12 @@ function QuestionBar({ store, snapshot, locked }: { store: QuestionStore; snapsh
     createElement(
       Text,
       { color: inkColor(isPlan ? getPalette().brand : getPalette().brandDeep), bold: true, wrap: 'truncate-end' },
-      truncateColumns(`${isPlan ? '📋 plan review' : '❓ question'} ${index + 1}/${pending.request.questions.length} · lines ${rendered.lines.length === 0 ? 0 : visibleScroll + 1}-${Math.min(rendered.lines.length, visibleScroll + viewport.bodyRows)}/${rendered.lines.length}`, viewport.contentColumns),
+      truncateColumns(`${isPlan ? t('question.title.plan') : t('question.title.normal')} ${index + 1}/${pending.request.questions.length} · lines ${rendered.lines.length === 0 ? 0 : visibleScroll + 1}-${Math.min(rendered.lines.length, visibleScroll + viewport.bodyRows)}/${rendered.lines.length}`, viewport.contentColumns),
     ),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     createElement(StyledRows, { lines: rendered.lines.slice(visibleScroll, visibleScroll + viewport.bodyRows) }),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, dim(truncateColumns(footer, viewport.contentColumns))),
+    createElement(Text, { wrap: 'truncate-end' }, dim(truncateColumns(footer, viewport.contentColumns))),
   )
 }
 
@@ -1659,16 +1991,16 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
   error: string | undefined
   /** `provider/model` label of the applied model: the cursor lands on it once. */
   current?: string
-  onSelect(row: ModelRow): void
-  onProviders?(): void
-  onRetry(): void
-  onClose(): void
+  onSelect: (row: ModelRow) => void
+  onProviders?: () => void
+  onRetry: () => void
+  onClose: () => void
 }): ReactElement {
   const [query, setQuery] = useState('')
   const [cursor, setCursor] = useState(0)
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
-  const rows = directory?.rows ?? []
+  const rows = useMemo(() => directory?.rows ?? [], [directory])
   // Direct-typing filter over provider and model names (the /mode contract):
   // printable keys edit the query, so a long directory is searchable without
   // a separate search mode. With a query active, q/r/g/G stop acting as
@@ -1679,6 +2011,13 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
     return rows.filter(row => `${row.provider} ${row.providerName ?? ''} ${row.model} ${row.modelName}`.toLowerCase().includes(needle))
   }, [rows, query])
   const positioned = useRef(false)
+  // Latest-value ref: Ink re-subscribes useInput when its effect flushes,
+  // which can lag a committed render (a directory that just landed paints
+  // before the subscription swaps). A keystroke in that window would meet a
+  // stale closure — Enter died as an empty-filter no-op right after "2 of 4
+  // match" painted. The handler reads render-fresh values through the ref.
+  const liveRef = useRef({ filtered, query, cursor })
+  liveRef.current = { filtered, query, cursor }
 
   useEffect(() => {
     // Open ON the applied model (Codex resumes the previous pick): the first
@@ -1697,7 +2036,7 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
       // Position within the ACTIVE filter: the full-row index means nothing
       // when the query already narrowed the list while the directory loaded
       // (a late resolve must not place the cursor outside `filtered`).
-      const filteredIndex = filtered.indexOf(rows[index]!)
+      const filteredIndex = filtered.indexOf(rows[index])
       setCursor(filteredIndex >= 0 ? filteredIndex : 0)
     } else if (cursor >= filtered.length) {
       setCursor(Math.max(0, filtered.length - 1))
@@ -1705,11 +2044,12 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
   }, [rows, filtered, cursor, current])
 
   useInput((input, key) => {
-    if (key.escape || (input === 'q' && query === '')) {
+    const { filtered: list, query: text, cursor: at } = liveRef.current
+    if (key.escape || (input === 'q' && text === '')) {
       onClose()
       return
     }
-    if (input === 'r' && query === '') {
+    if (input === 'r' && text === '') {
       onRetry()
       return
     }
@@ -1722,19 +2062,19 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
       onClose()
       return
     }
-    const next = editQuery(query, input, key)
+    const next = editQuery(text, input, key)
     if (next !== undefined) {
       setQuery(next)
       setCursor(0)
       return
     }
-    if (filtered.length === 0) return
+    if (list.length === 0) return
     if (key.upArrow) {
-      setCursor(cursor > 0 ? cursor - 1 : filtered.length - 1)
+      setCursor(at > 0 ? at - 1 : list.length - 1)
       return
     }
     if (key.downArrow) {
-      setCursor(cursor < filtered.length - 1 ? cursor + 1 : 0)
+      setCursor(at < list.length - 1 ? at + 1 : 0)
       return
     }
     if (key.pageUp) {
@@ -1742,11 +2082,11 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
       return
     }
     if (key.pageDown) {
-      setCursor(current => Math.min(filtered.length - 1, current + Math.max(1, viewport.bodyRows - 1)))
+      setCursor(current => Math.min(list.length - 1, current + Math.max(1, viewport.bodyRows - 1)))
       return
     }
-    if (key.return && filtered[cursor] !== undefined) {
-      onSelect(filtered[cursor])
+    if (key.return && list[at] !== undefined) {
+      onSelect(list[at])
     }
   })
 
@@ -1754,19 +2094,19 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
     const providers = onProviders === undefined ? '' : ' · tab providers'
     const state = filtered.length === 0
       ? directory === undefined && error === undefined
-        ? 'loading…'
+        ? t('panel.model.loading')
         : error !== undefined
-          ? 'error'
-          : query === '' ? 'no models' : `no match for '${singleLineText(query)}'`
+          ? t('panel.model.error')
+          : query === '' ? t('panel.model.noModels') : t('panel.model.compactNoMatch', { query: singleLineText(query) })
       : `❯ ${filtered[cursor]?.modelName ?? filtered[cursor]?.model ?? ''}`
     const tail = query === ''
-      ? 'type to filter · r retry · esc/q close'
-      : 'backspace edits · esc close'
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`/model · ${state}${providers} · ${tail}`, viewport.contentColumns))
+      ? t('panel.model.footer.filter')
+      : t('panel.model.footer.filtered')
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.model.compact', { state, providers, tail }), viewport.contentColumns))
   }
 
   const stateRows: ReactElement[] = directory === undefined && error === undefined
-    ? [createElement(Text, { key: 'loading', dimColor: true, wrap: 'truncate-end' }, '  loading models…')]
+    ? [createElement(Text, { key: 'loading', dimColor: true, wrap: 'truncate-end' }, `  ${t('panel.model.loading')}`)]
     : error !== undefined
       ? [createElement(
         Text,
@@ -1779,12 +2119,12 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
           : [createElement(
             Text,
             { key: 'failures', color: inkColor(getPalette().warn), wrap: 'truncate-end' },
-            truncateColumns(`  unavailable providers: ${directory?.failures.join(', ')}`, viewport.contentColumns),
+            truncateColumns(`  ${t('panel.provider.failure', { providers: directory?.failures.join(', ') ?? '' })}`, viewport.contentColumns),
           )]),
         ...(rows.length === 0
-          ? [createElement(Text, { key: 'empty', dimColor: true, wrap: 'truncate-end' }, '  no models available')]
+          ? [createElement(Text, { key: 'empty', dimColor: true, wrap: 'truncate-end' }, `  ${t('panel.model.noModels')}`)]
           : filtered.length === 0
-            ? [createElement(Text, { key: 'no-match', dimColor: true, wrap: 'truncate-end' }, truncateColumns(`  no models match '${singleLineText(query)}'`, viewport.contentColumns))]
+            ? [createElement(Text, { key: 'no-match', dimColor: true, wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.model.noMatch', { query: singleLineText(query) })}`, viewport.contentColumns))]
             : []),
       ]
   // Measurement and rendering share the same physical-row budget: state
@@ -1794,12 +2134,13 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
   const rowBudget = Math.max(0, viewport.bodyRows - visibleStateRows.length)
   const first = selectionWindow(cursor, filtered.length, rowBudget)
   const visible = rowBudget === 0 ? [] : filtered.slice(first, first + rowBudget)
+  const accent = panelAccent('model', getPalette().brand)
   return createElement(
     Box,
-    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().brand) },
-    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns(query === ''
-      ? `/model — select model${rows.length === 0 ? '' : ` · ${cursor + 1}/${rows.length}`}`
-      : `/model — select model · ${filtered.length} of ${rows.length} match '${singleLineText(query)}'`, viewport.contentColumns)),
+    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(query === ''
+      ? rows.length === 0 ? t('panel.model.title') : t('panel.model.titleCount', { index: cursor + 1, total: rows.length })
+      : t('panel.model.titleMatches', { filtered: filtered.length, total: rows.length, query: singleLineText(query) }), viewport.contentColumns)),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     ...visibleStateRows,
     ...visible.map((row) => {
@@ -1817,23 +2158,23 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
       )
     }),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, dim(truncateColumns(query === ''
-      ? `type to filter · ↑↓ move · pgup/pgdn page · enter select${onProviders === undefined ? '' : ' · tab providers'} · r retry · esc/q close`
-      : `↑↓ move · pgup/pgdn page · enter select · backspace edits · esc close`, viewport.contentColumns))),
+    createElement(Text, { wrap: 'truncate-end' }, dim(truncateColumns(query === ''
+      ? t('panel.model.footer.select', { providers: onProviders === undefined ? '' : ` · ${t('panel.model.providers')}` })
+      : t('panel.model.footer.filteredSelect'), viewport.contentColumns))),
   )
 }
 
 /** Compact provider-state copy; only value-free credential facts cross this boundary. */
 function providerStateLabel(row: ProviderTargetView): string {
-  const route = row.active ? 'active' : 'dormant'
+  const route = row.active ? t('panel.provider.active') : t('panel.provider.dormant')
   const credential = row.credential
-  if (credential?.kind === 'error') return `${route} · key status unavailable`
+  if (credential?.kind === 'error') return t('panel.provider.state', { route, value: t('panel.provider.keyStatusUnavailable') })
   if (credential?.kind === 'facts') {
-    if (!credential.configured) return `${route} · key missing`
-    const source = credential.source === undefined ? 'configured' : singleLineText(credential.source)
-    return `${route} · key ${source}${credential.writable ? '' : ' · read-only'}`
+    if (!credential.configured) return t('panel.provider.state', { route, value: t('panel.provider.noKey') })
+    const source = credential.source === undefined ? t('panel.provider.configured') : singleLineText(credential.source)
+    return t('panel.provider.state', { route, value: `${t('panel.provider.key', { value: source })}${credential.writable ? '' : ` · ${t('panel.provider.readOnly')}`}` })
   }
-  return `${route} · ${row.configured ? 'provider auth' : 'not configured'}`
+  return t('panel.provider.state', { route, value: row.configured ? t('panel.provider.authConfigured') : t('panel.provider.noLogin') })
 }
 
 /** The provider-management stage reached from /model with `a`. */
@@ -1842,15 +2183,15 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
   error: string | undefined
   authorizations: ProviderAuthorizationDirectory | undefined
   authorizationError: string | undefined
-  onConfigure(target: ProviderTargetView): void
-  onUnset(target: ProviderTargetView): void
-  onRemove(target: ProviderTargetView): void
-  onLogin(target: ProviderTargetView, authorization: ProviderAuthorizationRow): void
-  onLogout(target: ProviderTargetView, authorization: ProviderAuthorizationRow): void
-  onRetry(): void
-  onBack(): void
+  onConfigure: (target: ProviderTargetView) => void
+  onUnset: (target: ProviderTargetView) => void
+  onRemove: (target: ProviderTargetView) => void
+  onLogin: (target: ProviderTargetView, authorization: ProviderAuthorizationRow) => void
+  onLogout: (target: ProviderTargetView, authorization: ProviderAuthorizationRow) => void
+  onRetry: () => void
+  onBack: () => void
   /** Leave the whole /model flow (Ctrl+C), not just this stage. */
-  onExit(): void
+  onExit: () => void
 }): ReactElement {
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
@@ -1912,9 +2253,9 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
     if (input === 'd') {
       const facts = target.credential
       if (facts?.kind !== 'facts' || !facts.configured) {
-        setActionError('this provider has no configured API key to remove')
+        setActionError(t('panel.provider.noConfiguredKey'))
       } else if (!facts.writable) {
-        setActionError('this API key is supplied read-only by the environment')
+        setActionError(t('panel.provider.readOnlyKey'))
       } else {
         onUnset(target)
       }
@@ -1922,7 +2263,7 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
     }
     if (input === 'x') {
       if (!target.removable) {
-        setActionError('this provider profile is not removable')
+        setActionError(t('panel.provider.notRemovable'))
       } else {
         onRemove(target)
       }
@@ -1930,14 +2271,14 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
     }
     const authorization = authorizationForProvider(authorizations, target.provider)
     if (input === 'l' || input === 'L') {
-      if (authorization === undefined) setActionError('this provider offers no interactive login flow')
-      else if (authorization.inFlight) setActionError('a login attempt is already running for this provider')
+      if (authorization === undefined) setActionError(t('panel.provider.noLoginFlow'))
+      else if (authorization.inFlight) setActionError(t('panel.provider.loginRunning'))
       else onLogin(target, authorization)
       return
     }
     if (input === 'o' || input === 'O') {
-      if (authorization === undefined || !authorization.record.configured) setActionError('this provider has no login record to remove')
-      else if (!authorization.record.writable) setActionError('this login record is read-only')
+      if (authorization === undefined || !authorization.record.configured) setActionError(t('panel.provider.noLoginRecord'))
+      else if (!authorization.record.writable) setActionError(t('panel.provider.readOnlyLogin'))
       else onLogout(target, authorization)
       return
     }
@@ -1946,7 +2287,7 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
     // the configuration surface behind an undiscoverable chord.
     if (key.return) {
       if (target.settingsNs.length === 0) {
-        setActionError('this provider is not managed by Harness settings')
+        setActionError(t('panel.provider.notManaged'))
       } else {
         onConfigure(target)
       }
@@ -1954,10 +2295,10 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
   }, true)
 
   if (viewport.maxHeight === 0 || viewport.compact) {
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('/model providers · enter configure · d remove key · esc back', viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.providers.compact'), viewport.contentColumns))
   }
   const stateRows: ReactElement[] = directory === undefined && error === undefined
-    ? [createElement(Text, { key: 'loading', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, '  loading providers…')]
+    ? [createElement(Text, { key: 'loading', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, `  ${t('panel.provider.loading')}`)]
     : error !== undefined
       ? [createElement(Text, { key: 'error', color: inkColor(getPalette().error), wrap: 'truncate-end' }, truncateColumns(`  ${singleLineText(error)}`, viewport.contentColumns))]
       : [
@@ -1971,14 +2312,14 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
         )),
         ...(authorizationError === undefined
           ? []
-          : [createElement(Text, { key: 'authorization-error', color: inkColor(getPalette().warn), wrap: 'truncate-end' }, truncateColumns(`  login status unavailable: ${singleLineText(authorizationError)}`, viewport.contentColumns))]),
+          : [createElement(Text, { key: 'authorization-error', color: inkColor(getPalette().warn), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.provider.loginStatusUnavailable', { message: singleLineText(authorizationError) })}`, viewport.contentColumns))]),
         ...(authorizations?.failures ?? []).map((failure, index) => createElement(
           Text,
           { key: `authorization-failure-${index}`, color: inkColor(getPalette().warn), wrap: 'truncate-end' },
           truncateColumns(`  ${singleLineText(failure)}`, viewport.contentColumns),
         )),
         ...(rows.length === 0
-          ? [createElement(Text, { key: 'empty', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, '  no configurable providers')]
+          ? [createElement(Text, { key: 'empty', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, `  ${t('panel.provider.empty')}`)]
           : []),
       ]
   const visibleStateRows = stateRows.slice(0, viewport.bodyRows)
@@ -1989,7 +2330,7 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
   const itemRows: ReactElement[] = []
   for (let display = first; display < first + rowBudget && display < displayLength; display += 1) {
     if (hasSeparator && display === configuredCount) {
-      itemRows.push(createElement(Text, { key: 'separator', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  ── not configured ──', viewport.contentColumns)))
+      itemRows.push(createElement(Text, { key: 'separator', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.provider.notConfiguredDivider')}`, viewport.contentColumns)))
       continue
     }
     const index = hasSeparator && display > configuredCount ? display - 1 : display
@@ -2013,15 +2354,16 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
       truncateColumns((index === cursor ? '❯ ' : '  ') + displayText(label), viewport.contentColumns),
     ))
   }
+  const accent = panelAccent('model-providers', getPalette().brand)
   return createElement(
     Box,
-    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().brand) },
-    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns(`/model — providers${rows.length === 0 ? '' : ` · ${cursor + 1}/${rows.length}`}`, viewport.contentColumns)),
+    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(rows.length === 0 ? t('panel.provider.title') : t('panel.provider.titleCount', { index: cursor + 1, total: rows.length }), viewport.contentColumns)),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     ...visibleStateRows,
     ...itemRows,
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('↑↓ move · enter configure · l login · o logout · d remove key · x remove provider · r retry · esc back', viewport.contentColumns)),
+    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(t('panel.providers.footer'), viewport.contentColumns)),
   )
 }
 
@@ -2049,14 +2391,14 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
   target: ProviderTargetView
   /** Models with declared efforts (settings first, catalog-advertised after) a model row can copy from. */
   effortDonors: readonly EffortDonor[]
-  save(target: ProviderTargetView, configuration: ProviderConfiguration): Promise<void>
+  save: (target: ProviderTargetView, configuration: ProviderConfiguration) => Promise<void>
   saveCredential: ((target: ProviderTargetView, key: string) => Promise<void>) | undefined
-  discover(target: ProviderTargetView, request: { readonly apiKey?: string; readonly baseURL?: string }, signal?: AbortSignal): Promise<readonly DiscoveredModelView[]>
+  discover: (target: ProviderTargetView, request: { readonly apiKey?: string; readonly baseURL?: string }, signal?: AbortSignal) => Promise<readonly DiscoveredModelView[]>
   /** Report a successful save so the surface can notice the key rotation. */
-  done(result: { readonly key: boolean }): void
-  back(): void
+  done: (result: { readonly key: boolean }) => void
+  back: () => void
   /** Leave the whole /model flow (Ctrl+C), not just this page. */
-  onExit(): void
+  onExit: () => void
 }): ReactElement {
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
@@ -2110,7 +2452,7 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
 
   /** Compact declaration summary for the row label: count, off, or inherit. */
   const effortsSummary = (model: ProviderModelSettings): string => {
-    const raw = (model.extras as Record<string, unknown> | undefined)?.reasoningEfforts
+    const raw = (model.extras)?.reasoningEfforts
     if (raw === false) return 'off'
     if (isDeclaredReasoningEfforts(raw)) return String(Object.keys(raw).length)
     return '~'
@@ -2263,7 +2605,7 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
     }
     if (input === 'e' && selected !== undefined) {
       setError(undefined)
-      setEffDraft(serializeReasoningEfforts((selected.extras as Record<string, unknown> | undefined)?.reasoningEfforts))
+      setEffDraft(serializeReasoningEfforts((selected.extras)?.reasoningEfforts))
       setEffEditing(true)
       return
     }
@@ -2291,19 +2633,20 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
     // Never hide a live input surface: one visible row keeps the escape
     // route honest on extremely short terminals (the three fixed rows - key,
     // url, add-by-id - cannot fit below a three-row body).
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('provider setup · terminal too small · esc back', viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.setup.compact'), viewport.contentColumns))
   }
   if (page === 'donor') {
     const stateRow = donorRows.length === 0
-      ? createElement(Text, { key: 'empty', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  no model with declared efforts yet; declare one with e, or hand-write settings', viewport.contentColumns))
-      : createElement(Text, { key: 'hint', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  copy verbatim into ' + displayText(selected?.id ?? ''), viewport.contentColumns))
+      ? createElement(Text, { key: 'empty', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.setup.noDonors')}`, viewport.contentColumns))
+      : createElement(Text, { key: 'hint', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.setup.copyInto', { id: displayText(selected?.id ?? '') })}`, viewport.contentColumns))
     const donorBudget = Math.max(0, viewport.bodyRows - 2)
     const donorFirst = selectionWindow(donorIndex, donorRows.length, donorBudget)
     const donorVisible = donorRows.slice(donorFirst, donorFirst + donorBudget)
+    const accent = panelAccent('model-efforts', getPalette().brand)
     return createElement(
       Box,
-      { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().brand) },
-      createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns('/model — copy efforts', viewport.contentColumns)),
+      { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+      createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.setup.copyTitle'), viewport.contentColumns)),
       createElement(PanelGap, { visible: viewport.gapRows > 0 }),
       stateRow,
       ...donorVisible.map((donor, index) => {
@@ -2312,7 +2655,7 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
         return createElement(Text, { key: donor.provider + '/' + donor.id, color: active ? inkColor(getPalette().brandBright) : inkColor(getPalette().text), wrap: 'truncate-end' }, truncateColumns(label, viewport.contentColumns))
       }),
       createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-      createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('↑↓ move · enter copy · esc back', viewport.contentColumns)),
+      createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(t('panel.setup.copyFooter'), viewport.contentColumns)),
     )
   }
   if (page === 'discover') {
@@ -2354,7 +2697,7 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
       modelRows.push(createElement(Text, { key: 'add', color: cursor === index ? inkColor(getPalette().brandBright) : inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  ' + (cursor === index ? '>' : ' ') + ' + add by id' + (addDraft === '' ? '' : ' ' + addDraft + '▏'), viewport.contentColumns)))
       continue
     }
-    const model = models[index]!
+    const model = models[index]
     const active = index === cursor
     const context = model.contextWindow === undefined ? '-' : String(model.contextWindow)
     const output = model.maxTokens === undefined ? '-' : String(model.maxTokens)
@@ -2364,10 +2707,11 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
       : '  in:' + (active && field === 'ctx' ? '[' + context + ']' : context) + ' out:' + (active && field === 'out' ? '[' + output + ']' : output) + ' eff:' + effortsSummary(model)
     modelRows.push(createElement(Text, { key: model.id, color: active ? inkColor(getPalette().brandBright) : inkColor(getPalette().success), wrap: 'truncate-end' }, truncateColumns('  ' + (active ? '>' : ' ') + ' [x] ' + displayText(model.id) + tail, viewport.contentColumns)))
   }
+  const accent = panelAccent('model-configure', getPalette().brand)
   return createElement(
     Box,
-    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().brand) },
-    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns('/model — configure ' + target.displayName, viewport.contentColumns)),
+    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.setup.title', { provider: target.displayName }), viewport.contentColumns)),
     // The adapter's configuration diagnostic heads the editor: the provider
     // is here precisely because it stayed listed for repair.
     ...(target.diagnostic === undefined ? [] : [createElement(
@@ -2381,7 +2725,7 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
     ...stateRows,
     ...modelRows,
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('↑↓ move · ←→ in/out · space remove · e efforts · c copy efforts · tab discover · enter save · esc back', viewport.contentColumns)),
+    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(t('panel.setup.footer'), viewport.contentColumns)),
   )
 }
 
@@ -2397,11 +2741,11 @@ function ProviderDiscoveryPanel({ target, baseURL, apiKey, configured, discover,
   baseURL: string
   apiKey: string
   configured: readonly string[]
-  discover(target: ProviderTargetView, request: { readonly apiKey?: string; readonly baseURL?: string }, signal?: AbortSignal): Promise<readonly DiscoveredModelView[]>
-  onAdopt(models: readonly DiscoveredModelView[]): void
-  back(): void
+  discover: (target: ProviderTargetView, request: { readonly apiKey?: string; readonly baseURL?: string }, signal?: AbortSignal) => Promise<readonly DiscoveredModelView[]>
+  onAdopt: (models: readonly DiscoveredModelView[]) => void
+  back: () => void
   /** Leave the whole /model flow (Ctrl+C). */
-  onExit(): void
+  onExit: () => void
 }): ReactElement {
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
@@ -2462,24 +2806,25 @@ function ProviderDiscoveryPanel({ target, baseURL, apiKey, configured, discover,
     }
   }, true)
   if (viewport.maxHeight === 0) {
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('model discovery · terminal too small · esc back', viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.discovery.compact'), viewport.contentColumns))
   }
   const stateRows = loading
-    ? [createElement(Text, { key: 'loading', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  discovering models…', viewport.contentColumns))]
+    ? [createElement(Text, { key: 'loading', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.discovery.loading')}`, viewport.contentColumns))]
     : error !== undefined
       ? [createElement(Text, { key: 'error', color: inkColor(getPalette().error), wrap: 'truncate-end' }, truncateColumns('  ' + error, viewport.contentColumns))]
       : rows.length === 0
-        ? [createElement(Text, { key: 'empty', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  the endpoint advertised no models; add ids by hand on the setup page', viewport.contentColumns))]
-        : [createElement(Text, { key: 'summary', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  ' + rows.length + ' advertised · ' + rows.filter(model => !known.has(model.id)).length + ' new · ' + checked.size + ' checked', viewport.contentColumns))]
+        ? [createElement(Text, { key: 'empty', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.discovery.empty')}`, viewport.contentColumns))]
+        : [createElement(Text, { key: 'summary', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.discovery.summary', { advertised: rows.length, newCount: rows.filter(model => !known.has(model.id)).length, checked: checked.size })}`, viewport.contentColumns))]
   // One spare row keeps the panel strictly below maxHeight even with the
   // gap collapsed (the at-equality regime makes Ink rewrite Static).
   const rowBudget = Math.max(0, viewport.bodyRows - stateRows.length - 1)
   const first = selectionWindow(cursor, rows.length, rowBudget)
   const visible = rows.slice(first, first + rowBudget)
+  const accent = panelAccent('model-discover', getPalette().brand)
   return createElement(
     Box,
-    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().brand) },
-    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns('/model — discover ' + target.displayName, viewport.contentColumns)),
+    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.discovery.title', { provider: target.displayName }), viewport.contentColumns)),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     ...stateRows,
     ...visible.map((model, index) => {
@@ -2491,7 +2836,7 @@ function ProviderDiscoveryPanel({ target, baseURL, apiKey, configured, discover,
       return createElement(Text, { key: model.id, color: added ? inkColor(getPalette().dim) : active ? inkColor(getPalette().brandBright) : inkColor(getPalette().text), wrap: 'truncate-end' }, truncateColumns(label, viewport.contentColumns))
     }),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('↑↓ move · space check · enter adopt · f refetch · esc back', viewport.contentColumns)),
+    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(t('panel.discovery.footer'), viewport.contentColumns)),
   )
 }
 
@@ -2499,9 +2844,9 @@ function ProviderDiscoveryPanel({ target, baseURL, apiKey, configured, discover,
 function ProviderConfirmPanel({ target, kind, confirm, done, back }: {
   target: ProviderTargetView
   kind: 'credential' | 'provider'
-  confirm(target: ProviderTargetView): Promise<void>
-  done(): void
-  back(): void
+  confirm: (target: ProviderTargetView) => Promise<void>
+  done: () => void
+  back: () => void
 }): ReactElement {
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
@@ -2559,7 +2904,7 @@ function HelpPanel({ descriptors, skills, commandError, skillError, onClose }: {
   skills: readonly SkillRow[]
   commandError: string | undefined
   skillError: string | undefined
-  onClose(): void
+  onClose: () => void
 }): ReactElement {
   const stdout = useStdout().stdout
   const columns = stdout?.columns ?? 80
@@ -2569,19 +2914,19 @@ function HelpPanel({ descriptors, skills, commandError, skillError, onClose }: {
   const descBudget = Math.max(0, viewport.contentColumns - nameWidth - 2)
   const row = (label: string, description: string): ReactElement => createElement(
     Text,
-    { dimColor: true, wrap: 'truncate-end' },
-    `  ${padColumns(label, nameWidth)}${dim(truncateColumns(displayText(description), descBudget))}`,
+    { color: inkColor(getPalette().dim), wrap: 'truncate-end' },
+    `  ${padColumns(label, nameWidth)}${truncateColumns(displayText(description), descBudget)}`,
   )
   const content: ReactElement[] = [
-    createElement(Text, { key: 'keys-title', bold: true, wrap: 'truncate-end' }, ' keys'),
-    createElement(Text, { key: 'key-submit', dimColor: true, wrap: 'truncate-end' }, '  enter submit · up/down history · tab complete'),
-    createElement(Text, { key: 'key-mentions', dimColor: true, wrap: 'truncate-end' }, '  @ mentions workspace files and sessions'),
-    createElement(Text, { key: 'key-inspector', dimColor: true, wrap: 'truncate-end' }, '  ctrl+o history details · ctrl/alt+r thinking · shift+tab permission preset'),
-    createElement(Text, { key: 'key-cancel', dimColor: true, wrap: 'truncate-end' }, '  esc interrupt the running turn · ctrl+c cancel / clear / quit · ctrl+d exit'),
-    createElement(Text, { key: 'key-queue', dimColor: true, wrap: 'truncate-end' }, '  delete on the empty composer cancels the newest queued message'),
-    createElement(Text, { key: 'key-edit', dimColor: true, wrap: 'truncate-end' }, '  ctrl+k cut to end of line · ctrl+u clear line · ctrl+a / ctrl+e line ends'),
+    createElement(Text, { key: 'keys-title', bold: true, wrap: 'truncate-end' }, t('help.keysTitle')),
+    createElement(Text, { key: 'key-submit', dimColor: true, wrap: 'truncate-end' }, `  ${t('help.key.submit')}`),
+    createElement(Text, { key: 'key-mentions', dimColor: true, wrap: 'truncate-end' }, `  ${t('help.key.mentions')}`),
+    createElement(Text, { key: 'key-inspector', dimColor: true, wrap: 'truncate-end' }, `  ${t('help.key.inspector')}`),
+    createElement(Text, { key: 'key-cancel', dimColor: true, wrap: 'truncate-end' }, `  ${t('help.key.cancel')}`),
+    createElement(Text, { key: 'key-queue', dimColor: true, wrap: 'truncate-end' }, `  ${t('help.key.queue')}`),
+    createElement(Text, { key: 'key-edit', dimColor: true, wrap: 'truncate-end' }, `  ${t('help.key.edit')}`),
     createElement(Text, { key: 'commands-gap' }, ' '),
-    createElement(Text, { key: 'commands-title', bold: true, wrap: 'truncate-end' }, ' commands'),
+    createElement(Text, { key: 'commands-title', bold: true, wrap: 'truncate-end' }, t('help.commandsTitle')),
     ...(commandError === undefined
       ? []
       : [createElement(
@@ -2592,18 +2937,18 @@ function HelpPanel({ descriptors, skills, commandError, skillError, onClose }: {
     ...LOCAL_COMMANDS.map(command => createElement(
       Box,
       { key: `local-${command.label.slice(1)}` },
-      row(command.label, command.description),
+      row(command.label, t(command.descriptionKey)),
     )),
     ...descriptors.filter(descriptor => !LOCAL_COMMAND_NAMES.has(descriptor.name)).map(descriptor => createElement(
       Text,
-      { key: `command-${descriptor.name}`, dimColor: true, wrap: 'truncate-end' },
-      `  ${padColumns(`/${descriptor.name}`, nameWidth)}${dim(truncateColumns(displayText(descriptor.description), descBudget))}`,
+      { key: `command-${descriptor.name}`, color: inkColor(getPalette().dim), wrap: 'truncate-end' },
+      `  ${padColumns(`/${descriptor.name}`, nameWidth)}${truncateColumns(displayText(descriptor.description), descBudget)}`,
     )),
     ...(skills.length === 0 && skillError === undefined
       ? []
       : [
           createElement(Text, { key: 'skills-gap' }, ' '),
-          createElement(Text, { key: 'skills-title', bold: true, wrap: 'truncate-end' }, ' skills'),
+          createElement(Text, { key: 'skills-title', bold: true, wrap: 'truncate-end' }, t('help.skillsTitle')),
         ]),
     ...(skillError === undefined
       ? []
@@ -2614,8 +2959,8 @@ function HelpPanel({ descriptors, skills, commandError, skillError, onClose }: {
       )]),
     ...skills.map(skill => createElement(
       Text,
-      { key: `skill-${skill.name}`, dimColor: true, wrap: 'truncate-end' },
-      `  ${padColumns(`/${skill.name}`, nameWidth)}${dim(truncateColumns(displayText(skill.description), descBudget))}`,
+      { key: `skill-${skill.name}`, color: inkColor(getPalette().dim), wrap: 'truncate-end' },
+      `  ${padColumns(`/${skill.name}`, nameWidth)}${truncateColumns(displayText(skill.description), descBudget)}`,
     )),
   ]
   const visibleScroll = clampScroll(scroll, content.length, viewport.bodyRows)
@@ -2641,17 +2986,18 @@ function HelpPanel({ descriptors, skills, commandError, skillError, onClose }: {
   })
 
   if (viewport.maxHeight === 0 || viewport.compact) {
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('/help · esc/q close', viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('help.compact'), viewport.contentColumns))
   }
 
+  const accent = panelAccent('help', getPalette().brand)
   return createElement(
     Box,
-    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().brand) },
-    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns(`/help — keys and commands · rows ${content.length === 0 ? 0 : visibleScroll + 1}-${Math.min(content.length, visibleScroll + viewport.bodyRows)}/${content.length}`, viewport.contentColumns)),
+    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(`/help — keys and commands · rows ${content.length === 0 ? 0 : visibleScroll + 1}-${Math.min(content.length, visibleScroll + viewport.bodyRows)}/${content.length}`, viewport.contentColumns)),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     ...content.slice(visibleScroll, visibleScroll + viewport.bodyRows),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, dim(truncateColumns('↑↓ scroll · pgup/pgdn page · g/G ends · esc/q close', viewport.contentColumns))),
+    createElement(Text, { wrap: 'truncate-end' }, dim(truncateColumns(t('help.footer'), viewport.contentColumns))),
   )
 }
 
@@ -2661,7 +3007,8 @@ function verboseLine(text: string, columns: number): string {
 }
 
 /** The empty-composer placeholder text (shared by the static and wave paths). */
-const COMPOSER_PLACEHOLDER = 'type a message · / commands · @ mentions'
+const composerPlaceholder = (mode: 'queue' | 'steer'): string =>
+  t(mode === 'steer' ? 'composer.placeholderSteer' : 'composer.placeholder')
 
 /** One physical cell of the wave-painted composer row: a char plus styles. */
 interface ComposerCell {
@@ -2694,9 +3041,9 @@ function waveRowSpans(cells: readonly ComposerCell[]): ReactElement[] {
   const spans: ReactElement[] = []
   let start = 0
   while (start < cells.length) {
-    const cell = cells[start]!
+    const cell = cells[start]
     let end = start + 1
-    while (end < cells.length && sameCellStyle(cells[end]!, cell)) end += 1
+    while (end < cells.length && sameCellStyle(cells[end], cell)) end += 1
     spans.push(createElement(
       Text,
       {
@@ -2719,7 +3066,7 @@ function cellIndexAtColumn(cells: readonly ComposerCell[], target: number): numb
   let column = 0
   for (let index = 0; index < cells.length; index += 1) {
     if (column === target) return index
-    column += cells[index]!.width ?? visibleColumns(cells[index]!.char)
+    column += cells[index].width ?? visibleColumns(cells[index].char)
     if (column > target) return undefined
   }
   return undefined
@@ -2792,11 +3139,13 @@ interface ComposerWaveProps {
   value: string
   /** Tier prompt glyph and accent color (persistent, like Codex's charge). */
   promptGlyph: string
+  /** Empty-composer placeholder for the delivery mode in force. */
+  placeholder: string
   promptColor: string
   /** Fires EXACTLY ONCE when this sweep ends for any reason — completed,
    * cancelled by the gate, or unmounted (a modal panel froze the composer) —
    * so Input's played-key latch survives the leaf's unmount/remount cycle. */
-  onSettled(): void
+  onSettled: () => void
 }
 
 /**
@@ -2864,7 +3213,7 @@ function ComposerWave(props: ComposerWaveProps): ReactElement {
     }
     for (const span of splitGraphemes(parts.before)) push(span.text)
     if (parts.hasCaret) push(parts.caret, { inverse: props.caretVisible })
-    const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after
+    const tail = placeholder ? props.placeholder : parts.after
     for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {})
     while (usedColumns < props.bandWidth) push(' ')
 
@@ -2873,9 +3222,9 @@ function ComposerWave(props: ComposerWaveProps): ReactElement {
       const word = tier === 'unknown' ? 'Into the Unknown' : 'deepseek'
       const start = Math.max(2, Math.floor((props.bandWidth - word.length) / 2))
       const indices = Array.from({ length: word.length }, (_, at) => cellIndexAtColumn(cells, start + at))
-      if (indices.every(index => index !== undefined && (cells[index]!.char === ' ' || cells[index]!.dim === true))) {
+      if (indices.every(index => index !== undefined && (cells[index].char === ' ' || cells[index].dim === true))) {
         for (let at = 0; at < word.length; at += 1) {
-          const cell = cells[indices[at]!]!
+          const cell = cells[indices[at]!]
           cell.char = word[at]!
           cell.width = 1
           cell.color = inkColor(deepseekWaveWordHue(at, hues))
@@ -2887,11 +3236,11 @@ function ComposerWave(props: ComposerWaveProps): ReactElement {
     if (bandRow === middleBandRow && (tier === 'deepseek' || tier === 'unknown') && style === 'wave') {
       const spark = deepseekWaveSpark(tick)
       const lastIndex = cellIndexAtColumn(cells, props.bandWidth - 1)
-      if (spark !== null && lastIndex !== undefined && cells[lastIndex]!.char === ' ') {
-        cells[lastIndex]!.char = spark
-        cells[lastIndex]!.color = props.promptColor
-        cells[lastIndex]!.bold = true
-        cells[lastIndex]!.dim = false
+      if (spark !== null && lastIndex !== undefined && cells[lastIndex].char === ' ') {
+        cells[lastIndex].char = spark
+        cells[lastIndex].color = props.promptColor
+        cells[lastIndex].bold = true
+        cells[lastIndex].dim = false
       }
     }
     return createElement(Text, { key: `editor-${sourceIndex}`, wrap: 'truncate-end' }, ...waveRowSpans(cells))
@@ -2905,16 +3254,110 @@ function ComposerWave(props: ComposerWaveProps): ReactElement {
   )
 }
 
+/**
+ * The /rainbow celebration leaf: a FIXED seven-color ribbon that slides
+ * across the three-row composer band. Same cell model as ComposerWave so
+ * CJK/emoji stay atomic; no wordmark, no sparkles — the spectrum is the
+ * show. Strictly one-shot per burst id (Input latches onSettled).
+ */
+function ComposerRainbowBurst(props: Omit<ComposerWaveProps, 'tier' | 'style'>): ReactElement {
+  const durationMs = RAINBOW_BURST_DURATION_MS
+  const { tick, done } = useWaveFrames(props.active, durationMs)
+  const settledRef = useRef(false)
+  const onSettledRef = useRef(props.onSettled)
+  onSettledRef.current = props.onSettled
+  const settle = (): void => {
+    if (settledRef.current) return
+    settledRef.current = true
+    onSettledRef.current()
+  }
+  useEffect(() => {
+    if (done) settle()
+  }, [done])
+  useEffect(() => () => {
+    settle()
+  }, [])
+  if (!props.active || done || tick * RAINBOW_BURST_TICK_MS >= durationMs) return props.fallback
+  const bandRgb = getPalette().composerBand
+  const totalBandRows = props.rows.length + 2
+  const burstBg = (row: number, column: number): string => {
+    const rgb = rainbowBurstColumnBg(tick, column, props.bandWidth, bandRgb, row, totalBandRows)
+    return rgb === null ? props.bandBg : inkColor(rgb)
+  }
+  const blankBandRow = (row: number): ReactElement => {
+    const blanks: ComposerCell[] = []
+    for (let column = 0; column < props.bandWidth; column += 1) {
+      blanks.push({ char: ' ', width: 1, backgroundColor: burstBg(row, column) })
+    }
+    return createElement(Text, { key: `blank-${row}` }, ...waveRowSpans(blanks))
+  }
+  const editorBurstRows = props.rows.map((row, visibleIndex) => {
+    const sourceIndex = props.windowStart + visibleIndex
+    const bandRow = visibleIndex + 1
+    const parts = editorRowParts(row, sourceIndex, props.caretRow, props.cursor)
+    const placeholder = sourceIndex === 0 && props.value === ''
+    const cells: ComposerCell[] = []
+    let usedColumns = 0
+    const push = (char: string, extra: Omit<ComposerCell, 'char' | 'width' | 'backgroundColor'> = {}): void => {
+      const width = visibleColumns(char)
+      cells.push({ char, width, backgroundColor: burstBg(bandRow, usedColumns), ...extra })
+      usedColumns += width
+    }
+    if (sourceIndex === 0) {
+      push(props.promptGlyph, { color: props.promptColor, bold: true })
+      push(' ', { color: props.promptColor })
+    } else {
+      push(' ')
+      push(' ')
+    }
+    for (const span of splitGraphemes(parts.before)) push(span.text)
+    if (parts.hasCaret) push(parts.caret, { inverse: props.caretVisible })
+    const tail = placeholder ? props.placeholder : parts.after
+    for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {})
+    while (usedColumns < props.bandWidth) push(' ')
+    return createElement(Text, { key: `editor-${sourceIndex}`, wrap: 'truncate-end' }, ...waveRowSpans(cells))
+  })
+  return createElement(
+    Box,
+    { flexDirection: 'column', width: props.bandWidth },
+    blankBandRow(0),
+    ...editorBurstRows,
+    blankBandRow(totalBandRows - 1),
+  )
+}
+
+/** One-word kind label per entry, so the inspector's ←→ walk names what
+ * each step is instead of leaving the reader to infer it from the body. */
+function entryKindLabel(entry: TranscriptEntry | undefined): string {
+  switch (entry?.kind) {
+    case 'user': return 'user prompt'
+    case 'pending': return 'queued prompt'
+    case 'assistant': return 'reply'
+    case 'tool': return 'tool call'
+    case 'command': return 'command'
+    case 'error': return 'turn error'
+    case 'turn-marker': return 'turn end'
+    case 'compaction': return 'compaction'
+    case 'retry': return 'retry'
+    case 'files': return 'files changed'
+    case 'workflow': return 'workflow run'
+    default: return 'empty'
+  }
+}
+
 /**
  * The Ctrl+O transcript inspector: one selected durable entry at a time,
  * with independent history selection and content scrolling. The complete
  * retained entry is converted to physical rows, but only one viewport slice
  * reaches Ink, so even a huge reasoning block cannot grow the dynamic tree.
  */
-function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[]; onClose(): void }): ReactElement {
-  const stdout = useStdout().stdout
-  const columns = stdout?.columns ?? 80
-  const rows = stdout?.rows ?? 30
+function VerbosePanel({ entries, onClose, columns, rows }: {
+  entries: readonly TranscriptEntry[]
+  onClose: () => void
+  /** Live terminal columns from App's resize store — not useStdout, so memo cannot skip a reflow. */
+  columns: number
+  rows: number
+}): ReactElement {
   const viewport = inspectorViewport(columns, rows)
   const [cursor, setCursor] = useState(() => Math.max(0, entries.length - 1))
   const [scroll, setScroll] = useState(0)
@@ -2927,6 +3370,8 @@ function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[
     [entry, viewport.contentColumns],
   )
   const visibleScroll = clampScroll(scroll, allLines.length, viewport.bodyRows)
+  const visibleScrollRef = useRef(visibleScroll)
+  visibleScrollRef.current = visibleScroll
 
   useEffect(() => {
     cursorRef.current = cursor
@@ -2936,7 +3381,7 @@ function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[
     const current = cursorRef.current
     const next = followInspectorCursor(current, previousLength.current, entries.length)
     if (next !== current) {
-      savedScroll.current.set(current, visibleScroll)
+      savedScroll.current.set(current, visibleScrollRef.current)
       setCursor(next)
       setScroll(savedScroll.current.get(next) ?? 0)
     }
@@ -3005,14 +3450,15 @@ function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[
     return createElement(
       Text,
       { wrap: 'truncate-end' },
-      truncateColumns('history details · ctrl+o / esc / q close', viewport.contentColumns),
+      truncateColumns(t('panel.verbose.compact'), viewport.contentColumns),
     )
   }
 
   const title = entries.length === 0
     ? 'history details · empty'
-    : `history details · entry ${cursor + 1}/${entries.length} · lines ${allLines.length === 0 ? 0 : visibleScroll + 1}-${Math.min(allLines.length, visibleScroll + viewport.bodyRows)}/${allLines.length}`
+    : `history details · entry ${cursor + 1}/${entries.length} · ${entryKindLabel(entry)} · lines ${allLines.length === 0 ? 0 : visibleScroll + 1}-${Math.min(allLines.length, visibleScroll + viewport.bodyRows)}/${allLines.length}`
   const visible = allLines.slice(visibleScroll, visibleScroll + viewport.bodyRows)
+  const accent = panelAccent('history-inspector', getPalette().brand)
   return createElement(
     Box,
     {
@@ -3020,11 +3466,11 @@ function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[
       width: viewport.outerColumns,
       paddingX: 1,
       borderStyle: 'round',
-      borderColor: inkColor(getPalette().brand),
+      borderColor: inkColor(accent.border),
     },
     createElement(
       Text,
-      { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' },
+      { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' },
       truncateColumns(title, viewport.contentColumns),
     ),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
@@ -3038,8 +3484,8 @@ function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     createElement(
       Text,
-      { dimColor: true, wrap: 'truncate-end' },
-      dim(truncateColumns('←→ entry · ↑↓ scroll · pgup/pgdn page · g/G ends · ctrl+o/esc/q close', viewport.contentColumns)),
+      { wrap: 'truncate-end' },
+      dim(truncateColumns(t('panel.verbose.footer'), viewport.contentColumns)),
     ),
   )
 }
@@ -3068,6 +3514,16 @@ interface CompletionCandidate {
   origin: 'command' | 'skill' | 'mention'
 }
 
+/**
+ * Wrap one completion-menu cursor step. An empty menu keeps the index at 0:
+ * `% 0` is NaN, and a NaN index silently disables the highlight, the accept
+ * key, and any later Enter that runs through the menu.
+ */
+export function stepCompletionIndex(index: number, delta: number, count: number): number {
+  if (count <= 0) return 0
+  return ((index + delta) % count + count) % count
+}
+
 /**
  * Resolve completion candidates for the current input: TUI-local commands,
  * the live registry descriptors, and user-invocable skills, filtered by the
@@ -3086,7 +3542,7 @@ export function completionCandidates(
 ): readonly CompletionCandidate[] {
   if (!value.startsWith('/')) return []
   const prefix = value.slice(1).split(' ')[0] ?? ''
-  const local: CompletionCandidate[] = LOCAL_COMMANDS.map(command => ({ ...command, origin: 'command' }))
+  const local: CompletionCandidate[] = LOCAL_COMMANDS.map(command => ({ label: command.label, description: t(command.descriptionKey), origin: 'command' }))
   // Local commands shadow registry names (e.g. the TUI-local /permission works
   // before any session exists, while the registry child needs one), so
   // collisions cannot render two rows with the same key.
@@ -3151,10 +3607,10 @@ function completionMenuRowCount(terminalRows: number, rowCount: number): number
 
 /**
  * The completion menu, rendered inside the composer's subtree directly above
- * the composer band — attached the way Claude-Code anchors its dropdown. Opening
- * it grows the stack downward: the composer stays the last element on screen
- * and everything above (the flushed static transcript, the status line) never
- * moves. Props-only (no lifted state): the menu is a pure view of the input
+ * the composer band — attached the way Claude-Code anchors its dropdown.
+ * Its height is deducted from the live transcript budget so the menu covers
+ * live rows instead of growing the tree and moving the composer/status.
+ * Props-only (no lifted state): the menu is a pure view of the input
  * editor's live completion state, so no cross-component effect ever resyncs
  * it (a state lift here previously deadlocked the menu after a resize).
  */
@@ -3212,7 +3668,7 @@ function CompletionMenu({ active, mention, index, rows, error }: {
     // Scroll affordance: with the full merged catalog (commands + registry +
     // skills) the six-row window rarely shows the tail — count and hint keep
     // the rest discoverable without inflating the menu budget.
-    hidden > 0 ? createElement(Text, { key: 'more', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, dim(`  … +${hidden} more`)) : undefined,
+    hidden > 0 ? createElement(Text, { key: 'more', color: inkColor(getPalette().dim), wrap: 'truncate-end' }, `  … +${hidden} more`) : undefined,
     showFooter ? createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, dim(mention ? `↑↓ choose · ${rows.length} items · tab insert` : `↑↓ choose · ${rows.length} items · tab complete`)) : undefined,
   )
 }
@@ -3234,7 +3690,7 @@ interface DraftFile extends FilePathInspection {
  * While a modal (approval / question / model panel) owns the keys, the
  * box passes every key through untouched.
  */
-function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openPlugin, openUpdate, openSchedule, openJobs, openStatusline, openTheme, openHistory, openAgents, openSubagent, openTodos, openDelete, openDiff, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, inspectFiles, prepareFiles, cycleMode, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, animations, applyAnimations, waveTier, waveStyle, maxRows, anchorRowsBelow, tabTitle, onEditorRows, onMenuRows, sessionKey }: {
+function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch, steer, submitMode, cycleSubmitMode, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openSearch, openPlugin, openUpdate, openSchedule, openJobs, openStatusline, openTheme, openLanguage, saveLanguage, openHistory, openQueue, openAgents, openSubagent, openTodos, openUsage, openDelete, openDiff, openReviewPicker, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, inspectFiles, prepareFiles, cycleMode, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, updateQueued, historyFill, historyConsumed, animations, applyAnimations, applyRainbow, rainbowBurstId, waveTier, waveStyle, maxRows, anchorRowsBelow, tabTitle, onEditorRows, onMenuRows, sessionKey }: {
   active: boolean
   frozen: boolean
   /** Frozen-band hint naming the surface that owns the keyboard; an empty
@@ -3243,82 +3699,100 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   busy: boolean
   descriptors: readonly CommandDescriptor[]
   skills: readonly SkillRow[]
-  dispatch(text: string, attachments?: readonly ContentBlock[], origin?: string): void
-  steer(text: string, attachments?: readonly ContentBlock[], origin?: string): void
+  dispatch: (text: string, attachments?: readonly ContentBlock[], origin?: string) => void
+  /** Submit as steering into the running turn (see {@link AppProps.steer}). */
+  steer: (text: string, attachments?: readonly ContentBlock[], origin?: string) => void
+  /** Delivery mode the next submission uses; Tab on an empty composer flips it. */
+  submitMode: 'queue' | 'steer'
+  /** Flip {@link submitMode} and report the new mode. */
+  cycleSubmitMode: () => void
   /** The full current session identity ('' while pending); the delivery origin. */
   sessionKey: string
-  interrupt(): boolean
-  quit(): void
-  openModel(): void
-  openEffort(): void
-  openHelp(): void
-  openMode(): void
-  openPermission(): void
-  openResume(): void
-  openPlugin(query?: string): void
+  interrupt: () => boolean
+  quit: () => void
+  openModel: () => void
+  openEffort: () => void
+  openHelp: () => void
+  openMode: () => void
+  openPermission: () => void
+  openResume: () => void
+  /** Open the /search panel with an optional seed query. */
+  openSearch: (query: string) => void
+  openPlugin: (query?: string) => void
   /** Open the /update panel (aligned upgrade surface). */
-  openUpdate(): void
+  openUpdate: () => void
   /** Open the /schedule reminder panel (read-only catalog). */
-  openSchedule(): void
-  openJobs(): void
-  openStatusline(): void
-  openTheme(): void
-  openHistory(): void
+  openSchedule: () => void
+  openJobs: () => void
+  openStatusline: () => void
+  openTheme: () => void
+  /** Open the /language picker (bare /language). */
+  openLanguage: () => void
+  /** Apply and persist a language chosen by argument. */
+  saveLanguage: (name: LanguageName) => void
+  openHistory: () => void
+  openQueue: () => void
   /** Open the /agents panel (live subagent feed + transcript entry). */
-  openAgents(): void
+  openAgents: () => void
   /** Open the /subagent model panel. */
-  openSubagent(): void
+  openSubagent: () => void
   /** Open the /todos subpage (full todo list in one bounded panel). */
-  openTodos(): void
-  /** Open the /resume picker in delete mode, optionally pre-armed on one id. */
-  openDelete(id?: string): void
-  openDiff(argument: string): void
-  reviewChanges(argument: string): void
+  openTodos: () => void
+  openUsage: () => void
+  /** Open the dedicated /delete picker, optionally pre-armed on one id. */
+  openDelete: (id?: string) => void
+  openDiff: (argument: string) => void
+  reviewChanges: (selection: ReviewSelection) => void
+  /** Open the /review candidate picker (bare /review). */
+  openReviewPicker: () => void
   /** The row id awaiting y/n in this box, when a deletion is pending. */
   deleteConfirm?: string
   /** Confirm the pending deletion (y in the box). */
-  confirmDelete(): void
+  confirmDelete: () => void
   /** Cancel the pending deletion (any other key in the box). */
-  cancelDelete(): void
-  createSession(mode?: string): void
-  forkSession(argument: string): void
-  cancelSessionSwitch(): boolean
-  notify(text: string, tone?: NoticeTone): void
+  cancelDelete: () => void
+  createSession: (mode?: string) => void
+  forkSession: (argument: string) => void
+  cancelSessionSwitch: () => boolean
+  notify: (text: string, tone?: NoticeTone) => void
   /** Apply the Ctrl+R passthrough to the detected editor (/vscode-keys); resolves to a one-line summary. */
-  applyEditorKeys(): Promise<string>
+  applyEditorKeys: () => Promise<string>
   hasNotice: boolean
-  dismissNotice(): void
-  toggleReasoning(): void
-  openVerbose(): void
-  clearView(): void
-  refresh(): void
-  loadMentions(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>
-  inspectImages(paths: readonly string[]): Promise<readonly ImagePathInspection[]>
-  prepareImages(paths: readonly string[], signal?: AbortSignal): Promise<readonly ImageBlock[]>
-  inspectFiles(paths: readonly string[]): Promise<readonly FilePathInspection[]>
-  prepareFiles(paths: readonly string[], signal?: AbortSignal): Promise<readonly FileBlock[]>
-  cycleMode(): string
-  exportTranscript(argument: string): Promise<void>
-  renameTitle(argument: string): string
-  copyLastResponse(): Promise<string>
+  dismissNotice: () => void
+  toggleReasoning: () => void
+  openVerbose: () => void
+  clearView: () => void
+  refresh: () => void
+  loadMentions: (query: string, signal?: AbortSignal) => Promise<readonly MentionCandidate[]>
+  inspectImages: (paths: readonly string[]) => Promise<readonly ImagePathInspection[]>
+  prepareImages: (paths: readonly string[], signal?: AbortSignal) => Promise<readonly ImageBlock[]>
+  inspectFiles: (paths: readonly string[]) => Promise<readonly FilePathInspection[]>
+  prepareFiles: (paths: readonly string[], signal?: AbortSignal) => Promise<readonly FileBlock[]>
+  cycleMode: () => string
+  exportTranscript: (argument: string) => Promise<void>
+  renameTitle: (argument: string) => string
+  copyLastResponse: () => Promise<string>
   /** Newest-first recall space (persistent + in-session, deduped). */
   recallSpace: readonly string[]
   /** Record one in-session submission (deduped, local only). */
-  recordLocal(text: string): void
+  recordLocal: (text: string) => void
   /** Persist one submission to the global history file. */
-  recordHistory(text: string): void
-  /** Live queued inbox rows; Delete on the empty composer cancels the newest. */
-  queued: readonly { messageId: string; target: 'next-turn' | 'next-step'; text: string }[]
-  /** Cancel one queued inbox message by identity. */
-  cancelQueued(messageId: string): void
+  recordHistory: (text: string) => void
+  /** Next-turn inbox rows, ordered exactly as the durable inbox. */
+  queued: readonly Extract<TranscriptEntry, { kind: 'pending' }>[]
+  updateQueued?: (messageId: string, action: QueueMutation) => void
   /** Accepted /history entry waiting to be placed into the composer. */
   historyFill: { text: string; index: number } | undefined
   /** Marks the accepted entry consumed (called after the fill is applied). */
-  historyConsumed(): void
+  historyConsumed: () => void
   /** Whether timed animations run (shimmer, chase, blink, wave). */
   animations: boolean
   /** Apply and report one /animation toggle (App persists through the runner). */
-  applyAnimations(enabled: boolean): void
+  applyAnimations: (enabled: boolean) => void
+  /** Reroll or pin the rainbow palette (switches to rainbow if needed). */
+  applyRainbow: (seed?: number) => void
+  /** Monotonic id of the in-flight /rainbow composer burst; 0 means none. */
+  rainbowBurstId: number
   /** DeepSeek easter-egg wave tier of the applied route (null otherwise):
    * official DeepSeek models drive their flash/pro tiers, non-DeepSeek
    * models running an effort above high drive the "Into the Unknown"
@@ -3337,10 +3811,10 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
    * background process sharing the console cannot keep it overwritten. */
   tabTitle: string
   /** Reports the editor's current physical row count so the live budget stays exact. */
-  onEditorRows(rows: number): void
+  onEditorRows: (rows: number) => void
   /** Reports the open completion menu's physical row count (0 when closed)
    * for the same reason: the dynamic budget must reserve it, not overflow. */
-  onMenuRows(rows: number): void
+  onMenuRows: (rows: number) => void
 }): ReactElement {
   const { stdout: inputStdout } = useStdout()
   const columns = inputStdout?.columns ?? 80
@@ -3393,27 +3867,28 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     preferredColumnRef.current = null
   }, [editorColumns])
 
-  // A /history panel acceptance lands as a fill: place the sanitized text at
-  // the end of the composer and resume recall from that entry.
+  // A /history panel acceptance lands as a fill: append the sanitized text to
+  // the composer and resume recall from that entry. Appending (never
+  // replacing) is what keeps a half-written draft and its prepared
+  // attachments from being destroyed by picking a history entry.
   useEffect(() => {
     if (historyFill === undefined) return
     const safe = sanitizeDraftText(historyFill.text)
-    draftImagesRef.current = []
-    setDraftImages([])
-    draftFilesRef.current = []
-    setDraftFiles([])
-    valueRef.current = safe
-    cursorRef.current = safe.length
-    setValue(safe)
-    setCursor(safe.length)
+    const current = valueRef.current
+    const joined = appendRecall(current, safe)
+    valueRef.current = joined
+    cursorRef.current = joined.length
+    setValue(joined)
+    setCursor(joined.length)
     resetCursorBlink()
     preferredColumnRef.current = null
     setDismissedMenuValue(undefined)
     recall.current = {
       entries: recallSpace,
       index: historyFill.index,
-      savedDraft: safe,
-      lastRecalled: safe,
+      // The draft this fill appended to stays reachable: Down walks back to it.
+      savedDraft: current,
+      lastRecalled: joined,
     }
     historyConsumed()
   }, [historyFill, recallSpace, historyConsumed, resetCursorBlink])
@@ -3443,7 +3918,11 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     if (stdin === undefined) return
     const originalRead = stdin.read.bind(stdin)
     const patchedRead = function patchedRead(this: typeof stdin, ...args: Parameters<typeof originalRead>) {
-      const chunk = originalRead(...args)
+      // `Readable.read` is declared `any`; the assertion names its real result
+      // union once so the normalization and the focus-event stripping below
+      // stay type-checked. Node hands back a Buffer unless an encoding was set,
+      // and null once the stream ends.
+      const chunk = originalRead(...args) as string | Buffer | null
       if (chunk === null) return chunk
       const normalized = normalizeKeyboardChunk(typeof chunk === 'string' ? chunk : String(chunk))
       const input = focusReporting
@@ -3464,9 +3943,9 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     } as typeof stdin.read
     stdin.read = patchedRead
     return () => {
-      stdin.read = originalRead as typeof stdin.read
+      stdin.read = originalRead
     }
-  }, [focusReporting, stdin])
+  }, [focusReporting, inputStdout, stdin])
 
   // Keep the navigation's recall space fresh while browsing state survives
   // (new local submissions extend the space; the index stays valid unless
@@ -3480,7 +3959,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   const [completionIndex, setCompletionIndex] = useState(0)
   const [dismissedMenuValue, setDismissedMenuValue] = useState<string | undefined>(undefined)
   const candidates = completionCandidates(value, descriptors, skills)
-  const slashActive = candidates.length > 0 && value.startsWith('/') && !value.includes(' ') && !value.includes('\n')
+  const slashActive = candidates.length > 0 && value.startsWith('/') && !value.includes(' ') && !value.includes('\n') && !looksLikePathDraft(value)
 
   // @mention token: the last `@word` on the cursor's line before the cursor.
   const beforeCursor = value.slice(0, cursor)
@@ -3519,7 +3998,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
 
   const registerDraftImage = (inspection: ImagePathInspection, marker: string): boolean => {
     if (draftImagesRef.current.some(image => sameImagePath(image.path, inspection.path))) {
-      notify(`${inspection.name} is already attached`, 'warning')
+      notify(t('notice.attachmentAlready', { name: inspection.name }), 'warning')
       return false
     }
     const next = [...draftImagesRef.current, { ...inspection, marker }]
@@ -3538,7 +4017,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     const originalCursor = cursorRef.current
     const total = imagePaths.length + filePaths.length
     if (total === 0) return
-    notify(`checking ${total} attachment${total === 1 ? '' : 's'}…`)
+    notify(t('notice.attachmentsChecking', { count: total, plural: total === 1 ? '' : 's' }))
     void Promise.all([
       imagePaths.length === 0 ? Promise.resolve([]) : inspectImages(imagePaths),
       filePaths.length === 0 ? Promise.resolve([]) : inspectFiles(filePaths),
@@ -3559,13 +4038,13 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         markers.push(marker)
       }
       if (imageAdditions.length === 0 && fileAdditions.length === 0) {
-        notify('those attachments are already attached', 'warning')
+        notify(t('notice.attachmentsAlready'), 'warning')
         return
       }
       const current = valueRef.current
       const anchor = remapStableRange(originalValue, current, { start: originalCursor, end: originalCursor })
       if (anchor === undefined) {
-        notify('draft changed at the attachment drop point; drop the files again', 'warning')
+        notify(t('notice.attachmentDraftChanged'), 'warning')
         return
       }
       const at = anchor.start
@@ -3586,9 +4065,9 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       draftFilesRef.current = nextFiles
       setDraftFiles(nextFiles)
       const count = imageAdditions.length + fileAdditions.length
-      notify(`${count} attachment${count === 1 ? '' : 's'} ready for the next message`)
+      notify(t('notice.attachmentsReady', { count, plural: count === 1 ? '' : 's' }))
     }, (reason: unknown) => {
-      notify(`attachment failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
+      notify(t('notice.attachmentFailed', { message: reason instanceof Error ? reason.message : String(reason) }), 'error')
     })
   }
 
@@ -3596,8 +4075,8 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     const requestId = mentionRequestRef.current + 1
     mentionRequestRef.current = requestId
     if (!active || !mentionActive) {
-      setMentionRows([])
-      setMentionError(undefined)
+      setMentionRows(current => current.length === 0 ? current : [])
+      setMentionError(current => current === undefined ? current : undefined)
       return
     }
     setMentionError(undefined)
@@ -3620,7 +4099,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       clearTimeout(timer)
       controller.abort()
     }
-  }, [active, mentionActive, mentionToken?.query])
+  }, [active, loadMentions, mentionActive, mentionToken?.query])
 
   // Codex routes keys to the topmost surface first. Completion therefore
   // remains available while a turn runs, and Esc dismisses it before the
@@ -3656,6 +4135,23 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   // the App's dynamic budget can reserve it instead of overflowing.
   const menuHeightRows = menuActive ? completionMenuRowCount(inputTerminalRows, menuRows.length) : 0
 
+  /**
+   * What accepting the highlighted completion candidate would insert, or ''
+   * when nothing can be accepted (no rows, or an image row that resolves
+   * asynchronously). The Enter branch uses it to tell a real accept from a
+   * no-op that must fall through to submission.
+   */
+  const highlightedCompletion = (): string => {
+    if (mentionActive) {
+      const row = rankedMentionRows[completionIndex % Math.max(1, rankedMentionRows.length)]
+      if (row === undefined) return ''
+      if (row.kind === 'file' && row.path !== undefined && looksLikeImagePath(row.path)) return ''
+      return row.label.startsWith('@') ? row.label : `@${row.label}${row.kind === 'directory' ? '/' : ''}`
+    }
+    const candidate = candidates[completionIndex % Math.max(1, candidates.length)]
+    return candidate === undefined ? '' : `${candidate.label} `
+  }
+
   /** Accept the highlighted completion-menu candidate into the draft. */
   const acceptMenuCandidate = (): void => {
     if (mentionActive && mentionToken !== undefined) {
@@ -3673,7 +4169,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
             const current = valueRef.current
             const anchor = remapStableRange(originalValue, current, { start, end: start + tokenText.length })
             if (anchor === undefined || current.slice(anchor.start, anchor.end) !== tokenText) {
-              notify('draft changed around the image mention; select it again', 'warning')
+              notify(t('notice.imageDraftChanged'), 'warning')
               return
             }
             if (draftImagesRef.current.some(image => sameImagePath(image.path, inspection.path))) {
@@ -3684,7 +4180,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
               setCursor(edit.cursor)
               resetCursorBlink()
               setDismissedMenuValue(edit.value)
-              notify(`${inspection.name} is already attached`, 'warning')
+              notify(t('notice.attachmentAlready', { name: inspection.name }), 'warning')
               return
             }
             const marker = uniqueImageMarker(inspection.name, 'mention')
@@ -3696,9 +4192,9 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
             resetCursorBlink()
             setDismissedMenuValue(edit.value)
             registerDraftImage(inspection, marker)
-            notify(`${inspection.name} ready for the next message`)
+            notify(t('notice.imageReady', { name: inspection.name }))
           }, (reason: unknown) => {
-            notify(`image attachment failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
+            notify(t('notice.imageFailed', { message: reason instanceof Error ? reason.message : String(reason) }), 'error')
           })
           setCompletionIndex(0)
           setDismissedMenuValue(undefined)
@@ -3745,6 +4241,18 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     preferredColumnRef.current = null
     setCompletionIndex(0)
     setDismissedMenuValue(undefined)
+    // A file drag (any OS / terminal) often writes the path without
+    // bracketed-paste wrappers, so it lands as ordinary insert. If the whole
+    // draft is one drop path, attach it the same way a copied pathname paste
+    // would.
+    const dropped = parsePastedAttachmentPaths(edit.value)
+    if (dropped.images.length > 0 || dropped.files.length > 0) {
+      valueRef.current = ''
+      cursorRef.current = 0
+      setValue('')
+      setCursor(0)
+      insertDroppedAttachments(dropped.images, dropped.files)
+    }
   }
 
   /** Move the cursor without editing; horizontal moves clear the column preference. */
@@ -3802,7 +4310,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     prepareAbortRef.current = undefined
     setPreparingImages(false)
     dismissNotice()
-    notify('image submission cancelled', 'warning')
+    notify(t('notice.imageCancelled'), 'warning')
   }
 
   /** Cross history while an unchanged recalled draft rests its caret on
@@ -3877,10 +4385,18 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         const label = cycleMode()
         if (label !== '') notify(label)
       } catch (error: unknown) {
-        notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+        notify(t('notice.permissionChangeFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
       }
       return
     }
+    // Tab on an EMPTY composer picks how the next submission is delivered:
+    // queue for the next turn, or steer into the turn already running. With a
+    // draft present Tab stays the completion key (handled with the menu
+    // below), so this only claims the keypress when nothing is being typed.
+    if (key.tab && liveValue === '' && !menuActive) {
+      cycleSubmitMode()
+      return
+    }
     // Ctrl+R toggles the thinking display (Claude-Code reasoning fold).
     // Alt+R is the zero-config alias: VS Code never intercepts Alt chords,
     // so the toggle stays reachable before /vscode-keys has been applied.
@@ -3926,7 +4442,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         applyEdit(deleteForward(liveValue, liveCursor))
         return
       }
-      if (busy) notify('cancel the running turn before exiting (Esc or Ctrl+C)', 'warning')
+      if (busy) notify(t('notice.cancelBeforeExit'), 'warning')
       else quit()
       return
     }
@@ -3952,7 +4468,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       const forwardDelete = rawEditorTokens.current?.some(token =>
         token.kind === 'delete-forward' || token.kind === 'delete-word-forward') === true
       if (forwardDelete) {
-        cancelQueued(queued[queued.length - 1]!.messageId)
+        updateQueued?.(queued[queued.length - 1].messageId, { kind: 'remove' })
         return
       }
     }
@@ -3968,8 +4484,19 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       // exactly, in which case Enter submits it (typing a full "/effort" and
       // pressing return must run the command, not re-accept its own text).
       if (menuActive) {
+        // Accepting can be a no-op: the menu is open with no matches yet, the
+        // slash line already spells its candidate, or a mention insertion
+        // repeats the token already in the draft. Enter must reach the submit
+        // path in every one of those cases, or the message cannot be sent.
+        const highlighted = highlightedCompletion()
+        const repeatsToken = mentionActive && mentionToken !== undefined && cursor === liveValue.length
+          && liveValue.slice(mentionToken.start, cursor) === highlighted
+        // The slash rule is a whole-list exact match, not a highlighted-row
+        // comparison: typing `/mode` once the list is open must run the
+        // command even when the highlight happens to rest on `/model`.
         const exactSlash = !mentionActive && candidates.some(candidate => candidate.label === liveValue)
-        if (!exactSlash) {
+        const acceptNoop = highlighted === '' || repeatsToken || exactSlash
+        if (!acceptNoop) {
           acceptMenuCandidate()
           return
         }
@@ -3984,7 +4511,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         // Slash semantics with attachments are unchanged: commands cannot
         // carry attachments, so the line goes to the model as a prompt —
         // warn instead of surprising the user with a literal "/export".
-        if (isSlashLine(text)) notify('commands cannot carry attachments; the line will be sent to the model as a prompt', 'warning')
+        if (isSlashLine(text)) notify(t('notice.commandAttachments'), 'warning')
         // Attachment prepares resolve asynchronously; the app remounts onto
         // another session in the meantime, and this (old) instance's unmount
         // cleanup runs too late on the microtask timeline. Tag the delivery
@@ -4023,7 +4550,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
           }
           recall.current = beginRecall(recallSpace, '')
           const blocks: readonly ContentBlock[] = [...images, ...files]
-          if (busy) steer(text, blocks, originSession)
+          if (submitMode === 'steer') steer(text, blocks, originSession)
           else dispatch(text, blocks, originSession)
         }, (reason: unknown) => {
           if (controller.signal.aborted || prepareEpochRef.current !== epoch) return
@@ -4083,7 +4610,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       if (text === '/copy') {
         void copyLastResponse().then(
           outcome => notify(outcome),
-          error => notify(`copy failed: ${error instanceof Error ? error.message : String(error)}`, 'error'),
+          error => notify(t('notice.copyFailed', { message: error instanceof Error ? error.message : String(error) }), 'error'),
         )
         return
       }
@@ -4092,7 +4619,16 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         return
       }
       if (text === '/review' || text.startsWith('/review ')) {
-        reviewChanges(text.slice(7))
+        const argument = text.slice(7).trim()
+        if (argument === '') {
+          openReviewPicker()
+          return
+        }
+        try {
+          reviewChanges(parseReviewArgument(argument))
+        } catch (error: unknown) {
+          notify(error instanceof Error ? error.message : String(error), 'warning')
+        }
         return
       }
       if (text === '/model' || text.startsWith('/model ')) {
@@ -4127,6 +4663,10 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         else dispatch(text)
         return
       }
+      if (text === '/search' || text.startsWith('/search ')) {
+        openSearch(text.slice(7).trim())
+        return
+      }
       if (text === '/new' || text.startsWith('/new ')) {
         createSession(text.slice(4).trim() || undefined)
         return
@@ -4159,17 +4699,41 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         openTheme()
         return
       }
+      if (text === '/language' || text.startsWith('/language ')) {
+        const argument = text.slice('/language'.length).trim()
+        if (argument === '') openLanguage()
+        else if (argument === 'en' || argument === 'zh') {
+          saveLanguage(parseLanguageName(argument))
+          notify(t('notice.languageSaved', { name: argument }))
+          refresh()
+        } else notify(t('notice.usage.language'), 'warning')
+        return
+      }
       if (text === '/animation' || text.startsWith('/animation ')) {
         const parsed = parseAnimationsArgument(text.slice('/animation'.length))
         if (parsed === 'toggle') applyAnimations(!animations)
-        else if (parsed === 'usage') notify('usage: /animation [on|off]', 'info')
+        else if (parsed === 'usage') notify(t('notice.usage.animation'), 'info')
         else applyAnimations(parsed.enabled)
         return
       }
+      if (text === '/rainbow' || text.startsWith('/rainbow ')) {
+        const parsed = parseRainbowArgument(text.slice('/rainbow'.length))
+        if (parsed === 'usage') notify(t('notice.usage.rainbow'), 'warning')
+        else applyRainbow(parsed === 'random' ? undefined : parsed.seed)
+        return
+      }
       if (text === '/history') {
         openHistory()
         return
       }
+      if (text === '/queue') {
+        openQueue()
+        return
+      }
+      if (text === '/usage') {
+        openUsage()
+        return
+      }
       if (text === '/agents') {
         openAgents()
         return
@@ -4193,19 +4757,30 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         openDelete(text.slice(7).trim())
         return
       }
-      if (busy && !text.startsWith('/')) {
-        // A running turn is steered, not blocked: the inbox delivers this
-        // text at the next step boundary (Esc/Ctrl+C still cancels outright).
-        // Slash lines keep the registry path — commands run out of band.
-        steer(text)
+      const slash = slashNameAndArgs(text)
+      if (slash !== undefined && BARE_LOCAL_COMMANDS.has(slash.name) && slash.args !== '') {
+        notify(t('notice.usage.bareCommand', { name: slash.name }), 'warning')
         return
       }
-      dispatch(text)
+      // Delivery mode: everything above this point is a local command or a
+      // panel opener and always runs out of band. A real prompt follows the
+      // composer's Tab choice — `steer` joins the running turn, the default
+      // queues it for the next one.
+      if (submitMode === 'steer') steer(text)
+      else dispatch(text)
+      return
+    }
+    // The modified-Enter newline family: Ctrl+J arrives as a bare LF (Ink
+    // names it 'enter', not 'return'), and the kitty layer normalizes
+    // Ctrl/Shift+Enter to the same byte. Alt+Enter reaches here as a bare CR
+    // with no flags — Ink's parser drops the escape and reports no meta, and
+    // plain Enter always carries key.return — so a flagless CR is Alt+Enter.
+    // Only plain Enter submits. app.spec's "modified-Enter family" test pins
+    // this exact parser shape; an Ink upgrade that changes it fails there.
+    if (input === '\n' || input === '\r') {
+      applyEdit(insertText(liveValue, liveCursor, '\n'))
       return
     }
-    // Ink exposes Ctrl+J as a bare LF and Alt+Enter as a bare CR after
-    // stripping the leading escape. Neither is a multiline shortcut.
-    if (input === '\n' || input === '\r') return
     // A fast Tab followed by text can arrive as one readable chunk in an
     // integrated terminal. Accept the candidate first, then apply the
     // remaining characters against the synchronously updated editor refs.
@@ -4216,11 +4791,11 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       return
     }
     if (menuActive && key.upArrow) {
-      setCompletionIndex(index => (index + menuRows.length - 1) % menuRows.length)
+      setCompletionIndex(index => stepCompletionIndex(index, -1, menuRows.length))
       return
     }
     if (menuActive && key.downArrow) {
-      setCompletionIndex(index => (index + 1) % menuRows.length)
+      setCompletionIndex(index => stepCompletionIndex(index, 1, menuRows.length))
       return
     }
     // Batched Home/End/Delete/Backspace sequences bypass Ink's one-key parser
@@ -4313,10 +4888,13 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       return
     }
     if (input !== '' && !key.ctrl && !key.meta) {
-      // Bracketed-paste wrappers arrive as unknown escape sequences stripped
-      // of their ESC. Markers may ride their own chunk or the edges of a
-      // content chunk; strip every occurrence and track the open-paste flag
-      // so a chunk that is exactly LF inserts instead of submitting.
+      // Bracketed-paste wrappers arrive as escape sequences Ink has stripped
+      // only ONE leading ESC from, so the tail marker still carries its own:
+      // strip both spellings before the payload is read, or a dragged path
+      // reaches the attachment parser with a trailing control byte and fails.
+      // Markers may ride their own chunk or the edges of a content chunk; the
+      // open-paste flag is tracked so a chunk that is exactly LF inserts
+      // instead of submitting.
       let text = input
       if (text.includes(PASTE_START_MARKER)) {
         pasteBracketRef.current = true
@@ -4331,13 +4909,12 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
           clearTimeout(timer)
           pasteBracketCancelRef.current = undefined
         }
-        text = text.replaceAll(PASTE_START_MARKER, '')
       }
       if (text.includes(PASTE_END_MARKER)) {
         pasteBracketRef.current = false
         pasteBracketCancelRef.current?.()
-        text = text.replaceAll(PASTE_END_MARKER, '')
       }
+      text = stripPasteMarkers(text)
       if (text === '') return
       if (text.length > 1) {
         // A path-list paste splits into images and files; prose falls through
@@ -4377,13 +4954,23 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     if (!animations && waveKey !== null && waveKey !== wavePlayedKey) setWavePlayedKey(waveKey)
   }, [animations, waveKey, wavePlayedKey])
   const waveArmed = waveKey !== null && waveKey !== wavePlayedKey
+  const burstKey = rainbowBurstId > 0 ? `rainbow:${rainbowBurstId}` : null
+  const [burstPlayedKey, setBurstPlayedKey] = useState<string | null>(null)
+  useEffect(() => {
+    if (!animations && burstKey !== null && burstKey !== burstPlayedKey) setBurstPlayedKey(burstKey)
+  }, [animations, burstKey, burstPlayedKey])
+  const burstArmed = burstKey !== null && burstKey !== burstPlayedKey
 
   // Every exclusive panel keeps the composer as a stable visual anchor, but
   // freezes it to one row: no menu, multiline wrap, or animation.
   const tierActive = waveTier !== null
   const tierHues = waveTier === null ? null : deepseekWaveHues(waveTier)
   const promptColor = tierHues === null ? inkColor(getPalette().brand) : inkColor(tierHues[0])
-  const promptGlyph = waveTier === 'flash' ? '›' : waveTier === 'deepseek' ? '»' : '❯'
+  const waveGlyph = waveTier === 'flash' ? '›' : waveTier === 'deepseek' ? '»' : '❯'
+  // Steer mode owns the prompt glyph in every paint path (static band, wave,
+  // rainbow burst), so the mode is visible without reading the placeholder.
+  const promptGlyph = submitMode === 'steer' ? '↳' : waveGlyph
+  const placeholderText = composerPlaceholder(submitMode)
   // The multiline editor model: the sanitized draft hard-wrapped into
   // column-safe physical rows, with the caret mapped to its exact row and
   // column. Computed before the frozen path so the row report below runs
@@ -4421,7 +5008,9 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   // the reserve from outliving the menu (unmount or inactive handoff).
   useEffect(() => {
     onMenuRows(menuHeightRows)
-    return () => onMenuRows(0)
+    return () => {
+      if (menuHeightRows !== 0) onMenuRows(0)
+    }
   }, [menuHeightRows, onMenuRows])
   // The composer band: the old border's three-row footprint repainted as a
   // background-color band (the Codex-style shaded composer strip) — one
@@ -4457,7 +5046,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     return band(createElement(
       Text,
       { backgroundColor: bandBg, wrap: 'truncate-end' },
-      createElement(Text, { color: promptColor, bold: tierActive ? true : undefined }, busy ? '… ' : `${promptGlyph} `),
+      createElement(Text, { color: promptColor, bold: tierActive ? true : undefined }, submitMode === 'steer' ? '↳ ' : busy ? '… ' : `${promptGlyph} `),
       frozenLine,
       bandFill(2 + visibleColumns(frozenLine)),
     ))
@@ -4475,10 +5064,10 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   // spacer or a second blink timer.
   const editorRows: ReactElement[] = []
   for (let index = editorWindowStart; index < Math.min(editorViewModel.rows.length, editorWindowStart + editorWindowRows); index += 1) {
-    const row = editorViewModel.rows[index]!
+    const row = editorViewModel.rows[index]
     const parts = editorRowParts(row, index, caret.row, clampedCursor, !preparingImages)
     const placeholder = index === 0 && value === '' && !busy && !preparingImages
-    const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after
+    const tail = placeholder ? placeholderText : parts.after
     const consumed = 2 + visibleColumns(parts.before) + visibleColumns(parts.caret) + visibleColumns(tail)
     editorRows.push(createElement(
       Text,
@@ -4486,16 +5075,18 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       index === 0
         ? preparingImages
           ? createElement(Text, { color: inkColor(getPalette().warn), bold: true }, '… ')
-          : busy
-            ? createElement(BusyChase, { animated: animations })
-            : createElement(Text, { color: promptColor, bold: tierActive ? true : undefined }, `${promptGlyph} `)
+          : submitMode === 'steer'
+            ? createElement(Text, { color: promptColor, bold: true }, '↳ ')
+            : busy
+              ? createElement(BusyChase, { animated: animations })
+              : createElement(Text, { color: promptColor, bold: tierActive ? true : undefined }, `${promptGlyph} `)
         : '  ',
       parts.before,
       parts.hasCaret
         ? createElement(Text, { key: 'caret', inverse: cursorVisible || undefined }, parts.caret)
         : null,
       placeholder
-        ? createElement(Text, { dimColor: true }, COMPOSER_PLACEHOLDER)
+        ? createElement(Text, { dimColor: true }, tail)
         : parts.after,
       bandFill(consumed),
     ))
@@ -4511,26 +5102,47 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     Box,
     { flexDirection: 'column' },
     menu,
-    createElement(ComposerWave, {
-      key: waveKey ?? 'static',
-      tier: waveTier ?? 'deepseek',
-      style: waveStyle ?? 'wave',
-      active: waveTier !== null && waveStyle !== null && !busy && !preparingImages && animations && waveArmed,
-      onSettled: () => {
-        if (waveKey !== null) setWavePlayedKey(waveKey)
-      },
-      fallback: band(staticEditor),
-      bandWidth,
-      bandBg,
-      rows: editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows),
-      windowStart: editorWindowStart,
-      caretRow: caret.row,
-      cursor: clampedCursor,
-      caretVisible: cursorVisible,
-      value,
-      promptGlyph,
-      promptColor,
-    }),
+    burstArmed
+      ? createElement(ComposerRainbowBurst, {
+        key: burstKey,
+        active: !busy && !preparingImages && animations,
+        onSettled: () => {
+          if (burstKey !== null) setBurstPlayedKey(burstKey)
+        },
+        fallback: band(staticEditor),
+        bandWidth,
+        bandBg,
+        rows: editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows),
+        windowStart: editorWindowStart,
+        caretRow: caret.row,
+        cursor: clampedCursor,
+        caretVisible: cursorVisible,
+        value,
+        promptGlyph,
+        placeholder: placeholderText,
+        promptColor,
+      })
+      : createElement(ComposerWave, {
+        key: waveKey ?? 'static',
+        tier: waveTier ?? 'deepseek',
+        style: waveStyle ?? 'wave',
+        active: waveTier !== null && waveStyle !== null && !busy && !preparingImages && animations && waveArmed,
+        onSettled: () => {
+          if (waveKey !== null) setWavePlayedKey(waveKey)
+        },
+        fallback: band(staticEditor),
+        bandWidth,
+        bandBg,
+        rows: editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows),
+        windowStart: editorWindowStart,
+        caretRow: caret.row,
+        cursor: clampedCursor,
+        caretVisible: cursorVisible,
+        value,
+        promptGlyph,
+        placeholder: placeholderText,
+        promptColor,
+      }),
   )
 }
 
@@ -4755,7 +5367,13 @@ export function computeSettledRows(
 
 /** The whole terminal app; state arrives via the store, output via Ink. */
 export function App(props: AppProps): ReactElement {
-  const view = useSyncExternalStore(props.store.subscribe, props.store.getView)
+  // The stores are closure-backed singletons whose methods never touch `this`,
+  // but a bare method reference still detaches it from its receiver. One stable
+  // wrapper per store keeps both the receiver and the reference identity the
+  // `useSyncExternalStore` contract requires.
+  const subscribeTranscript = useCallback((listener: () => void) => props.store.subscribe(listener), [props.store])
+  const readTranscript = useCallback(() => props.store.getView(), [props.store])
+  const view = useSyncExternalStore(subscribeTranscript, readTranscript)
   // Terminal input anchor: Ink reference-counts raw mode across every active
   // `useInput` hook, so mutually exclusive surfaces (composer <-> approval
   // bar <-> panels) drop the count to zero inside each handoff commit — the
@@ -4777,8 +5395,10 @@ export function App(props: AppProps): ReactElement {
   // process-stable, so one callback per view identity is enough.
   const readDescriptors = useCallback(() => props.commands.descriptors, [props.commands])
   const readSkills = useCallback(() => props.skills.rows, [props.skills])
-  const descriptors = useSyncExternalStore(props.commands.subscribe, readDescriptors)
-  const skills = useSyncExternalStore(props.skills.subscribe, readSkills)
+  const subscribeCommands = useCallback((listener: () => void) => props.commands.subscribe(listener), [props.commands])
+  const subscribeSkills = useCallback((listener: () => void) => props.skills.subscribe(listener), [props.skills])
+  const descriptors = useSyncExternalStore(subscribeCommands, readDescriptors)
+  const skills = useSyncExternalStore(subscribeSkills, readSkills)
   const [modelLabel, setModelLabel] = useState(props.model)
   const [modelOpen, setModelOpen] = useState(false)
   /** Nested /model stages; only one owns terminal input at a time. */
@@ -4807,13 +5427,17 @@ export function App(props: AppProps): ReactElement {
    * (ordinary turns, image preparation, /animation toggles) never replays. */
   const [waveTier, setWaveTier] = useState<DeepseekWaveTier | null>(null)
   const [waveStyle, setWaveStyle] = useState<DeepseekWaveStyle | null>(null)
+  const [rainbowBurstId, setRainbowBurstId] = useState(0)
+  const fireRainbowBurst = (): void => {
+    setRainbowBurstId(id => id + 1)
+  }
   // /animation toggle: applies immediately, persists through the runner, and
   // gates every timed leaf (shimmer, chase, blink, wave) for this render.
   const [animations, setAnimations] = useState(props.animations ?? true)
   const applyAnimations = (enabled: boolean): void => {
     setAnimations(enabled)
     props.saveAnimations?.(enabled)
-    notify(`animations ${enabled ? 'on' : 'off'}`)
+    notify(t('notice.animationState', { state: enabled ? 'on' : 'off' }))
   }
   const previousModel = useRef<string | undefined>(undefined)
   const previousEffort = useRef<string | undefined>(props.effort)
@@ -4851,14 +5475,22 @@ export function App(props: AppProps): ReactElement {
   const [authorizationDirectory, setAuthorizationDirectory] = useState<ProviderAuthorizationDirectory | undefined>(undefined)
   const [authorizationError, setAuthorizationError] = useState<string | undefined>(undefined)
   const [modelLoadEpoch, setModelLoadEpoch] = useState(0)
+  /** Bumped when /effort's catalog lookup must be ignored (panel closed or superseded). */
+  const effortLookupEpoch = useRef(0)
   const [notice, setNotice] = useState<{ text: string; tone: NoticeTone } | undefined>(undefined)
   const notify = useCallback((text: string, tone: NoticeTone = 'info'): void => {
     setNotice({ text, tone })
   }, [])
 
+  const {
+    loadModels,
+    loadModelProviders,
+    loadProviderAuthorizations,
+    onBridgeReady,
+  } = props
   useEffect(() => {
-    props.onBridgeReady({ notify })
-  }, [])
+    onBridgeReady({ notify })
+  }, [notify, onBridgeReady])
   useEffect(() => {
     if (!modelOpen) return
     let cancelled = false
@@ -4867,7 +5499,7 @@ export function App(props: AppProps): ReactElement {
     // Enter the promise chain before invoking the loader so a provider that
     // throws synchronously becomes an in-panel error instead of escaping the
     // React effect and tearing down Ink.
-    Promise.resolve().then(() => props.loadModels()).then((loaded) => {
+    Promise.resolve().then(() => loadModels()).then((loaded) => {
       if (!cancelled) setDirectory(loaded)
     }, (error: unknown) => {
       if (!cancelled) setModelError(error instanceof Error ? error.message : String(error))
@@ -4875,13 +5507,13 @@ export function App(props: AppProps): ReactElement {
     return () => {
       cancelled = true
     }
-  }, [modelOpen, modelLoadEpoch, props.loadModels])
+  }, [loadModels, modelOpen, modelLoadEpoch])
   useEffect(() => {
-    if (!modelOpen || props.loadModelProviders === undefined) return
+    if (!modelOpen || loadModelProviders === undefined) return
     let cancelled = false
     setProviderDirectory(undefined)
     setProviderError(undefined)
-    Promise.resolve().then(() => props.loadModelProviders!()).then((loaded) => {
+    Promise.resolve().then(() => loadModelProviders()).then((loaded) => {
       if (!cancelled) setProviderDirectory(loaded)
     }, (error: unknown) => {
       if (!cancelled) setProviderError(error instanceof Error ? error.message : String(error))
@@ -4889,13 +5521,13 @@ export function App(props: AppProps): ReactElement {
     return () => {
       cancelled = true
     }
-  }, [modelOpen, modelLoadEpoch, props.loadModelProviders])
+  }, [loadModelProviders, modelOpen, modelLoadEpoch])
   useEffect(() => {
-    if (!modelOpen || props.loadProviderAuthorizations === undefined) return
+    if (!modelOpen || loadProviderAuthorizations === undefined) return
     let cancelled = false
     setAuthorizationDirectory(undefined)
     setAuthorizationError(undefined)
-    Promise.resolve().then(() => props.loadProviderAuthorizations!()).then((loaded) => {
+    Promise.resolve().then(() => loadProviderAuthorizations()).then((loaded) => {
       if (!cancelled) setAuthorizationDirectory(loaded)
     }, (error: unknown) => {
       if (!cancelled) setAuthorizationError(error instanceof Error ? error.message : String(error))
@@ -4903,7 +5535,7 @@ export function App(props: AppProps): ReactElement {
     return () => {
       cancelled = true
     }
-  }, [modelOpen, modelLoadEpoch, props.loadProviderAuthorizations])
+  }, [loadProviderAuthorizations, modelOpen, modelLoadEpoch])
   useEffect(() => {
     const subscribe = props.subscribeModelProviders
     if (!modelOpen || subscribe === undefined) return
@@ -4928,24 +5560,39 @@ export function App(props: AppProps): ReactElement {
   // Dedupe for the dynamic-budget tripwire: one warning per distinct shape.
   const budgetWarnRef = useRef<string | undefined>(undefined)
   const [verboseOpen, setVerboseOpen] = useState(false)
+  const [queueOpen, setQueueOpen] = useState(false)
+  /**
+   * How the composer delivers its next submission: `queue` waits for the next
+   * turn, `steer` joins the turn already running. Tab on an empty composer
+   * flips it; the prompt glyph and the placeholder both name the current mode.
+   */
+  const [submitMode, setSubmitMode] = useState<'queue' | 'steer'>('queue')
   const [diffView, setDiffView] = useState<GitDiffView | undefined>(undefined)
+  const [reviewPickerOpen, setReviewPickerOpen] = useState(false)
   const [helpOpen, setHelpOpen] = useState(false)
   const [modeOpen, setModeOpen] = useState(false)
   const [permissionOpen, setPermissionOpen] = useState(false)
   const [resumeOpen, setResumeOpen] = useState(false)
+  const [searchOpen, setSearchOpen] = useState(false)
+  /** /search seed: the query from `/search <text>` (cleared on open). */
+  const [searchSeed, setSearchSeed] = useState('')
   const [pluginOpen, setPluginOpen] = useState(false)
   const [pluginQuery, setPluginQuery] = useState('')
   const [updateOpen, setUpdateOpen] = useState(false)
+  const [updateApplying, setUpdateApplying] = useState(false)
+  useEffect(() => subscribeUpdateApplyRunning(setUpdateApplying), [])
   const [scheduleOpen, setScheduleOpen] = useState(false)
   const [jobsOpen, setJobsOpen] = useState(false)
   const [statuslineOpen, setStatuslineOpen] = useState(false)
   const [statuslineItems, setStatuslineItems] = useState<readonly StatusItemId[]>(() => parseStatuslineItems(props.statusline))
   const [themeOpen, setThemeOpen] = useState(false)
+  const [languageOpen, setLanguageOpen] = useState(false)
   const [historyOpen, setHistoryOpen] = useState(false)
   const [agentsOpen, setAgentsOpen] = useState(false)
   const [subagentOpen, setSubagentOpen] = useState(false)
   const [todosOpen, setTodosOpen] = useState(false)
-  /** /delete state: delete-mode hint plus an optional pre-armed row id. */
+  const [usageOpen, setUsageOpen] = useState(false)
+  /** /delete state: dedicated picker mode plus an optional pre-armed row id. */
   const [resumeDelete, setResumeDelete] = useState<{ mode: boolean; id?: string }>({ mode: false })
   /** The row id awaiting y/n in the COMPOSER (codex delete confirm): the
    * composer takes the keys, the resume panel yields until it settles. */
@@ -4958,19 +5605,20 @@ export function App(props: AppProps): ReactElement {
   const cancelDelete = useCallback((): void => {
     setDeleteConfirmId(undefined)
   }, [])
+  const deleteSession = props.deleteSession
   const confirmDelete = useCallback((): void => {
     const id = deleteConfirmId
     if (id === undefined) return
     setDeleteConfirmId(undefined)
-    void props.deleteSession(id).then(outcome => {
+    void deleteSession(id).then(outcome => {
       notify(outcome)
       // Keep the picker open and reload: a successful deletion must vanish
       // from the list immediately, not look like a no-op.
       setDeleteReloadToken(token => token + 1)
     }, (reason: unknown) => {
-      notify(`delete failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
+      notify(t('notice.deleteFailed', { message: reason instanceof Error ? reason.message : String(reason) }), 'error')
     })
-  }, [deleteConfirmId, props.deleteSession, notify])
+  }, [deleteSession, deleteConfirmId, notify])
   /** The /history panel's accepted entry: text plus its recall-space index. */
   const [historyFill, setHistoryFill] = useState<{ text: string; index: number } | undefined>(undefined)
   /** Submissions recorded in this process (Codex local history; persistent file stays in the runner). */
@@ -4988,60 +5636,90 @@ export function App(props: AppProps): ReactElement {
   }, [])
   /** The append-only flush boundary (see `settledEntryCount`): entries below
    * this index are final and ride the `<Static>` scrollback; everything at or
-   * beyond stays in the live tree. Pending inbox rows always live at
-   * index >= settled, so the queued-inbox scan below only walks the mutable
-   * tail instead of the whole history. */
+   * beyond stays in the live tree. */
   const settled = useMemo(() => settledEntryCount(view.entries), [view.entries])
-  /** Live queued inbox rows (event-sourced from `agent/inbox/spliced`). The
-   * projection only appends and removes pending rows at index >= settled, so
-   * a bounded tail scan replaces an unconditional O(history) filter on every
-   * event. */
-  const queuedRows = useMemo(() => {
-    const rows: Array<Extract<TranscriptEntry, { kind: 'pending' }>> = []
-    for (let index = settled; index < view.entries.length; index++) {
-      const entry = view.entries[index]
-      if (entry.kind === 'pending') rows.push(entry)
-    }
-    return rows
-  }, [view.entries, settled])
+  /** Next-turn rows in durable inbox order: a running tool row can split the
+   * pending rows, so this maps the inbox id list onto the folded entries
+   * instead of scanning the mutable tail. */
+  const queuedRows = useMemo(
+    () => queuedInboxRows(view.entries, view.pending['next-turn']),
+    [view.entries, view.pending],
+  )
   const [refreshEpoch, setRefreshEpoch] = useState(0)
-  const approvalSnapshot = useSyncExternalStore(props.approval.subscribe, props.approval.getSnapshot)
-  const questionSnapshot = useSyncExternalStore(props.questions.subscribe, props.questions.getSnapshot)
-  const agentRows = useSyncExternalStore(props.subagents.subscribe, props.subagents.getSnapshot)
+  const subscribeApproval = useCallback((listener: () => void) => props.approval.subscribe(listener), [props.approval])
+  const readApprovalSnapshot = useCallback(() => props.approval.getSnapshot(), [props.approval])
+  const subscribeQuestions = useCallback((listener: () => void) => props.questions.subscribe(listener), [props.questions])
+  const readQuestionSnapshot = useCallback(() => props.questions.getSnapshot(), [props.questions])
+  const subscribeSubagents = useCallback((listener: () => void) => props.subagents.subscribe(listener), [props.subagents])
+  const readAgentRows = useCallback(() => props.subagents.getSnapshot(), [props.subagents])
+  const approvalSnapshot = useSyncExternalStore(subscribeApproval, readApprovalSnapshot)
+  const questionSnapshot = useSyncExternalStore(subscribeQuestions, readQuestionSnapshot)
+  const agentRows = useSyncExternalStore(subscribeSubagents, readAgentRows)
   const approvalPending = approvalSnapshot.pending !== undefined
   const questionPending = questionSnapshot.pending !== undefined
-  // While any modal owns the keys, the prompt box passes everything through.
+  /**
+   * Every keyboard-owning surface that is mutually exclusive with the composer,
+   * in precedence order. This ONE list drives the composer gate, the transcript
+   * visibility, the frozen band's hint, and the hand-off when a human approval
+   * or question arrives, so a panel cannot be wired into one of them and
+   * forgotten in the others.
+   */
+  const panelSurfaces: readonly { readonly hint: string; readonly open: boolean; readonly close: () => void }[] = [
+    { hint: 'the diff review', open: diffView !== undefined, close: () => setDiffView(undefined) },
+    { hint: 'the review picker', open: reviewPickerOpen, close: () => setReviewPickerOpen(false) },
+    {
+      hint: '/model',
+      open: modelOpen,
+      close: () => {
+        setModelOpen(false)
+        setProviderOpen(false)
+        setProviderAction(undefined)
+        setEffortFor(undefined)
+      },
+    },
+    { hint: '/help', open: helpOpen, close: () => setHelpOpen(false) },
+    { hint: '/mode', open: modeOpen, close: () => setModeOpen(false) },
+    { hint: '/permission', open: permissionOpen, close: () => setPermissionOpen(false) },
+    { hint: '/resume', open: resumeOpen, close: () => setResumeOpen(false) },
+    { hint: '/search', open: searchOpen, close: () => setSearchOpen(false) },
+    { hint: '/plugin', open: pluginOpen, close: () => setPluginOpen(false) },
+    { hint: '/update', open: updateOpen, close: () => setUpdateOpen(false) },
+    { hint: '/schedule', open: scheduleOpen, close: () => setScheduleOpen(false) },
+    { hint: '/jobs', open: jobsOpen, close: () => setJobsOpen(false) },
+    { hint: '/statusline', open: statuslineOpen, close: () => setStatuslineOpen(false) },
+    { hint: '/theme', open: themeOpen, close: () => setThemeOpen(false) },
+    { hint: '/language', open: languageOpen, close: () => setLanguageOpen(false) },
+    { hint: '/history', open: historyOpen, close: () => setHistoryOpen(false) },
+    { hint: '/queue', open: queueOpen, close: () => setQueueOpen(false) },
+    { hint: '/agents', open: agentsOpen, close: () => setAgentsOpen(false) },
+    { hint: '/subagent', open: subagentOpen, close: () => setSubagentOpen(false) },
+    { hint: '/todos', open: todosOpen, close: () => setTodosOpen(false) },
+    { hint: '/usage', open: usageOpen, close: () => setUsageOpen(false) },
+  ]
+  const panelSurfacesRef = useRef(panelSurfaces)
+  panelSurfacesRef.current = panelSurfaces
+  const openPanel = panelSurfaces.find(surface => surface.open)
+  // The Ctrl+O inspector is the one surface the composer already yields to
+  // through verboseOpen; it rides the same gate without a panel row.
+  const inspectorVisible = verboseOpen && !approvalPending && !questionPending
+  const modalVisible = openPanel !== undefined || inspectorVisible || approvalPending || questionPending
   // While a deletion waits for y/n, the composer takes the keys (the resume
   // panel yields): the confirm is typed IN the input box, not as an invisible
   // panel keypress.
   const inputActive = deleteConfirmId !== undefined
     ? !approvalPending && !questionPending
-    : !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === undefined && !approvalPending && !questionPending
+    : !modalVisible
+  const transcriptVisible = !modalVisible
 
-  // Human questions outrank local inspectors. Close the lower modal instead
-  // of leaving an approval/question visible but keyboard-locked behind it.
+  // Human questions outrank local inspectors. Close every open surface instead
+  // of leaving it visible but keyboard-locked behind the approval.
   useEffect(() => {
     if (!approvalPending && !questionPending) return
-    setModelOpen(false)
-    setProviderOpen(false)
-    setProviderAction(undefined)
-    setEffortFor(undefined)
-    setHelpOpen(false)
-    setModeOpen(false)
-    setPermissionOpen(false)
-    setResumeOpen(false)
-    setPluginOpen(false)
-    setUpdateOpen(false)
-    setScheduleOpen(false)
-    setStatuslineOpen(false)
-    setThemeOpen(false)
-    setHistoryOpen(false)
-    setAgentsOpen(false)
-    setSubagentOpen(false)
-    setTodosOpen(false)
+    for (const surface of panelSurfacesRef.current) {
+      if (surface.open) surface.close()
+    }
     setDeleteConfirmId(undefined)
     setVerboseOpen(false)
-    setDiffView(undefined)
   }, [approvalPending, questionPending])
 
   // Append-only transcript: everything up to the first still-mutable entry
@@ -5085,6 +5763,7 @@ export function App(props: AppProps): ReactElement {
   // One pending synchronized frame covers a debounced resize or explicit
   // source-backed replay. It is closed after the corresponding React commit.
   const synchronizedReplayPending = useRef(false)
+  const resizeBurstHeld = useRef(false)
   useEffect(() => {
     if (appStdout === undefined) return
     let replayTimer: ReturnType<typeof setTimeout> | undefined
@@ -5096,24 +5775,31 @@ export function App(props: AppProps): ReactElement {
       if (next.columns === terminalSizeRef.current.columns && next.rows === terminalSizeRef.current.rows) return
       terminalSizeRef.current = next
 
-      // Ink 5 erases by the old logical line count. Once the terminal reflows
-      // a full-width border at a new width, that count is no longer enough and
-      // stale frames remain visible. Follow Codex's source-backed reflow
-      // policy: update live geometry immediately, but wait for the resize
-      // burst to settle before one hard reset and one transcript replay at the
-      // final width. Replaying Static on every event appends duplicate history.
+      // Hold the visible frame for the whole burst so intermediate Ink
+      // relayouts (new width against still-old Static rows) never flash as
+      // doubled borders. One clear + Static remount still runs after the
+      // burst settles.
+      if (!resizeBurstHeld.current) {
+        resizeBurstHeld.current = true
+        appStdout.write(SYNCHRONIZED_UPDATE_BEGIN)
+      }
       setTerminalSize(next)
       if (replayTimer !== undefined) clearTimeout(replayTimer)
       replayTimer = setTimeout(() => {
         synchronizedReplayPending.current = true
-        appStdout.write(SYNCHRONIZED_UPDATE_BEGIN + RESIZE_REFLOW_CLEAR)
+        appStdout.write(RESIZE_REFLOW_CLEAR)
         setRefreshEpoch(epoch => epoch + 1)
+        resizeBurstHeld.current = false
       }, RESIZE_REFLOW_DELAY_MS)
     }
     appStdout.on('resize', handleResize)
     return () => {
       appStdout.off('resize', handleResize)
       if (replayTimer !== undefined) clearTimeout(replayTimer)
+      if (resizeBurstHeld.current) {
+        appStdout.write(SYNCHRONIZED_UPDATE_END)
+        resizeBurstHeld.current = false
+      }
     }
   }, [appStdout])
   const terminalRows = terminalSize.rows
@@ -5146,14 +5832,19 @@ export function App(props: AppProps): ReactElement {
   }, [])
   const imeRowsBelowComposer = statusBarRows + 1
   const composerEditorCap = composerMaxRows(terminalRows)
-  // Bottom chrome is composer (2 borders + composerRows) + status (up to 2
-  // rows) + todo/agents/notice (3) = 8 resting rows, plus the historical
-  // 5-row menu reserve: small menus still fit without shrinking the live
-  // area (unchanged behavior), and menu rows beyond the reserve are budgeted
-  // exactly so the live/streaming area stays strictly below the terminal
-  // height as the editor or the menu grows.
-  const MENU_RESERVE_ROWS = 5
-  const dynamicRows = Math.max(1, terminalRows - 8 - MENU_RESERVE_ROWS - composerGutterRows - (composerRows - 1) - Math.max(0, menuRows - MENU_RESERVE_ROWS))
+  // Pin the composer and status at the bottom: every extra chrome row
+  // (completion menu, notice, todos, agents, extra editor/status rows)
+  // covers live transcript instead of growing the tree.
+  const dynamicRows = liveRegionBudget({
+    terminalRows,
+    composerRows,
+    statusBarRows,
+    menuRows,
+    gutterRows: composerGutterRows,
+    notice: notice !== undefined,
+    todo: transcriptVisible && view.todos.length > 0,
+    agents: transcriptVisible && agentRows.length > 0,
+  })
   const streamingActive = view.streaming !== '' || view.streamingReasoning !== ''
   const deepDivingVisible = busy && !streamingActive
   // Terminal tab label: "deepseek" until the session carries a name, then the
@@ -5201,6 +5892,10 @@ export function App(props: AppProps): ReactElement {
   )
   if (liveAudit.warning !== undefined && budgetWarnRef.current !== liveAudit.warning) {
     budgetWarnRef.current = liveAudit.warning
+    // The budget tripwire is a last-resort diagnostic: it fires only when the
+    // live/static allocation already broke its contract, and Ink owns/shadows
+    // console output. Everywhere else the TUI must never write to stdout.
+    // eslint-disable-next-line no-console -- see the tripwire note above
     console.warn(`[dsh-code] ${liveAudit.warning}`)
   }
   const auditedLiveLines = liveAudit.allocation.live === visibleLiveLines.length
@@ -5208,9 +5903,6 @@ export function App(props: AppProps): ReactElement {
     : visibleLiveLines.slice(-liveAudit.allocation.live)
   const auditedReasoningRows = liveAudit.allocation.reasoning
   const auditedAnswerRows = liveAudit.allocation.answer
-  const transcriptVisible = !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === undefined && !approvalPending && !questionPending
-  const inspectorVisible = verboseOpen && !approvalPending && !questionPending
-  const modalVisible = modelOpen || helpOpen || modeOpen || permissionOpen || resumeOpen || pluginOpen || updateOpen || scheduleOpen || jobsOpen || statuslineOpen || themeOpen || historyOpen || agentsOpen || subagentOpen || todosOpen || inspectorVisible || diffView !== undefined || approvalPending || questionPending
   // The surface that currently owns the keyboard, named in the frozen band:
   // an empty composer under a panel must not advertise typing it cannot
   // accept — every key actually feeds the panel (which may or may not
@@ -5219,58 +5911,54 @@ export function App(props: AppProps): ReactElement {
     ? 'the approval prompt'
     : questionPending
       ? 'the question'
-      : diffView !== undefined
-        ? 'the diff review'
-        : modelOpen
-          ? '/model'
-          : helpOpen
-            ? '/help'
-            : modeOpen
-              ? '/mode'
-              : permissionOpen
-                ? '/permission'
-                : resumeOpen
-                  ? '/resume'
-                  : pluginOpen
-                    ? '/plugin'
-                    : updateOpen
-                      ? '/update'
-                      : scheduleOpen
-                        ? '/schedule'
-                        : jobsOpen
-                          ? '/jobs'
-                        : statuslineOpen
-                          ? '/statusline'
-                          : themeOpen
-                            ? '/theme'
-                            : historyOpen
-                              ? '/history'
-                              : agentsOpen
-                                ? '/agents'
-                                : subagentOpen
-                                  ? '/subagent'
-                                  : todosOpen
-                                    ? '/todos'
-                                    : inspectorVisible
-                                      ? 'history details'
-                                      : undefined
+      : openPanel?.hint ?? (inspectorVisible ? 'history details' : undefined)
+  // One way out of every panel, matching Esc: while a panel owns the keys,
+  // Ctrl+C closes it instead of silently doing nothing. The composer keeps its
+  // own three states (interrupt the turn / clear the draft / quit) whenever no
+  // panel is open, and the approval and question bars keep theirs.
+  useStableInput((input, key) => {
+    if (!(key.ctrl && input === 'c')) return
+    if (approvalPending || questionPending || deleteConfirmId !== undefined) return
+    if (openPanel !== undefined) openPanel.close()
+    else if (inspectorVisible) setVerboseOpen(false)
+  }, true)
   const frozenHint = keyboardOwner === undefined
     ? undefined
-    : `keys go to ${keyboardOwner} · esc ${approvalPending ? 'rejects' : questionPending ? 'cancels' : 'closes'}`
+    : t('frozen.keysGoTo', {
+      owner: keyboardOwner,
+      action: approvalPending
+        ? t('frozen.action.rejects')
+        : questionPending
+          ? t('frozen.action.cancels')
+          : updateApplying && updateOpen
+            ? t('frozen.action.waits')
+            : t('frozen.action.closes'),
+    })
   const closeInspector = useCallback((): void => {
     setVerboseOpen(false)
   }, [])
-  const refreshScreen = (): void => {
-    // Same source-backed clear the resize path uses: reset the scroll region
-    // (`\x1b[r`) before wiping screen AND scrollback, then home the cursor.
-    // A bare `\x1b[2J\x1b[3J\x1b[H` leaves a previously set scroll region in
-    // place, so Ink's next repaint positions against stale bounds — the
-    // stale-position flicker where the screen keeps redrawing.
+  const refreshScreen = useCallback((opts?: { wipeScrollback?: boolean }): void => {
+    // Resize / Ctrl+L wipe screen AND scrollback. A history-cap trim remounts
+    // Static at the current width, so native scrollback must stay — the user
+    // may be reading messages above the fold.
+    const clear = opts?.wipeScrollback === false ? TRIM_REFLOW_CLEAR : RESIZE_REFLOW_CLEAR
     if (appStdout !== undefined) {
       synchronizedReplayPending.current = true
-      appStdout.write(SYNCHRONIZED_UPDATE_BEGIN + RESIZE_REFLOW_CLEAR)
+      appStdout.write(SYNCHRONIZED_UPDATE_BEGIN + clear)
     }
     setRefreshEpoch(epoch => epoch + 1)
+  }, [appStdout])
+  const applyRainbow = (seed?: number): void => {
+    // Replace the memoized roll, then setTheme so getPalette() and the
+    // painters pick the new values; persist rainbow as the active theme
+    // so a mid-session /rainbow from dark/light actually sticks. The
+    // source-backed rebuild (same as /theme) repaints Static history too.
+    rerollRainbow(seed)
+    setTheme('rainbow')
+    props.saveTheme?.('rainbow')
+    notify(t('notice.rainbowRolled', { seed: rainbowSeedLabel() }))
+    fireRainbowBurst()
+    refreshScreen()
   }
   useEffect(() => {
     if (!synchronizedReplayPending.current || appStdout === undefined) return
@@ -5288,8 +5976,8 @@ export function App(props: AppProps): ReactElement {
   const settledNeedsTrim = settledRowsCache.current?.needsTrim === true
   useEffect(() => {
     if (!settledNeedsTrim || busy || streamingActive) return
-    refreshScreen()
-  }, [settledNeedsTrim, busy, streamingActive])
+    refreshScreen({ wipeScrollback: false })
+  }, [busy, refreshScreen, settledNeedsTrim, streamingActive])
 
   const sessionHasImages = useMemo(() => view.entries.some(entry =>
     (entry.kind === 'user' || entry.kind === 'pending') && (entry.images?.length ?? 0) > 0), [view.entries])
@@ -5302,16 +5990,16 @@ export function App(props: AppProps): ReactElement {
       setEffortLabel(effortId)
       const selected = `${label}${effortId === undefined || effortId === '' ? '' : `@${effortId}`}`
       if (sessionHasImages && row.inputModalities !== undefined && !row.inputModalities.includes('image')) {
-        notify(`model → ${selected} · image history will be sent as text placeholders`, 'warning')
+        notify(t('notice.modelChangedPlaceholder', { model: selected }), 'warning')
       } else {
-        notify(`model → next step uses ${selected}`)
+        notify(t('notice.modelNextStep', { model: selected }))
       }
       setModelOpen(false)
       setProviderOpen(false)
       setProviderAction(undefined)
       setEffortFor(undefined)
     } catch (error: unknown) {
-      notify(`model switch failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      notify(t('notice.modelSwitchFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
     }
   }
 
@@ -5319,6 +6007,7 @@ export function App(props: AppProps): ReactElement {
     setModelLoadEpoch(epoch => epoch + 1)
   }
   const closeModelSurface = (): void => {
+    effortLookupEpoch.current += 1
     setModelOpen(false)
     setProviderOpen(false)
     setProviderAction(undefined)
@@ -5332,7 +6021,7 @@ export function App(props: AppProps): ReactElement {
     const seen = new Set<string>()
     for (const row of providerDirectory?.rows ?? []) {
       for (const model of row.configuration.models) {
-        const raw = (model.extras as Record<string, unknown> | undefined)?.reasoningEfforts
+        const raw = (model.extras)?.reasoningEfforts
         if (!isDeclaredReasoningEfforts(raw)) continue
         const key = row.provider + '/' + model.id
         if (seen.has(key)) continue
@@ -5370,7 +6059,7 @@ export function App(props: AppProps): ReactElement {
           setProviderAction(undefined)
           setProviderOpen(false)
           reloadModelSurfaces()
-          notify(`logged in to ${authorization.label}; select a model`)
+          notify(t('notice.loggedIn', { provider: authorization.label }))
         },
         back: () => {
           setProviderAction(undefined)
@@ -5386,7 +6075,7 @@ export function App(props: AppProps): ReactElement {
           setProviderAction(undefined)
           setProviderOpen(true)
           reloadModelSurfaces()
-          notify(`logged out from ${authorization.label}`)
+          notify(t('notice.loggedOut', { provider: authorization.label }))
         },
         back: () => setProviderAction(undefined),
       })
@@ -5397,13 +6086,13 @@ export function App(props: AppProps): ReactElement {
         save: props.saveModelProviderConfiguration,
         saveCredential: props.saveModelProviderCredential,
         discover: props.discoverModelProvider
-          ?? (async () => { throw new Error('model discovery is unavailable in this profile; enter models by hand') }),
+          ?? (() => Promise.reject(new Error('model discovery is unavailable in this profile; enter models by hand'))),
         done: result => {
           const target = providerAction.target
           setProviderAction(undefined)
           setProviderOpen(true)
           reloadModelSurfaces()
-          notify(`provider configuration saved: ${target.displayName}` + (result.key ? ' · API key updated' : ''))
+          notify(t('notice.providerSaved', { provider: target.displayName, suffix: result.key ? ' · API key updated' : '' }))
         },
         back: () => setProviderAction(undefined),
         onExit: closeModelSurface,
@@ -5418,7 +6107,7 @@ export function App(props: AppProps): ReactElement {
           setProviderAction(undefined)
           setProviderOpen(true)
           reloadModelSurfaces()
-          notify(`API key removed for ${target.displayName}`)
+          notify(t('notice.apiKeyRemoved', { provider: target.displayName }))
         },
         back: () => setProviderAction(undefined),
       })
@@ -5432,7 +6121,7 @@ export function App(props: AppProps): ReactElement {
           setProviderAction(undefined)
           setProviderOpen(true)
           reloadModelSurfaces()
-          notify(`provider removed: ${target.displayName}`)
+          notify(t('notice.providerRemoved', { provider: target.displayName }))
         },
         back: () => setProviderAction(undefined),
       })
@@ -5444,42 +6133,42 @@ export function App(props: AppProps): ReactElement {
         authorizationError,
         onConfigure: (target: ProviderTargetView) => {
           if (props.saveModelProviderConfiguration === undefined) {
-            notify('provider configuration is unavailable in this profile', 'warning')
+            notify(t('notice.providerUnavailable'), 'warning')
             return
           }
           setProviderAction({ kind: 'configure', target })
         },
         onUnset: (target: ProviderTargetView) => {
           if (props.unsetModelProviderCredential === undefined) {
-            notify('API key removal is unavailable in this profile', 'warning')
+            notify(t('notice.apiKeyUnavailable'), 'warning')
             return
           }
           setProviderAction({ kind: 'unset', target })
         },
         onRemove: (target: ProviderTargetView) => {
           if (props.removeModelProvider === undefined) {
-            notify('provider removal is unavailable in this profile', 'warning')
+            notify(t('notice.providerRemovalUnavailable'), 'warning')
             return
           }
           setProviderAction({ kind: 'remove', target })
         },
         onLogin: (target: ProviderTargetView, authorization: ProviderAuthorizationRow) => {
           if (busy) {
-            notify('provider login is available only while the agent is idle', 'warning')
+            notify(t('notice.loginIdleOnly'), 'warning')
             return
           }
           if (props.beginProviderAuthorization === undefined
             || props.cancelProviderAuthorization === undefined
             || props.openAuthorizationUrl === undefined
             || props.copyTextValue === undefined) {
-            notify('provider login is unavailable in this profile', 'warning')
+            notify(t('notice.loginUnavailable'), 'warning')
             return
           }
           setProviderAction({ kind: 'login', target, authorization })
         },
         onLogout: (target: ProviderTargetView, authorization: ProviderAuthorizationRow) => {
           if (props.logoutProviderAuthorization === undefined) {
-            notify('provider logout is unavailable in this profile', 'warning')
+            notify(t('notice.logoutUnavailable'), 'warning')
             return
           }
           setProviderAction({ kind: 'logout', target, authorization })
@@ -5512,7 +6201,7 @@ export function App(props: AppProps): ReactElement {
             setEffortFor(row)
             return
           }
-          const effortId = row.reasoning?.efforts.length === 1 ? row.reasoning.efforts[0]!.id : undefined
+          const effortId = row.reasoning?.efforts.length === 1 ? row.reasoning.efforts[0].id : undefined
           applyModel(row, effortId)
         },
         ...(props.loadModelProviders === undefined || props.saveModelProviderConfiguration === undefined
@@ -5547,6 +6236,7 @@ export function App(props: AppProps): ReactElement {
               continuationPrefix: '  ',
               dim: true,
               maxRows: auditedReasoningRows,
+              columns: Math.max(1, terminalColumns - 2),
             })
             // The collapsed marker shimmers only while reasoning streams
             // alone: once answer text flows, a periodically re-rendered
@@ -5563,6 +6253,7 @@ export function App(props: AppProps): ReactElement {
                 continuationPrefix: '  ',
                 dim: true,
                 maxRows: auditedReasoningRows,
+                columns: Math.max(1, terminalColumns - 2),
               })
           : undefined,
         view.streaming !== '' && auditedAnswerRows > 0
@@ -5570,7 +6261,7 @@ export function App(props: AppProps): ReactElement {
             StreamTail,
             // The same two-column gutter as settled replies: streamed text
             // lands exactly where the assembled message will render.
-            { text: view.streaming, dim: false, maxRows: auditedAnswerRows, prefix: '  ' },
+            { text: view.streaming, dim: false, maxRows: auditedAnswerRows, prefix: '  ', columns: Math.max(1, terminalColumns - 2) },
             busy ? createElement(Caret, { animated: animations }) : undefined,
           )
           : undefined,
@@ -5579,6 +6270,13 @@ export function App(props: AppProps): ReactElement {
       : undefined,
     transcriptVisible ? createElement(TodoPanel, { todos: view.todos }) : undefined,
     transcriptVisible ? createElement(AgentsLine, { rows: agentRows, total: props.subagents.getTotalSeen() }) : undefined,
+    usageOpen && !approvalPending && !questionPending
+      ? createElement(UsagePanel, {
+        key: props.sessionKey,
+        load: props.loadUsage,
+        close: () => setUsageOpen(false),
+      })
+      : undefined,
     todosOpen && !approvalPending && !questionPending
       ? createElement(MemoTodoListPanel, {
         todos: view.todos,
@@ -5587,6 +6285,14 @@ export function App(props: AppProps): ReactElement {
         },
       })
       : undefined,
+    queueOpen && !approvalPending && !questionPending
+      ? createElement(QueuePanel, {
+        rows: queuedRows,
+        busy,
+        update: props.updateQueued,
+        onClose: () => setQueueOpen(false),
+      })
+      : undefined,
     createElement(QuestionBar, { store: props.questions, snapshot: questionSnapshot, locked: false }),
     createElement(ApprovalBar, { snapshot: approvalSnapshot, locked: questionPending, notify, interrupt: props.interrupt, summarize: questionPending }),
     modelSurface,
@@ -5607,10 +6313,23 @@ export function App(props: AppProps): ReactElement {
         onClose: () => setDiffView(undefined),
       })
       : undefined,
+    reviewPickerOpen && !approvalPending && !questionPending && props.listReviewBranches !== undefined && props.listReviewCommits !== undefined
+      ? createElement(ReviewPickerPanel, {
+        loadBranches: props.listReviewBranches,
+        loadCommits: props.listReviewCommits,
+        choose: argument => {
+          setReviewPickerOpen(false)
+          props.reviewChanges(argument)
+        },
+        close: () => setReviewPickerOpen(false),
+      })
+      : undefined,
     verboseOpen && !approvalPending && !questionPending
       ? createElement(MemoVerbosePanel, {
         entries: view.entries,
         onClose: closeInspector,
+        columns: terminalColumns,
+        rows: terminalRows,
       })
       : undefined,
     modeOpen && !approvalPending && !questionPending
@@ -5619,9 +6338,9 @@ export function App(props: AppProps): ReactElement {
         load: props.loadPresets,
         select: (id: string) => {
           void props.switchMode(id).then(label => {
-            notify(`mode → ${label}`)
+            notify(t('notice.modeChangedSimple', { value: label }))
             setModeOpen(false)
-          }, (reason: unknown) => notify(`mode switch failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error'))
+          }, (reason: unknown) => notify(t('notice.modeSwitchFailed', { message: reason instanceof Error ? reason.message : String(reason) }), 'error'))
         },
         close: () => setModeOpen(false),
       })
@@ -5633,7 +6352,7 @@ export function App(props: AppProps): ReactElement {
         select: (id: string) => {
           try {
             const selected = props.setPermission(id)
-            notify(`permission → ${selected}`)
+            notify(t('notice.permissionChangedSimple', { value: selected }))
             setPermissionOpen(false)
           } catch (reason: unknown) {
             notify(`permission change failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
@@ -5647,14 +6366,43 @@ export function App(props: AppProps): ReactElement {
         currentCwd: props.workspaceRoot,
         load: props.loadSessions,
         readTranscript: props.loadSessionTranscript,
-        requestDelete,
+        requestDelete: resumeDelete.mode ? requestDelete : undefined,
         deleteConfirmId,
         reloadToken: deleteReloadToken,
         deleteMode: resumeDelete.mode,
-        select: (row: SessionRow) => { props.switchSession(row); setResumeOpen(false) },
+        presetId: resumeDelete.id,
+        select: (row: SessionRow) => {
+          // Defense in depth: the dedicated delete picker must never turn a
+          // selection into a session switch, even if its key routing regresses.
+          if (resumeDelete.mode) return
+          props.switchSession(row)
+          setResumeOpen(false)
+        },
         close: () => setResumeOpen(false),
       })
       : undefined,
+    searchOpen && !approvalPending && !questionPending && props.searchSessions !== undefined
+      ? createElement(SearchPanel, {
+        load: props.searchSessions,
+        initialQuery: searchSeed,
+        select: (row: SearchRow) => {
+          setSearchOpen(false)
+          props.switchSession({
+            id: row.id,
+            createdAt: row.updatedAt,
+            updatedAt: row.updatedAt,
+            cwd: '',
+            workspace: '',
+            subagent: row.subagent,
+            resumable: row.resumable,
+            live: false,
+            persisted: true,
+            preset: '',
+          })
+        },
+        close: () => setSearchOpen(false),
+      })
+      : undefined,
     pluginOpen && !approvalPending && !questionPending
       ? createElement(PluginPanel, { load: props.loadPlugins, initialQuery: pluginQuery, close: () => setPluginOpen(false) })
       : undefined,
@@ -5691,12 +6439,36 @@ export function App(props: AppProps): ReactElement {
           // palette. `auto` stores as requested; detection is a later step.
           setTheme(name)
           props.saveTheme?.(name)
-          notify(`theme → ${name}`)
+          // Rainbow prints its roll seed so a lucky launch can be reproduced
+          // with RAINBOW_SEED=<seed>.
+          notify(name === 'rainbow'
+            ? t('notice.themeRainbow', { seed: rainbowSeedLabel() })
+            : t('notice.themeSaved', { name }))
           setThemeOpen(false)
+          // The header whale and settled history live in the Static region,
+          // which renders once and would keep the old palette's colors; the
+          // same source-backed rebuild resize and Ctrl+L use repaints the
+          // whole screen (scrollback included) from the new palette.
+          if (name === 'rainbow') fireRainbowBurst()
+          refreshScreen()
         },
         close: () => setThemeOpen(false),
       })
       : undefined,
+    languageOpen && !approvalPending && !questionPending
+      ? createElement(LanguagePanel, {
+        current: getLanguage(),
+        select: (name: LanguageName) => {
+          props.saveLanguage(name)
+          notify(t('notice.languageSaved', { name }))
+          setLanguageOpen(false)
+          // The Static region renders once; the same source-backed rebuild
+          // the theme switch uses repaints translated text everywhere.
+          refreshScreen()
+        },
+        close: () => setLanguageOpen(false),
+      })
+      : undefined,
     historyOpen && !approvalPending && !questionPending
       ? createElement(HistoryPanel, {
         entries: recallSpace,
@@ -5724,15 +6496,15 @@ export function App(props: AppProps): ReactElement {
             // The runner's label already carries the effort suffix
             // (`provider/model@effort`), so no second append here.
             const label = props.setSubagentModel(row, effortId)
-            notify(`subagents → ${label}`)
+            notify(t('notice.subagentsChanged', { value: label }))
             setSubagentOpen(false)
           } catch (reason: unknown) {
-            notify(`subagent model change failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
+            notify(t('notice.subagentChangeFailed', { message: reason instanceof Error ? reason.message : String(reason) }), 'error')
           }
         },
         inherit: () => {
           props.clearSubagentModel()
-          notify('subagents → inherit current model')
+          notify(t('notice.subagentsInherited'))
           setSubagentOpen(false)
         },
         close: () => setSubagentOpen(false),
@@ -5759,11 +6531,18 @@ export function App(props: AppProps): ReactElement {
         descriptors,
         skills,
         dispatch: props.dispatch,
-        applyEditorKeys: props.applyEditorKeys,
         steer: props.steer,
+        submitMode,
+        cycleSubmitMode: () => {
+          const next = submitMode === 'queue' ? 'steer' : 'queue'
+          setSubmitMode(next)
+          notify(t(next === 'steer' ? 'notice.submitMode.steer' : 'notice.submitMode.queue'))
+        },
+        applyEditorKeys: props.applyEditorKeys,
         interrupt: props.interrupt,
         quit: props.quit,
         openModel: () => {
+          effortLookupEpoch.current += 1
           setDirectory(undefined)
           setModelError(undefined)
           setProviderDirectory(undefined)
@@ -5786,18 +6565,20 @@ export function App(props: AppProps): ReactElement {
           // never as "the model has no efforts" — the adapter advertises
           // levels for every deepseek model, so "no efforts" is almost
           // always a failed resolveModelInfo, not a fact.
+          const epoch = ++effortLookupEpoch.current
           void props.loadModels().then((loaded) => {
+            if (epoch !== effortLookupEpoch.current) return
             const [provider, model] = modelLabel.split('/')
             const row = loaded.rows.find(candidate => candidate.provider === provider && candidate.model === model)
               ?? loaded.rows.find(candidate => candidate.model === model && candidate.reasoning !== undefined)
               ?? loaded.rows.find(candidate => candidate.model === model)
             if (row === undefined) {
-              notify('current model is not in the catalog', 'warning')
+              notify(t('notice.modelMissing'), 'warning')
               return
             }
             const rowTag = `${row.provider}/${row.model}`
             if (loaded.reasoningFailures?.includes(rowTag) === true) {
-              notify('reasoning levels temporarily unavailable (capability lookup failed) — try again', 'warning')
+              notify(t('notice.effortUnavailable'), 'warning')
               return
             }
             if (row.reasoning === undefined || row.reasoning.efforts.length === 0) {
@@ -5821,20 +6602,34 @@ export function App(props: AppProps): ReactElement {
         openMode: () => setModeOpen(true),
         openPermission: () => setPermissionOpen(true),
         openResume: () => { setResumeDelete({ mode: false }); setResumeOpen(true) },
+        openSearch: (query: string) => {
+          if (props.searchSessions === undefined) {
+            notify(t('notice.sessionSearchUnavailable'), 'warning')
+            return
+          }
+          setSearchSeed(query)
+          setSearchOpen(true)
+        },
         openPlugin: (query = '') => { setPluginQuery(query); setPluginOpen(true) },
         openUpdate: () => setUpdateOpen(true),
         openSchedule: () => setScheduleOpen(true),
         openJobs: () => setJobsOpen(true),
         openStatusline: () => setStatuslineOpen(true),
         openTheme: () => setThemeOpen(true),
+        openLanguage: () => setLanguageOpen(true),
+        saveLanguage: props.saveLanguage,
         openHistory: () => setHistoryOpen(true),
+        openQueue: () => setQueueOpen(true),
         openAgents: () => setAgentsOpen(true),
         openSubagent: () => setSubagentOpen(true),
         openTodos: () => setTodosOpen(true),
+        openUsage: () => setUsageOpen(true),
         openDelete: (id?: string) => {
           const armed = id === undefined || id === '' ? undefined : id
           setResumeDelete({ mode: true, ...armed === undefined ? {} : { id: armed } })
-          setDeleteConfirmId(armed)
+          // Confirm after the picker resolves the id against the listing —
+          // the argument may be a suffix of the displayed id, not the row key.
+          setDeleteConfirmId(undefined)
           setResumeOpen(true)
         },
         openDiff: (argument: string) => {
@@ -5843,6 +6638,7 @@ export function App(props: AppProps): ReactElement {
           })
         },
         reviewChanges: props.reviewChanges,
+        openReviewPicker: () => setReviewPickerOpen(true),
         deleteConfirm: deleteConfirmId,
         confirmDelete,
         cancelDelete,
@@ -5886,11 +6682,13 @@ export function App(props: AppProps): ReactElement {
         recordLocal,
         recordHistory: props.recordHistory,
         queued: queuedRows,
-        cancelQueued: props.cancelQueued,
+        updateQueued: props.updateQueued,
         historyFill,
         historyConsumed,
         animations,
         applyAnimations,
+        applyRainbow,
+        rainbowBurstId,
         waveTier,
         waveStyle,
         maxRows: composerEditorCap,
@@ -5914,6 +6712,7 @@ export function App(props: AppProps): ReactElement {
         },
         stats: view.stats,
         busy,
+        animated: animations,
         columns: terminalColumns,
         items: statuslineItems,
         onRows: handleStatusRows,