dsh-code 1.0.6 → 1.2.0

package/src/app.ts

@@ -26,18 +26,33 @@ 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 { LanguagePanel } from './language-panel.ts'
+import { getLanguage, parseLanguageName, t, type LanguageName, type MessageKey } from './i18n.ts'
+import { UpdatePanel } 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 type { TranscriptStore } from './store.ts'
+import { DEFAULT_TERMINAL_TITLE, sanitizeTerminalTitle, terminalTitleSequence, useTerminalTitle } from './terminal-title.ts'
 import { settledEntryCount, type TranscriptEntry } from './render/projection.ts'
+import { imeCursorRowsUp, useImeCursorAnchor } from './render/ime-cursor.ts'
 import { type MdSegment, visibleColumns } from './render/markdown.ts'
 import {
   busyChaseFrame,
@@ -55,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'
@@ -80,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, EffortPanel, HistoryPanel, JobsPanel, ModePanel, PermissionPanel, PluginPanel, ResumePanel, 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'
@@ -93,7 +114,7 @@ import {
   type RecallState,
 } 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,
@@ -144,7 +165,7 @@ const SYNCHRONIZED_UPDATE_END = '\x1b[?2026l'
 import {
   layoutStatusBar,
   parseStatuslineItems,
-  STATUS_CYCLE_HINT,
+  statusCycleHint,
   STATUS_GROUP_SEPARATOR,
   STATUS_ITEM_SEPARATOR,
   STATUS_ROW2_INDENT,
@@ -171,6 +192,7 @@ import {
   followInspectorCursor,
   inspectorViewport,
   layoutGutterRows,
+  liveRegionBudget,
   moveScroll,
   panelViewport,
   revealRow,
@@ -178,6 +200,8 @@ import {
 } from './render/inspector.ts'
 import {
   clampLiveAllocation,
+  diffLineStyle,
+  fillDiffLineBars,
   lineSegment,
   markdownLines,
   settledEntryLines,
@@ -220,37 +244,53 @@ 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: '/jobs', description: 'inspect background jobs' },
-  { 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)))
 
+/** 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. */
@@ -289,127 +329,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>
-  /** Cycle to the next permission preset (Shift+Tab); returns the new label. */
-  cyclePermission(): string
+  ) => 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
+  /** 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>
+  /** Run the launcher's aligned update; streams sanitized lines; resolves with the exit code. */
+  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). */
@@ -463,7 +527,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. */
@@ -473,7 +543,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(() => {
@@ -502,6 +572,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,
@@ -515,8 +592,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,
@@ -613,6 +690,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 }
   }
@@ -625,20 +714,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 }
   }
 }
 
@@ -662,7 +777,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)
@@ -670,15 +785,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) => {
@@ -697,15 +804,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)),
   )
 }
 
