dsh-code 1.0.5 → 1.0.7

package/src/app.ts

@@ -20,7 +20,7 @@ import {
 } from 'react'
 import { Box, Static, Text, useInput, useStdin, useStdout, type Key } from 'ink'
 import type { CommandDescriptor } from '@deepseek-ai/dsh-commands'
-import type { ImageBlock } from '@deepseek-ai/dsh-llm'
+import type { ContentBlock, FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm'
 import type { TodoItem } from '@deepseek-ai/dsh-tool-todo'
 import type { AskUserQuestionAnswerItem, AskUserQuestionItem } from '@deepseek-ai/dsh-user-questions'
 import type { AuthorizationInteraction, AuthorizationStatus } from '@deepseek-ai/dsh-authorization'
@@ -34,14 +34,19 @@ import {
   type ThemeName,
 } from './theme.ts'
 import { ThemePanel } from './theme-panel.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,
   BUSY_CHASE_TICK_MS,
+  CARET_BLINK_TICK_MS,
   caretVisible,
   DEEP_DIVING_SHIMMER_TICK_MS,
   DEEPSEEK_WAVE_TICK_MS,
@@ -56,11 +61,13 @@ import {
   deepDivingSparkColor,
   effortAboveHigh,
   isOfficialDeepSeekLabel,
+  parseAnimationsArgument,
   type DeepseekWaveStyle,
   type DeepseekWaveTier,
 } from './render/animations.ts'
 import type { ApprovalSnapshot, ApprovalStore } from './approval.ts'
-import { submissionPayload, type CommandsView } from './commands.ts'
+import { isSlashLine, submissionPayload, type CommandsView } from './commands.ts'
+import { rankByName } from './render/fuzzy.ts'
 import type { ModelDirectory, ModelRow } from './models.ts'
 import {
   isDeclaredReasoningEfforts,
@@ -77,7 +84,7 @@ 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 { AgentsPanel, editQuery, EffortPanel, HistoryPanel, JobsPanel, ModePanel, PermissionPanel, PluginPanel, ResumePanel, SchedulePanel, StatuslinePanel, runClock, SubagentPanel, type JobRow } from './kernel-panels.ts'
 import type { PresetRow } from './presets.ts'
 import type { PermissionRow } from './permissions.ts'
 import type { PluginRow } from './plugin-inventory.ts'
@@ -100,7 +107,8 @@ import {
 import { ProviderAuthorizationLogoutPanel, ProviderAuthorizationPanel } from './authorization-panel.ts'
 import {
   looksLikeImagePath,
-  parsePastedImagePaths,
+  parsePastedAttachmentPaths,
+  type FilePathInspection,
   type ImagePathInspection,
 } from './attachments.ts'
 
@@ -196,6 +204,7 @@ import {
   editorRowParts,
   insertText,
   type EditResult,
+  type EditorRowModel,
   killToLineEnd,
   killToLineStart,
   moveCursorBy,
@@ -225,9 +234,12 @@ const LOCAL_COMMANDS = [
   { label: '/fork', description: 'fork at the latest completed turn (/fork [event-seq])' },
   { label: '/resume', description: 'browse or switch root sessions (/resume [id|prefix])' },
   { label: '/plugin', description: 'inspect the live plugin composition' },
+  { label: '/update', description: 'update dsh-code, the harness host, and profile plugins in one aligned step' },
   { label: '/jobs', description: 'inspect background jobs' },
+  { label: '/schedule', description: 'inspect active reminders (created through schedule tools)' },
   { label: '/statusline', description: 'customize the status line items' },
   { label: '/theme', description: 'switch the color theme' },
+  { label: '/animation', description: 'toggle timed animations (/animation [on|off])' },
   { label: '/history', description: 'search and recall past prompts' },
   { label: '/agents', description: 'inspect subagent sessions of this conversation' },
   { label: '/todos', description: 'inspect the full todo list' },
@@ -277,10 +289,20 @@ export interface AppProps {
   mode: string
   /** Permission preset selected for the current or pending first session. */
   permission: string
-  /** Submit one line: slash commands to the registry, other text to the agent. */
-  dispatch(text: string, images?: readonly ImageBlock[]): void
-  /** Submit steering: consumed at the running turn's next step boundary. */
-  steer(text: string, images?: readonly ImageBlock[]): void
+  /**
+   * Submit one line: slash commands to the registry, other text to the agent.
+   * The optional origin names the session the submission was composed for —
+   * 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
+  /**
+   * 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
   /** Quit: unmount, flush, and request process exit. */
@@ -293,6 +315,10 @@ export interface AppProps {
   inspectImages(paths: readonly string[]): Promise<readonly ImagePathInspection[]>
   /** Validate, normalize and persist images immediately before submission. */
   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[]>
+  /** Persist non-image files immediately before submission as durable file blocks. */
+  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
   /** The /subagent override label, '' when delegated agents follow the current model. */
@@ -338,8 +364,10 @@ export interface AppProps {
   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
+  /** 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
   /** Export the transcript to a markdown file (/export [path]); reports via notices. */
@@ -369,6 +397,10 @@ export interface AppProps {
   loadPlugins(): readonly PluginRow[]
   /** Caller-visible background jobs (the host jobs registry, read-only). */
   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): Promise<number>
   /** Registers the app's notice channel with the runner (called once on mount). */
   onBridgeReady(bridge: { notify(text: string, tone?: NoticeTone): void }): void
   /** Ordered enabled status items (/statusline config); the runner owns persistence. */
@@ -377,6 +409,11 @@ export interface AppProps {
   saveStatusline(items: readonly string[]): void
   /** Apply and persist one /theme selection; the runner owns the theme.json file. */
   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
   /** Persistent cross-session input history (oldest first); the runner owns the file. */
   history: readonly string[]
   /** Persist one submitted prompt to the global history file. */
@@ -393,12 +430,23 @@ function padColumns(text: string, width: number): string {
   return clipped + ' '.repeat(Math.max(0, width - visibleColumns(clipped)))
 }
 
-/** Interval-driven frame counter for one self-contained animated leaf. */
+/**
+ * Wall-clock frame counter for one self-contained animated leaf. Each fire
+ * derives the tick from elapsed time instead of counting intervals, so a
+ * stretched interval (busy event loop, slow SSH) skips the animation ahead
+ * rather than slowing it down; the tick always tracks real time.
+ */
 function useFrames(intervalMs: number, active = true): number {
   const [tick, setTick] = useState(0)
   useEffect(() => {
     if (!active) return
-    const id = setInterval(() => setTick(current => current + 1), intervalMs)
+    const startedAt = Date.now()
+    setTick(0)
+    const id = setInterval(() => {
+      // Clock setback (NTP resync) must not produce negative ticks — the
+      // blink parity check would flip the caret off for a full period.
+      setTick(Math.max(0, Math.floor((Date.now() - startedAt) / intervalMs)))
+    }, intervalMs)
     return () => {
       clearInterval(id)
     }
@@ -421,15 +469,18 @@ function useStableInput(handler: (input: string, key: Key) => void, active: bool
   useInput(stableHandler, { isActive: active })
 }
 
-/** The original web StateDot chase used by the busy composer marker. */
-function BusyChase(): ReactElement {
-  const tick = useFrames(BUSY_CHASE_TICK_MS)
+/**
+ * The original web StateDot chase used by the busy composer marker. With
+ * animations off it freezes on the first frame (still visibly busy).
+ */
+function BusyChase({ animated = true }: { animated?: boolean }): ReactElement {
+  const tick = useFrames(BUSY_CHASE_TICK_MS, animated)
   return createElement(Text, { color: inkColor(getPalette().brandBright) }, busyChaseFrame(tick) + ' ')
 }
 
-/** Blinking block caret appended to streaming text. */
-function Caret(): ReactElement {
-  const tick = useFrames(530)
+/** Blinking block caret appended to streaming text; solid when frozen. */
+function Caret({ animated = true }: { animated?: boolean }): ReactElement {
+  const tick = useFrames(CARET_BLINK_TICK_MS, animated)
   return createElement(Text, null, caretVisible(tick) ? '▍' : ' ')
 }
 
@@ -440,7 +491,7 @@ function useCursorBlink(active: boolean): { visible: boolean; reset(): void } {
   useEffect(() => {
     setVisible(true)
     if (!active) return
-    const id = setInterval(() => setVisible(current => !current), 530)
+    const id = setInterval(() => setVisible(current => !current), CARET_BLINK_TICK_MS)
     return () => {
       clearInterval(id)
     }
@@ -456,10 +507,12 @@ function useCursorBlink(active: boolean): { visible: boolean; reset(): void } {
  * One bounded line painted with the deep-diving shimmer: a continuously
  * moving blue gradient across graphemes, the `✻` glyph in the breathing
  * spark color. Shared by the busy line and the collapsed thinking marker;
- * always exactly one row (truncate-end) so the live budget stays exact.
+ * always exactly one row (truncate-end) so the live budget stays exact. With
+ * animations off the same spans render in fixed colors — no timer, no
+ * per-frame repaint, the `✻` keeps its highlight.
  */
-function ShimmerLine({ text }: { text: string }): ReactElement {
-  const tick = useFrames(DEEP_DIVING_SHIMMER_TICK_MS)
+function ShimmerLine({ text, animated = true }: { text: string; animated?: boolean }): ReactElement {
+  const tick = useFrames(DEEP_DIVING_SHIMMER_TICK_MS, animated)
   const palette = getPalette()
   const graphemes = splitGraphemes(text)
   return createElement(
@@ -471,7 +524,11 @@ function ShimmerLine({ text }: { text: string }): ReactElement {
         Text,
         {
           key: `${grapheme.start}-${grapheme.end}`,
-          color: inkColor(sparkle ? deepDivingSparkColor(tick, palette.brandDeep, palette.brandBright) : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, palette.brandBright)),
+          color: inkColor(!animated
+            ? (sparkle ? palette.brandBright : palette.brandDeep)
+            : sparkle
+              ? deepDivingSparkColor(tick, palette.brandDeep, palette.brandBright)
+              : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, palette.brandBright)),
           bold: sparkle || undefined,
         },
         grapheme.text,
@@ -486,10 +543,10 @@ function ShimmerLine({ text }: { text: string }): ReactElement {
  * only once the turn has clearly been running (15s) — anchored to `turn/start`
  * so a resumed mid-turn keeps the real time.
  */
-function DeepDivingLine({ since }: { since: number }): ReactElement {
+function DeepDivingLine({ since, animated = true }: { since: number; animated?: boolean }): ReactElement {
   const elapsed = since === 0 ? 0 : Date.now() - since
   const text = elapsed >= 15_000 ? `✻ Deep diving... ${runClock(elapsed)}` : '✻ Deep diving...'
-  return createElement(ShimmerLine, { text })
+  return createElement(ShimmerLine, { text, animated })
 }
 
 /**
@@ -883,6 +940,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':
@@ -924,12 +985,15 @@ function deepseekWaveHues(tier: DeepseekWaveTier): readonly [RgbTriple, RgbTripl
     : [palette.brandBright, palette.code, palette.brandMid]
 }
 
-function StatusLine({ facts, stats, busy, columns, items }: {
+function StatusLine({ facts, stats, busy, columns, items, onRows }: {
   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
 }): ReactElement {
   const layout = useMemo(() => layoutStatusBar(facts, stats, Math.max(8, columns - 2), {
     busy,
@@ -955,6 +1019,13 @@ function StatusLine({ facts, stats, busy, columns, items }: {
     columns,
     items,
   ])
+  // 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[] = []
@@ -1593,38 +1664,52 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
   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)
 
   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') {
+    if (key.escape || (input === 'q' && query === '')) {
       onClose()
       return
     }
-    if (input === 'r') {
+    if (input === 'r' && query === '') {
       onRetry()
       return
     }
@@ -1637,13 +1722,19 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
       onClose()
       return
     }
-    if (rows.length === 0) return
+    const next = editQuery(query, input, key)
+    if (next !== undefined) {
+      setQuery(next)
+      setCursor(0)
+      return
+    }
+    if (filtered.length === 0) return
     if (key.upArrow) {
-      setCursor(cursor > 0 ? cursor - 1 : rows.length - 1)
+      setCursor(cursor > 0 ? cursor - 1 : filtered.length - 1)
       return
     }
     if (key.downArrow) {
-      setCursor(cursor < rows.length - 1 ? cursor + 1 : 0)
+      setCursor(cursor < filtered.length - 1 ? cursor + 1 : 0)
       return
     }
     if (key.pageUp) {
@@ -1651,32 +1742,27 @@ 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(filtered.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 && filtered[cursor] !== undefined) {
+      onSelect(filtered[cursor])
     }
   })
 
   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…'
         : 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))
+          : query === '' ? 'no models' : `no match for '${singleLineText(query)}'`
+      : `❯ ${filtered[cursor]?.modelName ?? filtered[cursor]?.model ?? ''}`
+    const tail = query === ''
+      ? 'type to filter · r retry · esc/q close'
+      : 'backspace edits · esc close'
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`/model · ${state}${providers} · ${tail}`, viewport.contentColumns))
   }
 
   const stateRows: ReactElement[] = directory === undefined && error === undefined
@@ -1697,23 +1783,27 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
           )]),
         ...(rows.length === 0
           ? [createElement(Text, { key: 'empty', dimColor: true, wrap: 'truncate-end' }, '  no models available')]
-          : []),
+          : filtered.length === 0
+            ? [createElement(Text, { key: 'no-match', dimColor: true, wrap: 'truncate-end' }, truncateColumns(`  no models match '${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)
   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)),
+    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns(query === ''
+      ? `/model — select model${rows.length === 0 ? '' : ` · ${cursor + 1}/${rows.length}`}`
+      : `/model — select model · ${filtered.length} of ${rows.length} match '${singleLineText(query)}'`, viewport.contentColumns)),
     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(
@@ -1727,7 +1817,9 @@ 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, { dimColor: true, wrap: 'truncate-end' }, dim(truncateColumns(query === ''
+      ? `type to filter · ↑↓ move · pgup/pgdn page · enter select${onProviders === undefined ? '' : ' · tab providers'} · r retry · esc/q close`
+      : `↑↓ move · pgup/pgdn page · enter select · backspace edits · esc close`, viewport.contentColumns))),
   )
 }
 
@@ -1908,7 +2000,10 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
     const manualKeyConfigured = row.credential?.kind === 'facts' && row.credential.configured
     const showAuthorization = !manualKeyConfigured || authorization?.record.configured === true || authorization?.inFlight === true
     const authLabel = showAuthorization ? ' · ' + providerAuthorizationStatus(authorization) : ''
-    const label = identity + ' · ' + providerStateLabel(row) + authLabel + (row.removable ? ' · custom' : '')
+    // The adapter's configuration diagnostic rides the row (the provider
+    // stays listed and repairable — this is why it did not vanish).
+    const diagnostic = row.diagnostic === undefined ? '' : ' · ! ' + singleLineText(row.diagnostic)
+    const label = identity + ' · ' + providerStateLabel(row) + authLabel + (row.removable ? ' · custom' : '') + diagnostic
     // Configured rows render in the intermediate brand blue so the in-use
     // group reads at a glance; the dormant tail keeps the dim caption gray.
     const idleColor = row.configured ? inkColor(getPalette().brandMid) : inkColor(getPalette().dim)
@@ -2249,7 +2344,9 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
   const keyBullets = '•'.repeat(Math.min([...keyDraft].length, Math.max(1, viewport.contentColumns - 14)))
   const keyRow = createElement(Text, { key: 'key', color: zone === 'key' ? inkColor(getPalette().brandBright) : inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(('  ' + (zone === 'key' ? '>' : ' ') + ' key   ' + keyBullets + (zone === 'key' && !busy ? '▏' : '') + (keyDraft === '' ? ' (' + keyStatus + ')' : busy ? ' saving…' : '')).replace(/ +$/u, ''), viewport.contentColumns))
   const urlRow = createElement(Text, { key: 'url', color: zone === 'url' ? inkColor(getPalette().brandBright) : inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  ' + (zone === 'url' ? '>' : ' ') + ' url   ' + (baseURL === '' ? '(official default)' : baseURL) + (zone === 'url' ? '▏' : ''), viewport.contentColumns))
-  const rowBudget = Math.max(0, viewport.bodyRows - stateRows.length - 3)
+  // The fixed diagnostic row (present only with an adapter error) joins the
+  // same height budget as the state rows — it must never overflow the panel.
+  const rowBudget = Math.max(0, viewport.bodyRows - stateRows.length - (target.diagnostic === undefined ? 0 : 1) - 3)
   const first = selectionWindow(cursor, models.length + 1, rowBudget)
   const modelRows: ReactElement[] = []
   for (let index = first; index < first + Math.max(0, Math.min(models.length + 1 - first, rowBudget)); index += 1) {
@@ -2271,6 +2368,13 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
     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)),
+    // The adapter's configuration diagnostic heads the editor: the provider
+    // is here precisely because it stayed listed for repair.
+    ...(target.diagnostic === undefined ? [] : [createElement(
+      Text,
+      { key: 'diagnostic', color: inkColor(getPalette().warn), wrap: 'truncate-end' },
+      truncateColumns('! ' + displayText(singleLineText(target.diagnostic)), viewport.contentColumns),
+    )]),
     createElement(PanelGap, { visible: viewport.gapRows > 0 }),
     keyRow,
     urlRow,
@@ -2610,6 +2714,197 @@ function waveRowSpans(cells: readonly ComposerCell[]): ReactElement[] {
   return spans
 }
 
+/** Index of the cell STARTING at a display column, if one does. */
+function cellIndexAtColumn(cells: readonly ComposerCell[], target: number): number | undefined {
+  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)
+    if (column > target) return undefined
+  }
+  return undefined
+}
+
+/**
+ * Wall-clock wave frames — strictly ONE sweep per MOUNT; the mount-spanning
+ * one-shot latch (surviving modal unmounts) lives in Input as `wavePlayedKey`.
+ * The first gate-off after the sweep has started (it completed, a turn went
+ * busy, image preparation began, animations were toggled off) latches `done`
+ * for this mount, so the same mount can never resume or replay. A trigger
+ * that lands while the gate is already down stays pending until the gate
+ * rises once, then plays.
+ */
+function useWaveFrames(active: boolean, durationMs: number): { tick: number; done: boolean } {
+  const [tick, setTick] = useState(0)
+  const [done, setDone] = useState(false)
+  const startedRef = useRef(false)
+  useEffect(() => {
+    if (done) return
+    if (!active) {
+      // A sweep that already started is cancelled permanently, never resumed.
+      if (startedRef.current) setDone(true)
+      return
+    }
+    startedRef.current = true
+    const startedAt = Date.now()
+    const id = setInterval(() => {
+      const elapsed = Date.now() - startedAt
+      if (elapsed >= durationMs) {
+        clearInterval(id)
+        setDone(true)
+        return
+      }
+      setTick(Math.max(0, Math.floor(elapsed / DEEPSEEK_WAVE_TICK_MS)))
+    }, DEEPSEEK_WAVE_TICK_MS)
+    return () => {
+      clearInterval(id)
+    }
+  }, [active, durationMs, done])
+  return { tick, done }
+}
+
+/** The wave-painted composer band: everything the sweep needs, as data. */
+interface ComposerWaveProps {
+  /** Wave tier of the applied route (flash / deepseek / unknown). */
+  tier: DeepseekWaveTier
+  /** Ignition style App picked for this trigger. */
+  style: DeepseekWaveStyle
+  /** False while busy, preparing images, or animations are off; the fallback
+   * band renders instead (non-wave routes keep it false permanently). */
+  active: boolean
+  /** The static band to render before, after, and instead of the sweep. */
+  fallback: ReactElement
+  /** Composer band width in columns (terminal width minus the last column). */
+  bandWidth: number
+  /** Ink color of the static band background (the transparent-cell base). */
+  bandBg: string
+  /** The editor's visible physical rows (already windowed). */
+  rows: readonly EditorRowModel[]
+  /** Index of `rows[0]` in the full editor model (keying + caret row math). */
+  windowStart: number
+  /** Absolute caret row in the editor model. */
+  caretRow: number
+  /** The authoritative cursor offset. */
+  cursor: number
+  /** Caret blink visibility (shared with the static path). */
+  caretVisible: boolean
+  /** The draft text (placeholder detection on row 0). */
+  value: string
+  /** Tier prompt glyph and accent color (persistent, like Codex's charge). */
+  promptGlyph: 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
+}
+
+/**
+ * The self-contained wave leaf: it owns its 33ms tick, so the sweep
+ * re-renders ONLY this component at ~30fps — Input's derived editor state
+ * never re-runs per frame. Graphemes stay atomic and every background sample
+ * advances by terminal display columns, so CJK and emoji cannot move the
+ * caret or wrap the band. The duration gate renders the fallback band on the
+ * frame the sweep completes.
+ */
+function ComposerWave(props: ComposerWaveProps): ReactElement {
+  const { tier, style } = props
+  const durationMs = deepseekWaveDuration(tier, style)
+  const { tick, done } = useWaveFrames(props.active, durationMs)
+  // Report the sweep's end exactly once — completion, gate cancellation, or
+  // unmount (a modal opened and froze the composer) — latching Input's
+  // played-key so this trigger can never replay after a remount.
+  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 * DEEPSEEK_WAVE_TICK_MS >= durationMs) return props.fallback
+  const hues = deepseekWaveHues(tier)
+  const bandRgb = getPalette().composerBand
+  const totalBandRows = props.rows.length + 2
+  const waveBg = (row: number, column: number): string => {
+    const rgb = deepseekWaveColumnBg(tick, column, props.bandWidth, tier, style, hues, 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: waveBg(row, column) })
+    }
+    return createElement(Text, { key: `blank-${row}` }, ...waveRowSpans(blanks))
+  }
+  const editorWaveRows = 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: waveBg(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 ? COMPOSER_PLACEHOLDER : parts.after
+    for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {})
+    while (usedColumns < props.bandWidth) push(' ')
+
+    const middleBandRow = Math.floor(totalBandRows / 2)
+    if (bandRow === middleBandRow && deepseekWaveWordVisible(tick, tier, style)) {
+      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))) {
+        for (let at = 0; at < word.length; at += 1) {
+          const cell = cells[indices[at]!]!
+          cell.char = word[at]!
+          cell.width = 1
+          cell.color = inkColor(deepseekWaveWordHue(at, hues))
+          cell.bold = true
+          cell.dim = false
+        }
+      }
+    }
+    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
+      }
+    }
+    return createElement(Text, { key: `editor-${sourceIndex}`, wrap: 'truncate-end' }, ...waveRowSpans(cells))
+  })
+  return createElement(
+    Box,
+    { flexDirection: 'column', width: props.bandWidth },
+    blankBandRow(0),
+    ...editorWaveRows,
+    blankBandRow(totalBandRows - 1),
+  )
+}
+
 /**
  * The Ctrl+O transcript inspector: one selected durable entry at a time,
  * with independent history selection and content scrolling. The complete
@@ -2821,8 +3116,12 @@ export function completionCandidates(
     seen.add(name)
     all.push(candidate)
   }
-  if (prefix === '') return all
-  return all.filter(candidate => candidate.label.slice(1).startsWith(prefix))
+  // Fuzzy ranking (the web menu's discovery feel): the query must be a
+  // case-insensitive ordered subsequence of a name; prefix hits first, then
+  // alignment score, then this composition order. An empty query keeps the
+  // full list.
+  return rankByName(all.map(candidate => ({ name: candidate.label.slice(1), candidate })), prefix)
+    .map(entry => entry.candidate)
 }
 
 /**
@@ -2923,20 +3222,31 @@ interface DraftImage extends ImagePathInspection {
   readonly marker: string
 }
 
+/** One attached non-image file held in the editor until submission persists it. */
+interface DraftFile extends FilePathInspection {
+  /** Visible draft token; deleting it also detaches the hidden path. */
+  readonly marker: string
+}
+
 /**
  * The prompt box: TUI-local slash commands handled locally, other lines
  * dispatched; input editing keeps a cursor with history and completion.
  * 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, cyclePermission, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, waveTier, waveStyle, maxRows, onEditorRows, onMenuRows }: {
+function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openPlugin, openUpdate, openSchedule, openJobs, openStatusline, openTheme, openHistory, openAgents, openSubagent, openTodos, openDelete, openDiff, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, inspectFiles, prepareFiles, cycleMode, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, animations, applyAnimations, waveTier, waveStyle, maxRows, anchorRowsBelow, tabTitle, onEditorRows, onMenuRows, sessionKey }: {
   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, images?: readonly ImageBlock[]): void
-  steer(text: string, images?: readonly ImageBlock[]): void
+  dispatch(text: string, attachments?: readonly ContentBlock[], origin?: string): void
+  steer(text: string, attachments?: readonly ContentBlock[], origin?: string): void
+  /** The full current session identity ('' while pending); the delivery origin. */
+  sessionKey: string
   interrupt(): boolean
   quit(): void
   openModel(): void
@@ -2946,6 +3256,10 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   openPermission(): void
   openResume(): 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
@@ -2981,7 +3295,9 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   loadMentions(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>
   inspectImages(paths: readonly string[]): Promise<readonly ImagePathInspection[]>
   prepareImages(paths: readonly string[], signal?: AbortSignal): Promise<readonly ImageBlock[]>
-  cyclePermission(): string
+  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>
@@ -2999,6 +3315,10 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   historyFill: { text: string; index: number } | undefined
   /** Marks the accepted entry consumed (called after the fill is applied). */
   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
   /** 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"
@@ -3009,14 +3329,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
   /** 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
 }): 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()
@@ -3029,10 +3360,13 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   const [draftImages, setDraftImages] = useState<readonly DraftImage[]>([])
   const draftImagesRef = useRef(draftImages)
   draftImagesRef.current = draftImages
+  const [draftFiles, setDraftFiles] = useState<readonly DraftFile[]>([])
+  const draftFilesRef = useRef(draftFiles)
+  draftFilesRef.current = draftFiles
   const [preparingImages, setPreparingImages] = useState(false)
   const prepareAbortRef = useRef<AbortController | undefined>(undefined)
   const prepareEpochRef = useRef(0)
-  const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages)
+  const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages && animations)
   useEffect(() => () => {
     prepareEpochRef.current += 1
     prepareAbortRef.current?.abort()
@@ -3066,6 +3400,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     const safe = sanitizeDraftText(historyFill.text)
     draftImagesRef.current = []
     setDraftImages([])
+    draftFilesRef.current = []
+    setDraftFiles([])
     valueRef.current = safe
     cursorRef.current = safe.length
     setValue(safe)
@@ -3088,6 +3424,11 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       draftImagesRef.current = next
       return next.length === current.length ? current : next
     })
+    setDraftFiles((current) => {
+      const next = current.filter(file => value.includes(file.marker))
+      draftFilesRef.current = next
+      return next.length === current.length ? current : next
+    })
   }, [value])
 
   // Home/End and the Backspace-vs-Delete family never survive Ink's parser
@@ -3108,6 +3449,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       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)
@@ -3150,13 +3499,19 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     process.platform === 'win32' ? left.toLowerCase() === right.toLowerCase() : left === right
   )
 
-  const uniqueImageMarker = (name: string, source: 'mention' | 'drop', reserved: readonly string[] = []): string => {
+  const uniqueImageMarker = (name: string, source: 'mention' | 'drop', reserved: readonly string[] = [], kind: 'image' | 'file' = 'image'): string => {
     const safeName = singleLineText(sanitizeDraftText(name))
-    const base = source === 'mention' ? `@${safeName}` : `[image: ${safeName}]`
+    const label = kind === 'file' ? 'file' : 'image'
+    const base = source === 'mention' ? `@${safeName}` : `[${label}: ${safeName}]`
     let marker = base
     let suffix = 2
-    while (valueRef.current.includes(marker) || draftImagesRef.current.some(image => image.marker === marker) || reserved.includes(marker)) {
-      marker = source === 'mention' ? `@${safeName} (${suffix})` : `[image: ${safeName} ${suffix}]`
+    const taken = (candidate: string): boolean =>
+      valueRef.current.includes(candidate)
+      || draftImagesRef.current.some(image => image.marker === candidate)
+      || draftFilesRef.current.some(file => file.marker === candidate)
+      || reserved.includes(candidate)
+    while (taken(marker)) {
+      marker = source === 'mention' ? `@${safeName} (${suffix})` : `[${label}: ${safeName} ${suffix}]`
       suffix += 1
     }
     return marker
@@ -3173,27 +3528,44 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     return true
   }
 
-  const insertDroppedImages = (paths: readonly string[]): void => {
+  /**
+   * Attach a paste/drop split into image and non-image paths: images ride the
+   * durable image blocks, files ride the 0.1.5 file blocks, and both register
+   * visible draft markers anchored at the drop point.
+   */
+  const insertDroppedAttachments = (imagePaths: readonly string[], filePaths: readonly string[]): void => {
     const originalValue = valueRef.current
     const originalCursor = cursorRef.current
-    notify(`checking ${paths.length} image${paths.length === 1 ? '' : 's'}…`)
-    void inspectImages(paths).then((inspected) => {
-      const additions: DraftImage[] = []
+    const total = imagePaths.length + filePaths.length
+    if (total === 0) return
+    notify(`checking ${total} attachment${total === 1 ? '' : 's'}…`)
+    void Promise.all([
+      imagePaths.length === 0 ? Promise.resolve([]) : inspectImages(imagePaths),
+      filePaths.length === 0 ? Promise.resolve([]) : inspectFiles(filePaths),
+    ]).then(([inspectedImages, inspectedFiles]) => {
+      const imageAdditions: DraftImage[] = []
+      const fileAdditions: DraftFile[] = []
       const markers: string[] = []
-      for (const inspection of inspected) {
-        if ([...draftImagesRef.current, ...additions].some(image => sameImagePath(image.path, inspection.path))) continue
+      for (const inspection of inspectedImages) {
+        if ([...draftImagesRef.current, ...imageAdditions].some(image => sameImagePath(image.path, inspection.path))) continue
         const marker = uniqueImageMarker(inspection.name, 'drop', markers)
-        additions.push({ ...inspection, marker })
+        imageAdditions.push({ ...inspection, marker })
         markers.push(marker)
       }
-      if (additions.length === 0) {
-        notify('those images are already attached', 'warning')
+      for (const inspection of inspectedFiles) {
+        if ([...draftFilesRef.current, ...fileAdditions].some(file => sameImagePath(file.path, inspection.path))) continue
+        const marker = uniqueImageMarker(inspection.name, 'drop', markers, 'file')
+        fileAdditions.push({ ...inspection, marker })
+        markers.push(marker)
+      }
+      if (imageAdditions.length === 0 && fileAdditions.length === 0) {
+        notify('those attachments are already attached', 'warning')
         return
       }
       const current = valueRef.current
       const anchor = remapStableRange(originalValue, current, { start: originalCursor, end: originalCursor })
       if (anchor === undefined) {
-        notify('draft changed at the image drop point; drop the images again', 'warning')
+        notify('draft changed at the attachment drop point; drop the files again', 'warning')
         return
       }
       const at = anchor.start
@@ -3207,12 +3579,16 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       setValue(edit.value)
       setCursor(nextCursor)
       resetCursorBlink()
-      const nextImages = [...draftImagesRef.current, ...additions]
+      const nextImages = [...draftImagesRef.current, ...imageAdditions]
       draftImagesRef.current = nextImages
       setDraftImages(nextImages)
-      notify(`${additions.length} image${additions.length === 1 ? '' : 's'} ready for the next message`)
+      const nextFiles = [...draftFilesRef.current, ...fileAdditions]
+      draftFilesRef.current = nextFiles
+      setDraftFiles(nextFiles)
+      const count = imageAdditions.length + fileAdditions.length
+      notify(`${count} attachment${count === 1 ? '' : 's'} ready for the next message`)
     }, (reason: unknown) => {
-      notify(`image attachment failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
+      notify(`attachment failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
     })
   }
 
@@ -3253,8 +3629,21 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   const visibleMentionRows = mentionToken !== undefined && isPathLikeMentionQuery(mentionToken.query)
     ? mentionRows.filter(row => row.kind !== 'session')
     : mentionRows
+  // Fuzzy ordering over the upstream candidates (≤20 per page, cheaper than
+  // the slash menu): rows whose name contains the typed query as an ordered
+  // subsequence rise to the top by alignment, and every other upstream row
+  // keeps its place after them — the upstream matcher has its own relevance
+  // semantics (path segments), so ranking reorders but never drops rows. A
+  // path-like query keeps the upstream order entirely.
+  let rankedMentionRows = visibleMentionRows
+  if (mentionToken !== undefined && !isPathLikeMentionQuery(mentionToken.query) && mentionToken.query !== '') {
+    const hits = rankByName(visibleMentionRows.map(row => ({ name: row.label.replace(/^@/u, ''), row })), mentionToken.query)
+      .map(entry => entry.row)
+    const hitSet = new Set(hits)
+    rankedMentionRows = [...hits, ...visibleMentionRows.filter(row => !hitSet.has(row))]
+  }
   const menuRows: readonly CompletionCandidate[] = mentionActive
-    ? visibleMentionRows.map(row => ({
+    ? rankedMentionRows.map(row => ({
       label: row.label.startsWith('@')
         ? row.label
         : `@${row.label}${row.kind === 'directory' ? '/' : ''}`,
@@ -3270,8 +3659,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   /** Accept the highlighted completion-menu candidate into the draft. */
   const acceptMenuCandidate = (): void => {
     if (mentionActive && mentionToken !== undefined) {
-      if (visibleMentionRows.length === 0) return
-      const row = visibleMentionRows[completionIndex % visibleMentionRows.length]
+      if (rankedMentionRows.length === 0) return
+      const row = rankedMentionRows[completionIndex % rankedMentionRows.length]
       if (row !== undefined) {
         if (row.kind === 'file' && row.path !== undefined && looksLikeImagePath(row.path)) {
           const tokenText = value.slice(mentionToken.start, cursor)
@@ -3416,20 +3805,16 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
     notify('image submission cancelled', '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)
@@ -3441,10 +3826,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) => {
@@ -3471,11 +3870,12 @@ 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')
       }
@@ -3510,6 +3910,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         resetCursorBlink()
         draftImagesRef.current = []
         setDraftImages([])
+        draftFilesRef.current = []
+        setDraftFiles([])
         setCompletionIndex(0)
         setDismissedMenuValue(undefined)
       } else {
@@ -3578,15 +3980,29 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
       // completion-inserted trailing space still routes `/quit ` correctly.
       const trimmed = liveValue.trim()
       const text = submissionPayload(liveValue)
-      if (draftImagesRef.current.length > 0) {
+      if (draftImagesRef.current.length > 0 || draftFilesRef.current.length > 0) {
+        // 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')
+        // 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
+        // with the composing session so the runner can drop the stale one.
+        const originSession = sessionKey
         const controller = new AbortController()
         const epoch = prepareEpochRef.current + 1
         prepareEpochRef.current = epoch
         prepareAbortRef.current = controller
         setPreparingImages(true)
-        notify(`processing ${draftImagesRef.current.length} image${draftImagesRef.current.length === 1 ? '' : 's'}…`)
-        const snapshot = draftImagesRef.current
-        void prepareImages(snapshot.map(image => image.path), controller.signal).then((images) => {
+        const imageSnapshot = draftImagesRef.current
+        const fileSnapshot = draftFilesRef.current
+        const total = imageSnapshot.length + fileSnapshot.length
+        notify(`processing ${total} attachment${total === 1 ? '' : 's'}…`)
+        void Promise.all([
+          imageSnapshot.length === 0 ? Promise.resolve([]) : prepareImages(imageSnapshot.map(image => image.path), controller.signal),
+          fileSnapshot.length === 0 ? Promise.resolve([]) : prepareFiles(fileSnapshot.map(file => file.path), controller.signal),
+        ]).then(([images, files]) => {
           if (controller.signal.aborted || prepareEpochRef.current !== epoch) return
           prepareAbortRef.current = undefined
           setPreparingImages(false)
@@ -3596,6 +4012,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
           setCursor(0)
           draftImagesRef.current = []
           setDraftImages([])
+          draftFilesRef.current = []
+          setDraftFiles([])
           setCompletionIndex(0)
           setDismissedMenuValue(undefined)
           dismissNotice()
@@ -3604,13 +4022,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
             recordHistory(text)
           }
           recall.current = beginRecall(recallSpace, '')
-          if (busy) steer(text, images)
-          else dispatch(text, images)
+          const blocks: readonly ContentBlock[] = [...images, ...files]
+          if (busy) steer(text, blocks, originSession)
+          else dispatch(text, blocks, originSession)
         }, (reason: unknown) => {
           if (controller.signal.aborted || prepareEpochRef.current !== epoch) return
           prepareAbortRef.current = undefined
           setPreparingImages(false)
-          notify(`image submission failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
+          notify(`attachment submission failed: ${reason instanceof Error ? reason.message : String(reason)}`, 'error')
         })
         return
       }
@@ -3623,13 +4042,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()
@@ -3721,6 +4139,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
@@ -3733,6 +4159,13 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         openTheme()
         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 applyAnimations(parsed.enabled)
+        return
+      }
       if (text === '/history') {
         openHistory()
         return
@@ -3906,50 +4339,44 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         text = text.replaceAll(PASTE_END_MARKER, '')
       }
       if (text === '') return
-      const droppedPaths = text.length > 1 ? parsePastedImagePaths(text) : []
-      if (droppedPaths.length > 0) {
-        insertDroppedImages(droppedPaths)
-        return
+      if (text.length > 1) {
+        // A path-list paste splits into images and files; prose falls through
+        // as ordinary text (the splitter returns empty groups for non-paths).
+        const dropped = parsePastedAttachmentPaths(text)
+        if (dropped.images.length > 0 || dropped.files.length > 0) {
+          insertDroppedAttachments(dropped.images, dropped.files)
+          return
+        }
       }
       applyEdit(insertText(valueRef.current, cursorRef.current, text))
     }
   }, active)
 
-  // The DeepSeek easter-egg wave owns its 33ms tick HERE instead of in App:
-  // the interval re-renders only the composer band at 30fps, never the whole
-  // tree. App drives the tier/style pair on a model switch; this local effect
-  // starts the sweep whenever that pair changes (App picks a NEW random style
-  // for every replay — including effort changes on the same route — so the
-  // pair always differs when a new wave should run) and stops it when the
-  // route leaves every wave tier (tier becomes null).
-  const [waveTick, setWaveTick] = useState<number | null>(null)
-  const wavePrevious = useRef<{ tier: DeepseekWaveTier | null; style: DeepseekWaveStyle | null }>({ tier: null, style: null })
-  useEffect(() => {
-    const previous = wavePrevious.current
-    wavePrevious.current = { tier: waveTier, style: waveStyle }
-    if (waveTier === null) {
-      setWaveTick(null)
-      return
-    }
-    if (previous.tier !== waveTier || previous.style !== waveStyle) {
-      setWaveTick(0)
-    }
-  }, [waveTier, waveStyle])
-  const waveActive = !preparingImages && waveTick !== null && waveTier !== null && waveStyle !== null
-    && waveTick * DEEPSEEK_WAVE_TICK_MS < deepseekWaveDuration(waveTier, waveStyle)
-  useEffect(() => {
-    if (!waveActive) return
-    const id = setInterval(() => {
-      setWaveTick(current => (current === null ? 0 : current + 1))
-    }, DEEPSEEK_WAVE_TICK_MS)
-    return () => {
-      clearInterval(id)
-    }
-  }, [waveActive])
+  // The DeepSeek easter-egg wave renders through the ComposerWave leaf
+  // below, which owns its 33ms tick: the sweep re-renders only that child at
+  // 30fps — this component's editor model, menu, and derived state never
+  // re-run per frame. App drives the tier/style pair on a model switch, and
+  // the child remounts whenever that pair changes (App picks a NEW random
+  // style for every replay, so the pair always differs when a wave should
+  // run), resetting the timeline to frame 0 before the first paint.
+  //
+  // The sweep is strictly one-shot per trigger, and the latch lives HERE —
+  // not in the leaf — because modal panels freeze the composer and UNMOUNT
+  // ComposerWave; a mount-scoped latch would reset on every panel close and
+  // replay a finished sweep. Keying `wavePlayedKey` by the tier:style pair
+  // survives those unmounts: only a NEW trigger (which always changes the
+  // pair) re-arms the sweep. Busy turns, image preparation, /animation
+  // toggles, and panel open/close on an UNCHANGED model+effort pair never
+  // fire it again.
+  const waveKey = waveTier !== null && waveStyle !== null ? `${waveTier}:${waveStyle}` : null
+  const [wavePlayedKey, setWavePlayedKey] = useState<string | null>(null)
   useEffect(() => {
-    if (waveTick !== null && waveTier !== null && waveStyle !== null
-      && waveTick * DEEPSEEK_WAVE_TICK_MS >= deepseekWaveDuration(waveTier, waveStyle)) setWaveTick(null)
-  }, [waveTick, waveTier, waveStyle])
+    // While animations are off, any pending trigger is consumed silently:
+    // re-enabling must never queue or replay a celebration the user opted
+    // out of watching.
+    if (!animations && waveKey !== null && waveKey !== wavePlayedKey) setWavePlayedKey(waveKey)
+  }, [animations, waveKey, wavePlayedKey])
+  const waveArmed = waveKey !== null && waveKey !== wavePlayedKey
 
   // Every exclusive panel keeps the composer as a stable visual anchor, but
   // freezes it to one row: no menu, multiline wrap, or animation.
@@ -3979,6 +4406,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(() => {
@@ -4014,7 +4452,7 @@ 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,
@@ -4049,7 +4487,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
         ? preparingImages
           ? createElement(Text, { color: inkColor(getPalette().warn), bold: true }, '… ')
           : busy
-            ? createElement(BusyChase)
+            ? createElement(BusyChase, { animated: animations })
             : createElement(Text, { color: promptColor, bold: tierActive ? true : undefined }, `${promptGlyph} `)
         : '  ',
       parts.before,
@@ -4064,104 +4502,35 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
   }
   const staticEditor = createElement(Box, { flexDirection: 'column' }, ...editorRows)
 
-  // The wave paints the SAME visible rows and caret site as the static path.
-  // Graphemes remain atomic and every background sample advances by terminal
-  // display columns, so CJK and emoji cannot move the caret or wrap the band.
-  const waveRow = (): ReactElement => {
-    const hues = deepseekWaveHues(waveTier!)
-    const style = waveStyle!
-    const bandRgb = getPalette().composerBand
-    const visibleRows = editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows)
-    const totalBandRows = visibleRows.length + 2
-    const waveBg = (row: number, column: number): string => {
-      const rgb = deepseekWaveColumnBg(waveTick!, column, bandWidth, waveTier!, style, hues, bandRgb, row, totalBandRows)
-      return rgb === null ? bandBg : inkColor(rgb)
-    }
-    const blankBandRow = (row: number): ReactElement => {
-      const blanks: ComposerCell[] = []
-      for (let column = 0; column < bandWidth; column += 1) {
-        blanks.push({ char: ' ', width: 1, backgroundColor: waveBg(row, column) })
-      }
-      return createElement(Text, { key: `blank-${row}` }, ...waveRowSpans(blanks))
-    }
-    const cellIndexAtColumn = (cells: readonly ComposerCell[], target: number): number | undefined => {
-      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)
-        if (column > target) return undefined
-      }
-      return undefined
-    }
-    const editorWaveRows = visibleRows.map((row, visibleIndex) => {
-      const sourceIndex = editorWindowStart + visibleIndex
-      const bandRow = visibleIndex + 1
-      const parts = editorRowParts(row, sourceIndex, caret.row, clampedCursor)
-      const placeholder = sourceIndex === 0 && value === '' && !busy
-      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: waveBg(bandRow, usedColumns), ...extra })
-        usedColumns += width
-      }
-      if (sourceIndex === 0) {
-        push(promptGlyph, { color: promptColor, bold: true })
-        push(' ', { color: promptColor })
-      } else {
-        push(' ')
-        push(' ')
-      }
-      for (const span of splitGraphemes(parts.before)) push(span.text)
-      if (parts.hasCaret) push(parts.caret, { inverse: cursorVisible })
-      const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after
-      for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {})
-      while (usedColumns < bandWidth) push(' ')
-
-      const middleBandRow = Math.floor(totalBandRows / 2)
-      if (bandRow === middleBandRow && deepseekWaveWordVisible(waveTick!, waveTier!, style)) {
-        const word = waveTier === 'unknown' ? 'Into the Unknown' : 'deepseek'
-        const start = Math.max(2, Math.floor((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))) {
-          for (let at = 0; at < word.length; at += 1) {
-            const cell = cells[indices[at]!]!
-            cell.char = word[at]!
-            cell.width = 1
-            cell.color = inkColor(deepseekWaveWordHue(at, hues))
-            cell.bold = true
-            cell.dim = false
-          }
-        }
-      }
-      if (bandRow === middleBandRow && (waveTier === 'deepseek' || waveTier === 'unknown') && style === 'wave') {
-        const spark = deepseekWaveSpark(waveTick!)
-        const lastIndex = cellIndexAtColumn(cells, bandWidth - 1)
-        if (spark !== null && lastIndex !== undefined && cells[lastIndex]!.char === ' ') {
-          cells[lastIndex]!.char = spark
-          cells[lastIndex]!.color = promptColor
-          cells[lastIndex]!.bold = true
-          cells[lastIndex]!.dim = false
-        }
-      }
-      return createElement(Text, { key: `editor-${sourceIndex}`, wrap: 'truncate-end' }, ...waveRowSpans(cells))
-    })
-    return createElement(
-      Box,
-      { flexDirection: 'column', width: bandWidth },
-      blankBandRow(0),
-      ...editorWaveRows,
-      blankBandRow(totalBandRows - 1),
-    )
-  }
-
+  // The wave paints the SAME visible rows and caret site as the static path
+  // through the ComposerWave leaf (see its comment). The child remounts on
+  // every tier/style change, so its timeline always starts at frame 0, and
+  // its gate cancels — never freezes — the sweep while busy, preparing
+  // images, or animations are off.
   return createElement(
     Box,
     { flexDirection: 'column' },
     menu,
-    waveTick !== null && waveTier !== null && waveStyle !== null && !busy && !preparingImages
-      ? waveRow()
-      : band(staticEditor),
+    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,
+    }),
   )
 }
 
@@ -4431,12 +4800,21 @@ export function App(props: AppProps): ReactElement {
    * to static while the prompt marker keeps the tier accent. The trigger
    * follows the applied model label (what the status bar actually shows),
    * never the initial paint, and the tier is derived from the label and
-   * cached at the switch. The 33ms tick itself lives inside Input, so the
-   * sweep re-renders only the composer band, not the whole tree, at 30fps;
-   * App owns the rarely-changing tier/style and Input starts the sweep
-   * whenever that pair changes. */
+   * cached at the switch. The 33ms tick itself lives inside the ComposerWave
+   * leaf, so the sweep re-renders only the composer band, not the whole tree,
+   * at 30fps; App owns the rarely-changing tier/style and the leaf plays the
+   * sweep exactly ONCE per pair change — an unchanged model+effort pair
+   * (ordinary turns, image preparation, /animation toggles) never replays. */
   const [waveTier, setWaveTier] = useState<DeepseekWaveTier | null>(null)
   const [waveStyle, setWaveStyle] = useState<DeepseekWaveStyle | null>(null)
+  // /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'}`)
+  }
   const previousModel = useRef<string | undefined>(undefined)
   const previousEffort = useRef<string | undefined>(props.effort)
   const previousStyle = useRef<DeepseekWaveStyle | undefined>(undefined)
@@ -4557,6 +4935,8 @@ export function App(props: AppProps): ReactElement {
   const [resumeOpen, setResumeOpen] = useState(false)
   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))
@@ -4636,7 +5016,7 @@ 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 && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === undefined && !approvalPending && !questionPending
 
   // Human questions outrank local inspectors. Close the lower modal instead
   // of leaving an approval/question visible but keyboard-locked behind it.
@@ -4651,6 +5031,8 @@ export function App(props: AppProps): ReactElement {
     setPermissionOpen(false)
     setResumeOpen(false)
     setPluginOpen(false)
+    setUpdateOpen(false)
+    setScheduleOpen(false)
     setStatuslineOpen(false)
     setThemeOpen(false)
     setHistoryOpen(false)
@@ -4668,7 +5050,7 @@ export function App(props: AppProps): ReactElement {
   // contract that lets arbitrarily long conversations scroll instead of
   // freezing when the live tree exceeds the terminal height. The dynamic
   // region below stays small: the streaming tail, modals, composer, and its
-  // status footer. `assistant/chunk` preserves `entries` identity.
+  // status footer. Live stream frames preserve `entries` identity.
   //
   // `computeSettledRows` extends the cached row set incrementally: the
   // settled prefix is permanently final, so a grown boundary builds ONLY the
@@ -4753,6 +5135,16 @@ 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
@@ -4764,6 +5156,10 @@ export function App(props: AppProps): ReactElement {
   const dynamicRows = Math.max(1, terminalRows - 8 - MENU_RESERVE_ROWS - composerGutterRows - (composerRows - 1) - Math.max(0, menuRows - MENU_RESERVE_ROWS))
   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
@@ -4812,9 +5208,55 @@ 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 transcriptVisible = !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === undefined && !approvalPending && !questionPending
   const inspectorVisible = verboseOpen && !approvalPending && !questionPending
-  const modalVisible = modelOpen || helpOpen || modeOpen || permissionOpen || resumeOpen || pluginOpen || 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 || historyOpen || agentsOpen || subagentOpen || todosOpen || inspectorVisible || diffView !== undefined || approvalPending || questionPending
+  // The surface that currently owns the keyboard, named in the frozen band:
+  // an empty composer under a panel must not advertise typing it cannot
+  // accept — every key actually feeds the panel (which may or may not
+  // 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'
+        : modelOpen
+          ? '/model'
+          : helpOpen
+            ? '/help'
+            : modeOpen
+              ? '/mode'
+              : permissionOpen
+                ? '/permission'
+                : resumeOpen
+                  ? '/resume'
+                  : pluginOpen
+                    ? '/plugin'
+                    : updateOpen
+                      ? '/update'
+                      : scheduleOpen
+                        ? '/schedule'
+                        : jobsOpen
+                          ? '/jobs'
+                        : statuslineOpen
+                          ? '/statusline'
+                          : themeOpen
+                            ? '/theme'
+                            : historyOpen
+                              ? '/history'
+                              : agentsOpen
+                                ? '/agents'
+                                : subagentOpen
+                                  ? '/subagent'
+                                  : todosOpen
+                                    ? '/todos'
+                                    : inspectorVisible
+                                      ? 'history details'
+                                      : undefined
+  const frozenHint = keyboardOwner === undefined
+    ? undefined
+    : `keys go to ${keyboardOwner} · esc ${approvalPending ? 'rejects' : questionPending ? 'cancels' : 'closes'}`
   const closeInspector = useCallback((): void => {
     setVerboseOpen(false)
   }, [])
@@ -5114,7 +5556,7 @@ export function App(props: AppProps): ReactElement {
             // marker falls back to the static dim row — same as Deep diving
             // always yields the live region to streaming content.
             : view.streaming === ''
-              ? createElement(ShimmerLine, { text: '✻ Thinking… (Ctrl/Alt+R to expand)' })
+              ? createElement(ShimmerLine, { text: '✻ Thinking… (Ctrl/Alt+R to expand)', animated: animations })
               : createElement(StreamTail, {
                 text: 'Thinking… (Ctrl/Alt+R to expand)',
                 prefix: '✻ ',
@@ -5129,10 +5571,10 @@ export function App(props: AppProps): ReactElement {
             // The same two-column gutter as settled replies: streamed text
             // lands exactly where the assembled message will render.
             { text: view.streaming, dim: false, maxRows: auditedAnswerRows, prefix: '  ' },
-            busy ? createElement(Caret) : undefined,
+            busy ? createElement(Caret, { animated: animations }) : undefined,
           )
           : undefined,
-        deepDivingVisible ? createElement(DeepDivingLine, { since: view.busySince }) : undefined,
+        deepDivingVisible ? createElement(DeepDivingLine, { since: view.busySince, animated: animations }) : undefined,
       )
       : undefined,
     transcriptVisible ? createElement(TodoPanel, { todos: view.todos }) : undefined,
@@ -5216,6 +5658,17 @@ export function App(props: AppProps): ReactElement {
     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,
@@ -5301,6 +5754,7 @@ export function App(props: AppProps): ReactElement {
       createElement(Input, {
         active: inputActive,
         frozen: modalVisible,
+        frozenHint,
         busy,
         descriptors,
         skills,
@@ -5368,6 +5822,8 @@ export function App(props: AppProps): ReactElement {
         openPermission: () => setPermissionOpen(true),
         openResume: () => { setResumeDelete({ mode: false }); setResumeOpen(true) },
         openPlugin: (query = '') => { setPluginQuery(query); setPluginOpen(true) },
+        openUpdate: () => setUpdateOpen(true),
+        openSchedule: () => setScheduleOpen(true),
         openJobs: () => setJobsOpen(true),
         openStatusline: () => setStatuslineOpen(true),
         openTheme: () => setThemeOpen(true),
@@ -5419,7 +5875,10 @@ export function App(props: AppProps): ReactElement {
         loadMentions: props.loadMentions,
         inspectImages: props.inspectImages,
         prepareImages: props.prepareImages,
-        cyclePermission: props.cyclePermission,
+        inspectFiles: props.inspectFiles,
+        prepareFiles: props.prepareFiles,
+        sessionKey: props.sessionKey,
+        cycleMode: props.cycleMode,
         exportTranscript: props.exportTranscript,
         renameTitle: props.renameTitle,
         copyLastResponse: props.copyLastResponse,
@@ -5430,9 +5889,13 @@ export function App(props: AppProps): ReactElement {
         cancelQueued: props.cancelQueued,
         historyFill,
         historyConsumed,
+        animations,
+        applyAnimations,
         waveTier,
         waveStyle,
         maxRows: composerEditorCap,
+        anchorRowsBelow: imeRowsBelowComposer,
+        tabTitle,
         onEditorRows: handleEditorRows,
         onMenuRows: handleMenuRows,
       }),
@@ -5444,7 +5907,7 @@ 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 },
@@ -5453,6 +5916,7 @@ export function App(props: AppProps): ReactElement {
         busy,
         columns: terminalColumns,
         items: statuslineItems,
+        onRows: handleStatusRows,
       }),
     ),
   )