dsh-code 1.0.4 → 1.0.6

package/src/app.ts

@@ -20,8 +20,8 @@ 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 { TodoItem } from '@deepseek-ai/dsh-session'
+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'
 import {
@@ -42,6 +42,7 @@ 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 +57,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,
@@ -100,7 +103,8 @@ import {
 import { ProviderAuthorizationLogoutPanel, ProviderAuthorizationPanel } from './authorization-panel.ts'
 import {
   looksLikeImagePath,
-  parsePastedImagePaths,
+  parsePastedAttachmentPaths,
+  type FilePathInspection,
   type ImagePathInspection,
 } from './attachments.ts'
 
@@ -196,6 +200,7 @@ import {
   editorRowParts,
   insertText,
   type EditResult,
+  type EditorRowModel,
   killToLineEnd,
   killToLineStart,
   moveCursorBy,
@@ -228,6 +233,7 @@ const LOCAL_COMMANDS = [
   { 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' },
@@ -277,10 +283,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 +309,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. */
@@ -377,6 +397,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 +418,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 +457,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 +479,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 +495,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 +512,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 +531,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 })
 }
 
 /**
@@ -1908,7 +1953,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 +2297,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 +2321,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 +2667,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 +3069,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 +3175,28 @@ 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, 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 }: {
   active: boolean
   frozen: boolean
   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
@@ -2981,6 +3241,8 @@ 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[]>
+  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
@@ -2999,6 +3261,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"
@@ -3029,10 +3295,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 +3335,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 +3359,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
@@ -3150,13 +3426,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 +3455,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 +3506,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 +3556,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 +3586,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)
@@ -3510,6 +3826,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 +3896,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 +3928,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 +3938,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
       }
@@ -3733,6 +4068,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 +4248,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.
@@ -4049,7 +4385,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 +4400,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 +4698,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)
@@ -4668,7 +4944,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
@@ -5114,7 +5390,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 +5405,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,
@@ -5419,6 +5695,9 @@ export function App(props: AppProps): ReactElement {
         loadMentions: props.loadMentions,
         inspectImages: props.inspectImages,
         prepareImages: props.prepareImages,
+        inspectFiles: props.inspectFiles,
+        prepareFiles: props.prepareFiles,
+        sessionKey: props.sessionKey,
         cyclePermission: props.cyclePermission,
         exportTranscript: props.exportTranscript,
         renameTitle: props.renameTitle,
@@ -5430,6 +5709,8 @@ export function App(props: AppProps): ReactElement {
         cancelQueued: props.cancelQueued,
         historyFill,
         historyConsumed,
+        animations,
+        applyAnimations,
         waveTier,
         waveStyle,
         maxRows: composerEditorCap,