@@ -723,6 +831,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
@@ -737,7 +871,7 @@ function Header({ resumed }: { resumed: boolean }): ReactElement {
   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,
@@ -756,7 +890,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,
@@ -791,7 +928,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,
@@ -844,7 +981,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' },
@@ -873,40 +1010,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':
@@ -928,6 +1227,10 @@ function statusToneProps(tone: StatusTone): {
       return { color: inkColor(getPalette().brand), bold: undefined, dimColor: undefined }
     case 'success':
       return { color: inkColor(getPalette().code), bold: true, dimColor: undefined }
+    // The plan station's dedicated green: the status bar otherwise speaks in
+    // blues, but the fourth cycle station IS a distinct green mode marker.
+    case 'plan':
+      return { color: inkColor(getPalette().success), bold: true, dimColor: undefined }
     case 'warn':
       return { color: inkColor(getPalette().warn), bold: true, dimColor: undefined }
     case 'error':
@@ -964,18 +1267,40 @@ 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 }: {
+function StatusLine({ facts, stats, busy, columns, items, onRows, animated }: {
   facts: StatusFacts
   stats: Parameters<typeof layoutStatusBar>[1]
   busy: boolean
   columns: number
   items: readonly string[]
+  /** 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 {
+  // 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(() => layoutStatusBar(facts, stats, Math.max(8, columns - 2), {
     busy,
     items,
@@ -999,7 +1324,16 @@ function StatusLine({ facts, stats, busy, columns, items }: {
     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
+  // (same contract as the composer's row report).
+  const statusRowCount: 1 | 2 = layout.row2.left.length > 0 ? 2 : 1
+  useEffect(() => {
+    onRows?.(statusRowCount)
+  }, [onRows, statusRowCount])
 
   const renderRow = (row: { left: readonly StatusGroup[]; right: readonly StatusSpan[]; hint: boolean }, key: string, indent = 0): ReactElement => {
     const leftParts: ReactElement[] = []
@@ -1010,7 +1344,7 @@ function StatusLine({ facts, stats, busy, columns, items }: {
       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,
         ))
       })
@@ -1022,12 +1356,12 @@ function StatusLine({ facts, stats, busy, columns, items }: {
       }
       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
@@ -1105,9 +1439,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
@@ -1134,7 +1468,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')
     }
   }
 
@@ -1158,35 +1492,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]").
@@ -1205,7 +1539,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) => {
@@ -1222,8 +1556,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)),
   )
 }
 
@@ -1596,21 +1930,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,
@@ -1618,12 +1952,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))),
   )
 }
 
@@ -1633,43 +1967,65 @@ 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 ?? []
+  // 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
+  // commands and become query text instead.
+  const filtered = useMemo(() => {
+    if (query === '') return rows
+    const needle = query.toLowerCase()
+    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
     // non-empty directory positions the cursor once, never on later refreshes.
     if (positioned.current || rows.length === 0 || current === undefined) {
-      if (rows.length === 0) {
+      if (filtered.length === 0) {
         if (cursor !== 0) setCursor(0)
         return
       }
-      if (cursor >= rows.length) setCursor(rows.length - 1)
+      if (cursor >= filtered.length) setCursor(filtered.length - 1)
       return
     }
     const index = rows.findIndex(row => `${row.provider}/${row.model}` === current)
     if (index >= 0) {
       positioned.current = true
-      setCursor(index)
-    } else if (cursor >= rows.length) {
-      setCursor(Math.max(0, rows.length - 1))
+      // 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])
+      setCursor(filteredIndex >= 0 ? filteredIndex : 0)
+    } else if (cursor >= filtered.length) {
+      setCursor(Math.max(0, filtered.length - 1))
     }
-  }, [rows, cursor, current])
+  }, [rows, filtered, cursor, current])
 
   useInput((input, key) => {
-    if (key.escape || input === 'q') {
+    const { filtered: list, query: text, cursor: at } = liveRef.current
+    if (key.escape || (input === 'q' && text === '')) {
       onClose()
       return
     }
-    if (input === 'r') {
+    if (input === 'r' && text === '') {
       onRetry()
       return
     }
@@ -1682,13 +2038,19 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
       onClose()
       return
     }
-    if (rows.length === 0) return
+    const next = editQuery(text, input, key)
+    if (next !== undefined) {
+      setQuery(next)
+      setCursor(0)
+      return
+    }
+    if (list.length === 0) return
     if (key.upArrow) {
-      setCursor(cursor > 0 ? cursor - 1 : rows.length - 1)
+      setCursor(at > 0 ? at - 1 : list.length - 1)
       return
     }
     if (key.downArrow) {
-      setCursor(cursor < rows.length - 1 ? cursor + 1 : 0)
+      setCursor(at < list.length - 1 ? at + 1 : 0)
       return
     }
     if (key.pageUp) {
@@ -1696,36 +2058,31 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
       return
     }
     if (key.pageDown) {
-      setCursor(current => Math.min(rows.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 (input === 'g') {
-      setCursor(0)
-      return
-    }
-    if (input === 'G') {
-      setCursor(rows.length - 1)
-      return
-    }
-    if (key.return && rows[cursor] !== undefined) {
-      onSelect(rows[cursor])
+    if (key.return && list[at] !== undefined) {
+      onSelect(list[at])
     }
   })
 
   if (viewport.maxHeight === 0 || viewport.compact) {
     const providers = onProviders === undefined ? '' : ' · tab providers'
-    const state = rows.length === 0
+    const state = filtered.length === 0
       ? directory === undefined && error === undefined
-        ? 'loading…'
+        ? t('panel.model.loading')
         : error !== undefined
-          ? 'error'
-          : 'no models'
-      : `❯ ${rows[cursor]?.modelName ?? rows[cursor]?.model ?? ''}`
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`/model · ${state}${providers} · r retry · esc/q close`, viewport.contentColumns))
+          ? 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 === ''
+      ? 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,
@@ -1738,27 +2095,32 @@ 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(`  ${t('panel.model.noMatch', { query: singleLineText(query) })}`, viewport.contentColumns))]
+            : []),
       ]
   // Measurement and rendering share the same physical-row budget: state
   // messages consume body rows before selectable entries, as in Codex's
   // list-selection views.
   const visibleStateRows = stateRows.slice(0, viewport.bodyRows)
   const rowBudget = Math.max(0, viewport.bodyRows - visibleStateRows.length)
-  const first = selectionWindow(cursor, rows.length, rowBudget)
-  const visible = rowBudget === 0 ? [] : rows.slice(first, first + rowBudget)
+  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(`/model — select model${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(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) => {
-      const index = rows.indexOf(row)
+      const index = filtered.indexOf(row)
       const capability = row.inputModalities?.includes('image') === true ? ' · image' : ''
       const label = displayText(`${row.providerName} · ${row.modelName}${capability}`)
       return createElement(
@@ -1772,21 +2134,23 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
       )
     }),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
-    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, dim(truncateColumns(`↑↓ move · pgup/pgdn page · enter select${onProviders === undefined ? '' : ' · tab providers'} · r retry · esc/q 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`. */
@@ -1795,15 +2159,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)
@@ -1865,9 +2229,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)
       }
@@ -1875,7 +2239,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)
       }
@@ -1883,14 +2247,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
     }
@@ -1899,7 +2263,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)
       }
@@ -1907,10 +2271,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))]
       : [
@@ -1924,14 +2288,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)
@@ -1942,7 +2306,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
@@ -1966,15 +2330,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)),
   )
 }
 
@@ -2002,14 +2367,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)
@@ -2063,7 +2428,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 '~'
@@ -2216,7 +2581,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
     }
@@ -2244,19 +2609,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) => {
@@ -2265,7 +2631,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') {
@@ -2307,7 +2673,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)
@@ -2317,10 +2683,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(
@@ -2334,7 +2701,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)),
   )
 }
 
@@ -2350,11 +2717,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)
@@ -2415,24 +2782,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) => {
@@ -2444,7 +2812,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)),
   )
 }
 
@@ -2452,9 +2820,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)
@@ -2512,7 +2880,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
@@ -2522,19 +2890,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(
@@ -2545,18 +2913,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
       ? []
@@ -2567,8 +2935,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)
@@ -2594,17 +2962,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))),
   )
 }
 
@@ -2614,7 +2983,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 {
@@ -2647,9 +3017,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,
       {
@@ -2672,7 +3042,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
@@ -2745,11 +3115,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
 }
 
 /**
@@ -2817,7 +3189,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(' ')
 
@@ -2826,9 +3198,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))
@@ -2840,11 +3212,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))
@@ -2858,13 +3230,104 @@ 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 {
+function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[]; onClose: () => void }): ReactElement {
   const stdout = useStdout().stdout
   const columns = stdout?.columns ?? 80
   const rows = stdout?.rows ?? 30
@@ -2958,14 +3421,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,
     {
@@ -2973,11 +3437,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 }),
@@ -2991,8 +3455,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)),
     ),
   )
 }
@@ -3039,7 +3503,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.
@@ -3104,10 +3568,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).
  */
@@ -3165,7 +3629,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,
   )
 }
@@ -3187,84 +3651,109 @@ 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, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openPlugin, 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, cyclePermission, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, animations, applyAnimations, waveTier, waveStyle, maxRows, 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
+   * draft otherwise advertises typing that the composer cannot accept. */
+  frozenHint?: string
   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
-  openJobs(): void
-  openStatusline(): void
-  openTheme(): void
-  openHistory(): 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
+  /** Open the /schedule reminder panel (read-only catalog). */
+  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
+  openTodos: () => void
+  openUsage: () => 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
+  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[]>
-  cyclePermission(): 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"
@@ -3275,14 +3764,25 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   waveStyle: DeepseekWaveStyle | null
   /** Maximum physical editor rows the composer may occupy (see composerMaxRows). */
   maxRows: number
+  /** Terminal rows below the composer the editor does not own: the status
+   * footer and Ink's parked cursor row. The IME anchor adds these to the
+   * caret's in-band offset to reach that parked position. */
+  anchorRowsBelow: number
+  /** The managed terminal tab label; re-asserted on terminal focus-in so a
+   * 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 columns = useStdout().stdout?.columns ?? 80
-  const inputTerminalRows = useStdout().stdout?.rows ?? 30
+  const { stdout: inputStdout } = useStdout()
+  const columns = inputStdout?.columns ?? 80
+  const inputTerminalRows = inputStdout?.rows ?? 30
+  // The managed tab label, kept current for the focus-in re-assert below.
+  const tabTitleRef = useRef(tabTitle)
+  tabTitleRef.current = tabTitle
   const editorColumns = Math.max(1, columns - 6)
   const stdin = useStdin().stdin
   const focusReporting = isVsCodeTerminalEnv()
@@ -3378,12 +3878,24 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     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
         ? stripTerminalFocusEvents(normalized, focused => {
           terminalFocusedRef.current = focused
+          // Focus-in re-asserts the managed tab label on both channels: a
+          // background process sharing this console (a test-runner worker,
+          // for example) may have overwritten the console title while the
+          // terminal was unfocused.
+          if (focused && inputStdout !== undefined) {
+            inputStdout.write(terminalTitleSequence(tabTitleRef.current))
+            process.title = sanitizeTerminalTitle(tabTitleRef.current)
+          }
         })
         : normalized
       rawEditorTokens.current = tokenizeRawEditorChunk(input)
@@ -3391,7 +3903,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     } as typeof stdin.read
     stdin.read = patchedRead
     return () => {
-      stdin.read = originalRead as typeof stdin.read
+      stdin.read = originalRead
     }
   }, [focusReporting, stdin])
 
@@ -3446,7 +3958,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 
   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 }]
@@ -3465,7 +3977,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     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),
@@ -3486,13 +3998,13 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         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
@@ -3513,9 +4025,9 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       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')
     })
   }
 
@@ -3600,7 +4112,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
             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))) {
@@ -3611,7 +4123,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
               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')
@@ -3623,9 +4135,9 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
             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)
@@ -3729,23 +4241,19 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     prepareAbortRef.current = undefined
     setPreparingImages(false)
     dismissNotice()
-    notify('image submission cancelled', 'warning')
+    notify(t('notice.imageCancelled'), 'warning')
   }
 
-  /** Move through visual rows first, then cross history at the true edge. */
+  /** Cross history while an unchanged recalled draft rests its caret on
+   * either text edge; between the edges (or inside ordinary drafts) the
+   * arrows move through visual rows first. */
   const navigateVertical = (direction: -1 | 1): void => {
     const currentValue = valueRef.current
     const currentCursor = cursorRef.current
-    const model = editorModel(currentValue, editorColumns)
-    const preferred = preferredColumnRef.current ?? caretSite(model, currentCursor).column
-    const next = moveCursorVertically(model, currentCursor, preferred, direction)
-    if (next !== currentCursor) {
-      cursorRef.current = next
-      setCursor(next)
-      resetCursorBlink()
-      preferredColumnRef.current = preferred
-      return
-    }
+    // History owns the arrows while an unchanged recalled draft rests its
+    // caret on either text edge (start or end). Everywhere else - edited
+    // drafts, interior carets, ordinary typing - the arrows move through
+    // visual rows as plain editing.
     if (recall.current.entries.length > 0
       && shouldRecallNavigate(currentValue, currentCursor, recall.current.lastRecalled, direction)) {
       const step = direction < 0 ? recallOlder(recall.current, currentValue) : recallNewer(recall.current)
@@ -3757,10 +4265,24 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         setValue(safe)
         setCursor(safe.length)
         preferredColumnRef.current = null
-        setDismissedMenuValue(undefined)
+        // Suppress the completion menu for the recalled text: a recalled
+        // command would otherwise reopen the menu, whose Up/Down navigation
+        // then traps the walk before it reaches older history entries. Any
+        // edit re-opens the menu; submitting resets the dismissal.
+        setDismissedMenuValue(safe)
       }
+      resetCursorBlink()
+      return
+    }
+    const model = editorModel(currentValue, editorColumns)
+    const preferred = preferredColumnRef.current ?? caretSite(model, currentCursor).column
+    const next = moveCursorVertically(model, currentCursor, preferred, direction)
+    if (next !== currentCursor) {
+      cursorRef.current = next
+      setCursor(next)
+      resetCursorBlink()
+      preferredColumnRef.current = preferred
     }
-    resetCursorBlink()
   }
 
   useStableInput((input, key) => {
@@ -3787,16 +4309,25 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       }
       return
     }
-    // Shift+Tab cycles the permission preset (Claude-Code convention).
+    // Shift+Tab cycles the mode stations: permission presets, then the
+    // plan station when the composition offers it (Claude-Code convention).
     if (key.tab && key.shift) {
       try {
-        const next = cyclePermission()
-        if (next !== '') notify(`permission → ${next}`)
+        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.
@@ -3842,7 +4373,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         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
     }
@@ -3868,7 +4399,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       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
       }
     }
@@ -3900,7 +4431,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         // 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
@@ -3939,7 +4470,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
           }
           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
@@ -3958,13 +4489,12 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       setDismissedMenuValue(undefined)
       if (trimmed === '') return
       dismissNotice()
-      // Global recall records non-slash submissions only (slash lines are
-      // commands, not prompts) — Codex record_local_submission semantics;
-      // the submission resets any active recall browsing.
-      if (!text.startsWith('/')) {
-        recordLocal(text)
-        recordHistory(text)
-      }
+      // Global recall records every submission - prompts and typed slash
+      // commands share one history, so Up/Down and /history recall commands
+      // exactly like prompts; the submission resets any active recall
+      // browsing.
+      recordLocal(text)
+      recordHistory(text)
       recall.current = beginRecall(recallSpace, '')
       if (text === '/quit') {
         quit()
@@ -4009,7 +4539,16 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         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 ')) {
@@ -4044,6 +4583,10 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         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
@@ -4056,6 +4599,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         openPlugin(text.slice(7).trim())
         return
       }
+      if (text === '/update') {
+        openUpdate()
+        return
+      }
+      if (text === '/schedule') {
+        openSchedule()
+        return
+      }
       if (text === '/jobs' || text.startsWith('/jobs ')) {
         openJobs()
         return
@@ -4068,17 +4619,41 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         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
@@ -4102,19 +4677,25 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         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)
-        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.
@@ -4286,13 +4867,23 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     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
@@ -4315,6 +4906,17 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   useEffect(() => {
     onEditorRows(editorRowCount)
   }, [editorRowCount, onEditorRows])
+  // IME anchor: park the real terminal cursor on the caret cell while the
+  // composer accepts input. IME composition and candidate windows anchor to
+  // that real cursor cell, which otherwise sits below the status row where
+  // Ink leaves it, so Chinese input never appears at the caret. Frozen bands
+  // release the anchor; the wrapper keeps Ink's relative erase ledger exact.
+  const caretRowInWindow = Math.max(0, Math.min(caret.row - editorWindowStart, editorWindowRows - 1))
+  useImeCursorAnchor(
+    !frozen,
+    imeCursorRowsUp({ editorWindowRows, caretRowInWindow, rowsBelowComposer: anchorRowsBelow }),
+    2 + caret.column,
+  )
   // The menu's physical rows ride the same one-way report; the cleanup keeps
   // the reserve from outliving the menu (unmount or inactive handoff).
   useEffect(() => {
@@ -4350,12 +4952,12 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       ))
     }
     const frozenLine = value === ''
-      ? 'type a message'
+      ? frozenHint ?? 'type a message'
       : verboseLine(value, Math.max(1, columns - 6))
     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)),
     ))
@@ -4373,10 +4975,10 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   // 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,
@@ -4384,16 +4986,18 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       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),
     ))
@@ -4409,26 +5013,47 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     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,
+      }),
   )
 }
 
@@ -4653,7 +5278,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
@@ -4675,8 +5306,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. */
@@ -4705,13 +5338,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)
@@ -4826,21 +5463,36 @@ 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 [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)
+  const [usageOpen, setUsageOpen] = useState(false)
   /** /delete state: delete-mode hint 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
@@ -4864,7 +5516,7 @@ export function App(props: AppProps): ReactElement {
       // 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])
   /** The /history panel's accepted entry: text plus its recall-space index. */
@@ -4884,26 +5536,25 @@ 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.
@@ -4912,7 +5563,8 @@ export function App(props: AppProps): ReactElement {
   // panel keypress.
   const inputActive = deleteConfirmId !== undefined
     ? !approvalPending && !questionPending
-    : !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !jobsOpen && !statuslineOpen && !themeOpen && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === undefined && !approvalPending && !questionPending
+    : !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !languageOpen && !historyOpen && !queueOpen && !agentsOpen && !subagentOpen && !todosOpen && !usageOpen && !verboseOpen && diffView === undefined && !reviewPickerOpen && !approvalPending && !questionPending
+  const transcriptVisible = !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !languageOpen && !historyOpen && !queueOpen && !agentsOpen && !subagentOpen && !todosOpen && !usageOpen && !verboseOpen && diffView === undefined && !reviewPickerOpen && !approvalPending && !questionPending
 
   // Human questions outrank local inspectors. Close the lower modal instead
   // of leaving an approval/question visible but keyboard-locked behind it.
@@ -4927,9 +5579,12 @@ export function App(props: AppProps): ReactElement {
     setPermissionOpen(false)
     setResumeOpen(false)
     setPluginOpen(false)
+    setUpdateOpen(false)
+    setScheduleOpen(false)
     setStatuslineOpen(false)
     setThemeOpen(false)
     setHistoryOpen(false)
+    setQueueOpen(false)
     setAgentsOpen(false)
     setSubagentOpen(false)
     setTodosOpen(false)
@@ -4979,6 +5634,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
@@ -4990,24 +5646,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
@@ -5029,17 +5692,36 @@ export function App(props: AppProps): ReactElement {
   const handleMenuRows = useCallback((rows: number): void => {
     setMenuRows(current => (current === rows ? current : rows))
   }, [])
+  // The status footer's exact row count, reported one-way by StatusLine (the
+  // second row renders only while it has content). The IME cursor anchor
+  // counts every row between the composer caret and Ink's parked cursor: the
+  // status footer plus Ink's own below-frame row. The gutter rows sit ABOVE
+  // the composer and never enter this distance.
+  const [statusBarRows, setStatusBarRows] = useState<1 | 2>(1)
+  const handleStatusRows = useCallback((rows: 1 | 2): void => {
+    setStatusBarRows(current => (current === rows ? current : rows))
+  }, [])
+  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
+  // session title; cleared on unmount so the host shell regains its default.
+  const tabTitle = view.title === '' ? DEFAULT_TERMINAL_TITLE : view.title
+  useTerminalTitle(tabTitle)
   const allLiveLines = useMemo(
     () => view.entries.slice(settled).flatMap(
       // Width shrinks with the real terminal (no 10-column floor: on a
@@ -5081,6 +5763,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
@@ -5088,9 +5774,60 @@ 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 && !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 || jobsOpen || statuslineOpen || themeOpen || historyOpen || agentsOpen || subagentOpen || todosOpen || inspectorVisible || diffView !== undefined || approvalPending || questionPending
+  const modalVisible = modelOpen || helpOpen || modeOpen || permissionOpen || resumeOpen || pluginOpen || updateOpen || scheduleOpen || jobsOpen || statuslineOpen || themeOpen || languageOpen || historyOpen || queueOpen || agentsOpen || subagentOpen || todosOpen || usageOpen || inspectorVisible || diffView !== undefined || reviewPickerOpen || 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
+  // filter with it), so the honest hint names the owner and the way out.
+  const keyboardOwner = approvalPending
+    ? 'the approval prompt'
+    : questionPending
+      ? 'the question'
+      : diffView !== undefined
+        ? 'the diff review'
+        : reviewPickerOpen
+          ? 'the review picker'
+        : modelOpen
+          ? '/model'
+          : helpOpen
+            ? '/help'
+            : modeOpen
+              ? '/mode'
+              : permissionOpen
+                ? '/permission'
+                : resumeOpen
+                  ? '/resume'
+                  : pluginOpen
+                    ? '/plugin'
+                    : updateOpen
+                      ? '/update'
+                      : scheduleOpen
+                        ? '/schedule'
+                        : jobsOpen
+                          ? '/jobs'
+                        : statuslineOpen
+                          ? '/statusline'
+                          : themeOpen
+                            ? '/theme'
+                            : languageOpen
+                              ? '/language'
+                            : historyOpen
+                              ? '/history'
+                              : agentsOpen
+                                ? '/agents'
+                                : subagentOpen
+                                  ? '/subagent'
+                                  : todosOpen
+                                    ? '/todos'
+                                    : usageOpen
+                                      ? '/usage'
+                                      : inspectorVisible
+                                        ? 'history details'
+                                        : undefined
+  const frozenHint = keyboardOwner === undefined
+    ? undefined
+    : `keys go to ${keyboardOwner} · esc ${approvalPending ? 'rejects' : questionPending ? 'cancels' : 'closes'}`
   const closeInspector = useCallback((): void => {
     setVerboseOpen(false)
   }, [])
@@ -5106,6 +5843,18 @@ export function App(props: AppProps): ReactElement {
     }
     setRefreshEpoch(epoch => epoch + 1)
   }
+  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
     synchronizedReplayPending.current = false
@@ -5136,16 +5885,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')
     }
   }
 
@@ -5166,7 +5915,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
@@ -5204,7 +5953,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)
@@ -5220,7 +5969,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),
       })
@@ -5231,13 +5980,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,
@@ -5252,7 +6001,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),
       })
@@ -5266,7 +6015,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),
       })
@@ -5278,42 +6027,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 })
@@ -5346,7 +6095,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
@@ -5413,6 +6162,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,
@@ -5421,6 +6177,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,
@@ -5441,6 +6205,17 @@ 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,
@@ -5453,9 +6228,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),
       })
@@ -5467,7 +6242,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')
@@ -5489,9 +6264,42 @@ export function App(props: AppProps): ReactElement {
         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,
+    updateOpen && !approvalPending && !questionPending
+      ? createElement(UpdatePanel, {
+        probe: props.probeUpdate,
+        apply: props.applyUpdate,
+        notify: (text: string, tone?: NoticeTone) => notify(text, tone),
+        close: () => setUpdateOpen(false),
+      })
+      : undefined,
+    scheduleOpen && !approvalPending && !questionPending
+      ? createElement(SchedulePanel, { rows: () => view.schedules, close: () => setScheduleOpen(false) })
+      : undefined,
     jobsOpen && !approvalPending && !questionPending
       ? createElement(JobsPanel, { load: props.loadJobs, close: () => setJobsOpen(false) })
       : undefined,
@@ -5514,12 +6322,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,
@@ -5547,15 +6379,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),
@@ -5577,12 +6409,19 @@ export function App(props: AppProps): ReactElement {
       createElement(Input, {
         active: inputActive,
         frozen: modalVisible,
+        frozenHint,
         busy,
         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: () => {
@@ -5614,12 +6453,12 @@ export function App(props: AppProps): ReactElement {
               ?? 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) {
@@ -5643,14 +6482,28 @@ 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 } })
@@ -5663,6 +6516,7 @@ export function App(props: AppProps): ReactElement {
           })
         },
         reviewChanges: props.reviewChanges,
+        openReviewPicker: () => setReviewPickerOpen(true),
         deleteConfirm: deleteConfirmId,
         confirmDelete,
         cancelDelete,
@@ -5698,7 +6552,7 @@ export function App(props: AppProps): ReactElement {
         inspectFiles: props.inspectFiles,
         prepareFiles: props.prepareFiles,
         sessionKey: props.sessionKey,
-        cyclePermission: props.cyclePermission,
+        cycleMode: props.cycleMode,
         exportTranscript: props.exportTranscript,
         renameTitle: props.renameTitle,
         copyLastResponse: props.copyLastResponse,
@@ -5706,14 +6560,18 @@ 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,
+        anchorRowsBelow: imeRowsBelowComposer,
+        tabTitle,
         onEditorRows: handleEditorRows,
         onMenuRows: handleMenuRows,
       }),
@@ -5725,15 +6583,17 @@ export function App(props: AppProps): ReactElement {
           branch: props.branch,
           sessionId: props.sessionId,
           title: view.title,
-          plan: view.plan,
+          plan: view.plan || props.pendingPlan === true,
           permission: view.permission !== '' ? view.permission : props.permission,
           sandbox: view.sandbox,
           goal: view.goal === undefined ? undefined : { phase: view.goal.phase, rounds: view.goal.rounds, max: view.goal.max },
         },
         stats: view.stats,
         busy,
+        animated: animations,
         columns: terminalColumns,
         items: statuslineItems,
+        onRows: handleStatusRows,
       }),
     ),
   )