dsh-code 1.0.7 → 1.3.0

package/src/startup.ts

@@ -14,7 +14,7 @@
  *   whose project directory matches the current working directory.
  * - `--session <id>` — create a new session under an explicit identity (the
  *   id must not exist yet).
- * - `--theme <dark|light|auto>` — the color palette; auto follows the
+ * - `--theme <dark|light|prismatic|rainbow|auto>` — the color palette; auto follows the
  *   terminal (dark fallback until OSC-11 detection lands).
  * - no flags — a fresh session with a minted id.
  *
@@ -69,7 +69,7 @@ export function resolveTuiStartup(options: TuiStartupOptions): TuiStartup {
     throw new Error('--mode applies only to a new session; it cannot be combined with --resume or --continue')
   }
   if (options.theme !== undefined && !THEME_NAMES.includes(options.theme)) {
-    throw new Error('--theme must be dark, light, or auto')
+    throw new Error(`--theme must be one of: ${THEME_NAMES.join(', ')}`)
   }
   const input = {
     ...(options.theme === undefined ? {} : { theme: options.theme }),
@@ -99,7 +99,7 @@ function tuiCommand(): Command {
     .option('-c, --continue', 'resume the most recent persisted session for this working directory')
     .option('--session <id>', 'create a new session under this explicit id')
     .option('--mode <preset>', 'agent preset for a newly created session')
-    .option('--theme <name>', 'color theme: dark (default), light, or auto')
+    .option('--theme <name>', 'color theme: dark (default), light, prismatic, rainbow, or auto')
     .option('-i, --image <path>', 'attach an image to the initial prompt (repeatable)', (path, paths: string[]) => [...paths, path], [])
     .argument('[prompt...]', 'initial prompt; sends immediately after startup')
     .addHelpText('after', `

package/src/store.ts

@@ -139,8 +139,26 @@ export function createTranscriptStore(replay?: readonly SessionEvent[]): Transcr
       }
     },
     reset(): void {
+      // /clear wipes settled history but must not drop the live attempt map:
+      // chunk frames after reset still name the same attemptId, and clearing
+      // the map froze the stream until settlement dumped the whole reply.
+      const live = {
+        streaming: acc.streaming,
+        streamingReasoning: acc.streamingReasoning,
+        busy: acc.busy,
+        busySince: acc.busySince,
+        model: acc.model,
+        firstChunkAt: acc.firstChunkAt,
+        stepStart: acc.stepStart,
+      }
       acc = createReplayAccumulator()
-      attemptKeys.clear()
+      acc.streaming = live.streaming
+      acc.streamingReasoning = live.streamingReasoning
+      acc.busy = live.busy
+      acc.busySince = live.busySince
+      acc.model = live.model
+      acc.firstChunkAt = live.firstChunkAt
+      acc.stepStart = live.stepStart
       dirty = true
       notify()
     },

package/src/subagents.ts

@@ -1,229 +1,229 @@
-/**
- * Live subagent activity feed: a bounded, display-only projection of CHILD
- * session events. The transcript store folds only the root session (the
- * durable truth this TUI renders); subagent conversations are their own
- * sessions, and before this module their events were dropped entirely —
- * a running subagent was invisible until its parent tool call settled.
- *
- * This is NOT a second transcript: each child folds to ONE row (label,
- * running state, bounded last-activity text), capped at
- * {@link MAX_SUBAGENT_ROWS}. The cap is a display budget, not a fan-out
- * limit: a new running child evicts the OLDEST settled row when one
- * exists, and while every row is busy the newcomer waits off-screen — but
- * the observed-session total (getTotalSeen) keeps counting, so status
- * totals never under-report the fan-out. Rows are advisory display
- * state, rebuilt from live events; nothing here persists or replays.
- * Notification is coalesced
- * by the same ~16ms frame throttle as the transcript store (per-burst
- * microtask notify chained SyncLane rerenders past React's nested update
- * limit; a bare macrotask merge repaints a whole turn's bursts at once).
- *
- * @module @deepseek-ai/dsh-code/subagents
- */
-
-import type { SessionEvent } from '@deepseek-ai/dsh-session'
-// Type-only import merges the subagent package's SessionEventMap variant
-// ('subagent/catalog') into the union this fold switches on.
-import type {} from '@deepseek-ai/dsh-subagent'
-
-/** Hard row cap: overflow evicts the oldest settled row; a fully busy feed waits. */
-export const MAX_SUBAGENT_ROWS = 8
-
-/** Render frame budget: the notification cadence's upper bound. */
-const NOTIFY_FRAME_MS = 16
-
-/** Bounded last-activity text (plain characters, display-sliced later). */
-const MAX_ACTIVITY_CHARS = 80
-
-/** One live subagent row in the feed. */
-export interface SubagentRow {
-  /** Child session id. */
-  readonly id: string
-  /** Display label (session title when observed, else a short id form). */
-  readonly label: string
-  /** Coarse lifecycle state folded from the child's events. */
-  readonly state: 'running' | 'idle' | 'done'
-  /** Bounded last-activity text for the status line. */
-  readonly activity: string
-  /** Last fold time (ms, event clock) — newest-first ordering key. */
-  readonly updatedAt: number
-}
-
-/** The read-only snapshot surface the renderer subscribes to. */
-export interface SubagentFeedView {
-  /** Subscribe to feed changes; returns the unsubscribe function. */
-  subscribe(listener: () => void): () => void
-  /** Read the current rows (identity-stable between changes). */
-  getSnapshot(): readonly SubagentRow[]
-  /**
-   * Distinct child sessions observed since the last reset. The row cap is
-   * a display budget, not a count of the fan-out; totals surface this.
-   */
-  getTotalSeen(): number
-}
-
-/** Single-line bounded preview of an assembled message's text content. */
-function messagePreview(content: unknown): string {
-  if (!Array.isArray(content)) return 'replied'
-  const texts: string[] = []
-  for (const block of content) {
-    if (texts.join(' ').length >= MAX_ACTIVITY_CHARS) break
-    if (typeof block === 'object' && block !== null) {
-      const { type, text } = block as Record<string, unknown>
-      if (type === 'text' && typeof text === 'string' && text !== '') texts.push(text)
-    }
-  }
-  const joined = texts.join(' ').replace(/\s+/gu, ' ').trim()
-  return joined === '' ? 'replied' : bound(joined)
-}
-
-/** Bound one activity string to the display budget. */
-function bound(text: string): string {
-  const flat = text.replace(/\s+/gu, ' ').trim()
-  return flat.length > MAX_ACTIVITY_CHARS ? `${flat.slice(0, MAX_ACTIVITY_CHARS - 1)}…` : flat
-}
-
-/**
- * Fold one child-session event into its feed row (pure).
- * Unknown event kinds leave the row untouched.
- * @param previous - the row's current state, when any.
- * @param sessionId - the child session id.
- * @param event - the child session event.
- * @returns the next row state.
- */
-export function foldSubagentRow(previous: SubagentRow | undefined, sessionId: string, event: SessionEvent): SubagentRow {
-  const base: SubagentRow = previous ?? {
-    id: sessionId,
-    label: `agent ${sessionId.slice(-6)}`,
-    state: 'running',
-    activity: 'starting…',
-    updatedAt: event.time,
-  }
-  const data = event.data as Record<string, unknown>
-  switch (event.type) {
-    case 'session/title': {
-      const title = data['title']
-      const text = typeof title === 'string' && title.trim() !== '' ? title : undefined
-      return text === undefined || text === base.label ? base : { ...base, label: bound(text), updatedAt: event.time }
-    }
-    case 'request/header':
-      return { ...base, state: 'running', activity: 'working…', updatedAt: event.time }
-    case 'user/message':
-      return { ...base, state: 'running', activity: 'prompted', updatedAt: event.time }
-    case 'assistant/attempt':
-      // Durable logs are settlement-only since session-log v2; an attempt
-      // landing without a surface message means the model is retrying or
-      // recovered from a stream error, so the child stays running.
-      return { ...base, state: 'running', activity: 'thinking…', updatedAt: event.time }
-    case 'subagent/catalog': {
-      // Parent-owned durable discovery fact (0.1.5): the catalog names the
-      // child's mode (one-shot vs continuable) and its authored label — the
-      // most semantic label the row can carry. It is a discovery fact, not a
-      // lifecycle signal: a fresh row starts idle, but a late delivery never
-      // regresses a row that already ran or finished. An unchanged fact keeps
-      // the row's identity (the no-op discipline of the default branch), so
-      // repeated deliveries never churn the snapshot array.
-      const mode = event.data.mode === 'continuable' ? 'continuable' : 'one-shot'
-      const label = event.data.label !== undefined && event.data.label.trim() !== '' ? bound(event.data.label) : undefined
-      const nextLabel = label === undefined ? base.label : label
-      const activity = label === undefined ? `catalog · ${mode}` : `catalog · ${mode} · ${label}`
-      const state = previous === undefined ? 'idle' : base.state
-      if (nextLabel === base.label && state === base.state && activity === base.activity) return base
-      return { ...base, state, label: nextLabel, activity, updatedAt: event.time }
-    }
-    case 'assistant/message':
-      return { ...base, state: 'idle', activity: messagePreview(data['message'] === undefined ? undefined : (data['message'] as { content?: unknown }).content), updatedAt: event.time }
-    case 'tool/call': {
-      const name = typeof data['name'] === 'string' ? data['name'] : 'tool'
-      return { ...base, state: 'running', activity: `tool ${name}`, updatedAt: event.time }
-    }
-    case 'tool/result':
-      return { ...base, state: 'running', activity: 'tool done', updatedAt: event.time }
-    case 'turn/start':
-      return { ...base, state: 'running', activity: base.activity === 'starting…' ? 'working…' : base.activity, updatedAt: event.time }
-    case 'turn/end':
-      return { ...base, state: 'done', activity: 'finished', updatedAt: event.time }
-    default:
-      // Unknown kinds leave the row untouched (identity-stable: a no-op
-      // fold must not churn the snapshot array).
-      return base
-  }
-}
-
-/**
- * Create one subagent feed. `apply` folds a child event (the caller gates
- * which sessions are children); `reset` clears on a session switch. Row
- * order is first-seen; the snapshot array is frozen and only replaced when
- * a row actually changed.
- * @returns the mutable feed handle plus its `SubagentFeedView`.
- */
-export function createSubagentFeed(): SubagentFeedView & {
-  apply(sessionId: string, event: SessionEvent): void
-  reset(): void
-} {
-  let rows: readonly SubagentRow[] = Object.freeze([])
-  const seen = new Set<string>()
-  const listeners = new Set<() => void>()
-  let scheduled = false
-  let lastNotifyAt = 0
-  const notify = (): void => {
-    if (scheduled) return
-    scheduled = true
-    const wait = NOTIFY_FRAME_MS - (Date.now() - lastNotifyAt)
-    const dispatch = (): void => {
-      scheduled = false
-      lastNotifyAt = Date.now()
-      for (const listener of listeners) listener()
-    }
-    if (wait <= 0) setImmediate(dispatch)
-    else setTimeout(dispatch, wait)
-  }
-  return {
-    apply(sessionId: string, event: SessionEvent): void {
-      const index = rows.findIndex(row => row.id === sessionId)
-      const previous = index === -1 ? undefined : rows[index]
-      const next = foldSubagentRow(previous, sessionId, event)
-      if (index !== -1) {
-        if (next === previous) return
-        rows = Object.freeze(rows.map((row, at) => at === index ? next : row))
-        notify()
-        return
-      }
-      // A child this feed has not shown yet: the honest total grows even
-      // when every row is busy; admission then prefers evicting the OLDEST
-      // settled row (idle or done — both are non-running) so a new running
-      // agent never waits on one that already settled.
-      const counted = !seen.has(sessionId)
-      if (counted) seen.add(sessionId)
-      if (rows.length >= MAX_SUBAGENT_ROWS) {
-        const evict = rows.findIndex(row => row.state !== 'running')
-        if (evict === -1) {
-          if (counted) notify()
-          return
-        }
-        rows = Object.freeze([...rows.slice(0, evict), next, ...rows.slice(evict + 1)])
-      } else {
-        rows = Object.freeze([...rows, next])
-      }
-      notify()
-    },
-    reset(): void {
-      seen.clear()
-      if (rows.length === 0) return
-      rows = Object.freeze([])
-      notify()
-    },
-    subscribe(listener: () => void): () => void {
-      listeners.add(listener)
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-    getSnapshot(): readonly SubagentRow[] {
-      return rows
-    },
-    getTotalSeen(): number {
-      return seen.size
-    },
-  }
-}
+/**
+ * Live subagent activity feed: a bounded, display-only projection of CHILD
+ * session events. The transcript store folds only the root session (the
+ * durable truth this TUI renders); subagent conversations are their own
+ * sessions, and before this module their events were dropped entirely —
+ * a running subagent was invisible until its parent tool call settled.
+ *
+ * This is NOT a second transcript: each child folds to ONE row (label,
+ * running state, bounded last-activity text), capped at
+ * {@link MAX_SUBAGENT_ROWS}. The cap is a display budget, not a fan-out
+ * limit: a new running child evicts the OLDEST settled row when one
+ * exists, and while every row is busy the newcomer waits off-screen — but
+ * the observed-session total (getTotalSeen) keeps counting, so status
+ * totals never under-report the fan-out. Rows are advisory display
+ * state, rebuilt from live events; nothing here persists or replays.
+ * Notification is coalesced
+ * by the same ~16ms frame throttle as the transcript store (per-burst
+ * microtask notify chained SyncLane rerenders past React's nested update
+ * limit; a bare macrotask merge repaints a whole turn's bursts at once).
+ *
+ * @module @deepseek-ai/dsh-code/subagents
+ */
+
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+// Type-only import merges the subagent package's SessionEventMap variant
+// ('subagent/catalog') into the union this fold switches on.
+import type {} from '@deepseek-ai/dsh-subagent'
+
+/** Hard row cap: overflow evicts the oldest settled row; a fully busy feed waits. */
+export const MAX_SUBAGENT_ROWS = 8
+
+/** Render frame budget: the notification cadence's upper bound. */
+const NOTIFY_FRAME_MS = 16
+
+/** Bounded last-activity text (plain characters, display-sliced later). */
+const MAX_ACTIVITY_CHARS = 80
+
+/** One live subagent row in the feed. */
+export interface SubagentRow {
+  /** Child session id. */
+  readonly id: string
+  /** Display label (session title when observed, else a short id form). */
+  readonly label: string
+  /** Coarse lifecycle state folded from the child's events. */
+  readonly state: 'running' | 'idle' | 'done'
+  /** Bounded last-activity text for the status line. */
+  readonly activity: string
+  /** Last fold time (ms, event clock) — newest-first ordering key. */
+  readonly updatedAt: number
+}
+
+/** The read-only snapshot surface the renderer subscribes to. */
+export interface SubagentFeedView {
+  /** Subscribe to feed changes; returns the unsubscribe function. */
+  subscribe(listener: () => void): () => void
+  /** Read the current rows (identity-stable between changes). */
+  getSnapshot(): readonly SubagentRow[]
+  /**
+   * Distinct child sessions observed since the last reset. The row cap is
+   * a display budget, not a count of the fan-out; totals surface this.
+   */
+  getTotalSeen(): number
+}
+
+/** Single-line bounded preview of an assembled message's text content. */
+function messagePreview(content: unknown): string {
+  if (!Array.isArray(content)) return 'replied'
+  const texts: string[] = []
+  for (const block of content) {
+    if (texts.join(' ').length >= MAX_ACTIVITY_CHARS) break
+    if (typeof block === 'object' && block !== null) {
+      const { type, text } = block as Record<string, unknown>
+      if (type === 'text' && typeof text === 'string' && text !== '') texts.push(text)
+    }
+  }
+  const joined = texts.join(' ').replace(/\s+/gu, ' ').trim()
+  return joined === '' ? 'replied' : bound(joined)
+}
+
+/** Bound one activity string to the display budget. */
+function bound(text: string): string {
+  const flat = text.replace(/\s+/gu, ' ').trim()
+  return flat.length > MAX_ACTIVITY_CHARS ? `${flat.slice(0, MAX_ACTIVITY_CHARS - 1)}…` : flat
+}
+
+/**
+ * Fold one child-session event into its feed row (pure).
+ * Unknown event kinds leave the row untouched.
+ * @param previous - the row's current state, when any.
+ * @param sessionId - the child session id.
+ * @param event - the child session event.
+ * @returns the next row state.
+ */
+export function foldSubagentRow(previous: SubagentRow | undefined, sessionId: string, event: SessionEvent): SubagentRow {
+  const base: SubagentRow = previous ?? {
+    id: sessionId,
+    label: `agent ${sessionId.slice(-6)}`,
+    state: 'running',
+    activity: 'starting…',
+    updatedAt: event.time,
+  }
+  const data = event.data as Record<string, unknown>
+  switch (event.type) {
+    case 'session/title': {
+      const title = data['title']
+      const text = typeof title === 'string' && title.trim() !== '' ? title : undefined
+      return text === undefined || text === base.label ? base : { ...base, label: bound(text), updatedAt: event.time }
+    }
+    case 'request/header':
+      return { ...base, state: 'running', activity: 'working…', updatedAt: event.time }
+    case 'user/message':
+      return { ...base, state: 'running', activity: 'prompted', updatedAt: event.time }
+    case 'assistant/attempt':
+      // Durable logs are settlement-only since session-log v2; an attempt
+      // landing without a surface message means the model is retrying or
+      // recovered from a stream error, so the child stays running.
+      return { ...base, state: 'running', activity: 'thinking…', updatedAt: event.time }
+    case 'subagent/catalog': {
+      // Parent-owned durable discovery fact (0.1.5): the catalog names the
+      // child's mode (one-shot vs continuable) and its authored label — the
+      // most semantic label the row can carry. It is a discovery fact, not a
+      // lifecycle signal: a fresh row starts idle, but a late delivery never
+      // regresses a row that already ran or finished. An unchanged fact keeps
+      // the row's identity (the no-op discipline of the default branch), so
+      // repeated deliveries never churn the snapshot array.
+      const mode = event.data.mode === 'continuable' ? 'continuable' : 'one-shot'
+      const label = event.data.label !== undefined && event.data.label.trim() !== '' ? bound(event.data.label) : undefined
+      const nextLabel = label === undefined ? base.label : label
+      const activity = label === undefined ? `catalog · ${mode}` : `catalog · ${mode} · ${label}`
+      const state = previous === undefined ? 'idle' : base.state
+      if (nextLabel === base.label && state === base.state && activity === base.activity) return base
+      return { ...base, state, label: nextLabel, activity, updatedAt: event.time }
+    }
+    case 'assistant/message':
+      return { ...base, state: 'idle', activity: messagePreview(data['message'] === undefined ? undefined : (data['message'] as { content?: unknown }).content), updatedAt: event.time }
+    case 'tool/call': {
+      const name = typeof data['name'] === 'string' ? data['name'] : 'tool'
+      return { ...base, state: 'running', activity: `tool ${name}`, updatedAt: event.time }
+    }
+    case 'tool/result':
+      return { ...base, state: 'running', activity: 'tool done', updatedAt: event.time }
+    case 'turn/start':
+      return { ...base, state: 'running', activity: base.activity === 'starting…' ? 'working…' : base.activity, updatedAt: event.time }
+    case 'turn/end':
+      return { ...base, state: 'done', activity: 'finished', updatedAt: event.time }
+    default:
+      // Unknown kinds leave the row untouched (identity-stable: a no-op
+      // fold must not churn the snapshot array).
+      return base
+  }
+}
+
+/**
+ * Create one subagent feed. `apply` folds a child event (the caller gates
+ * which sessions are children); `reset` clears on a session switch. Row
+ * order is first-seen; the snapshot array is frozen and only replaced when
+ * a row actually changed.
+ * @returns the mutable feed handle plus its `SubagentFeedView`.
+ */
+export function createSubagentFeed(): SubagentFeedView & {
+  apply(sessionId: string, event: SessionEvent): void
+  reset(): void
+} {
+  let rows: readonly SubagentRow[] = Object.freeze([])
+  const seen = new Set<string>()
+  const listeners = new Set<() => void>()
+  let scheduled = false
+  let lastNotifyAt = 0
+  const notify = (): void => {
+    if (scheduled) return
+    scheduled = true
+    const wait = NOTIFY_FRAME_MS - (Date.now() - lastNotifyAt)
+    const dispatch = (): void => {
+      scheduled = false
+      lastNotifyAt = Date.now()
+      for (const listener of listeners) listener()
+    }
+    if (wait <= 0) setImmediate(dispatch)
+    else setTimeout(dispatch, wait)
+  }
+  return {
+    apply(sessionId: string, event: SessionEvent): void {
+      const index = rows.findIndex(row => row.id === sessionId)
+      const previous = index === -1 ? undefined : rows[index]
+      const next = foldSubagentRow(previous, sessionId, event)
+      if (index !== -1) {
+        if (next === previous) return
+        rows = Object.freeze(rows.map((row, at) => at === index ? next : row))
+        notify()
+        return
+      }
+      // A child this feed has not shown yet: the honest total grows even
+      // when every row is busy; admission then prefers evicting the OLDEST
+      // settled row (idle or done — both are non-running) so a new running
+      // agent never waits on one that already settled.
+      const counted = !seen.has(sessionId)
+      if (counted) seen.add(sessionId)
+      if (rows.length >= MAX_SUBAGENT_ROWS) {
+        const evict = rows.findIndex(row => row.state !== 'running')
+        if (evict === -1) {
+          if (counted) notify()
+          return
+        }
+        rows = Object.freeze([...rows.slice(0, evict), next, ...rows.slice(evict + 1)])
+      } else {
+        rows = Object.freeze([...rows, next])
+      }
+      notify()
+    },
+    reset(): void {
+      seen.clear()
+      if (rows.length === 0) return
+      rows = Object.freeze([])
+      notify()
+    },
+    subscribe(listener: () => void): () => void {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    getSnapshot(): readonly SubagentRow[] {
+      return rows
+    },
+    getTotalSeen(): number {
+      return seen.size
+    },
+  }
+}

package/src/terminal-title.ts

@@ -74,6 +74,25 @@ export function clearTerminalTitleSequence(): string {
   return '\x1b]0;\x07'
 }
 
+/**
+ * Resolve the VS Code stable user-settings file for one platform and
+ * environment: `%APPDATA%` on Windows, the bundle data folder on macOS (NOT
+ * XDG `~/.config` — VS Code never reads that path there, so writing it
+ * silently no-ops and the tab kept showing the process name "node"), and
+ * XDG config on Linux.
+ */
+export function vscodeSettingsPath(platform: NodeJS.Platform, env: NodeJS.ProcessEnv): string | undefined {
+  const windows = platform === 'win32'
+  const darwin = platform === 'darwin'
+  const base = windows ? env['APPDATA'] : env['HOME']
+  if (base === undefined || base === '') return undefined
+  return windows
+    ? join(base, 'Code', 'User', 'settings.json')
+    : darwin
+      ? join(base, 'Library', 'Application Support', 'Code', 'User', 'settings.json')
+      : join(base, '.config', 'Code', 'User', 'settings.json')
+}
+
 /** Outcome of the VS Code settings alignment. */
 export interface VsCodeTitleSettingResult {
   wrote: boolean
@@ -98,11 +117,9 @@ export function ensureVsCodeTabTitleSetting(options: {
   if ((options.isTTY ?? process.stdout.isTTY) !== true) return { wrote: false, reason: 'not-vscode' }
   let file = options.settingsFile
   if (file === undefined) {
-    const base = process.platform === 'win32' ? env['APPDATA'] : env['HOME']
-    if (base === undefined || base === '') return { wrote: false, reason: 'error' }
-    file = process.platform === 'win32'
-      ? join(base, 'Code', 'User', 'settings.json')
-      : join(base, '.config', 'Code', 'User', 'settings.json')
+    const resolved = vscodeSettingsPath(process.platform, env)
+    if (resolved === undefined) return { wrote: false, reason: 'error' }
+    file = resolved
   }
   try {
     if (!existsSync(file)) {

package/src/theme-panel.ts

@@ -11,14 +11,9 @@ import { createElement, useState, type ReactElement } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink'
 import { clampScroll, panelViewport } from './render/inspector.ts'
 import { truncateColumns } from './render/text.ts'
-import { getPalette, inkColor, type ThemeName } from './theme.ts'
-
-/** The three theme rows in canonical order (the /theme selection surface). */
-const THEME_ROWS: readonly { id: ThemeName; label: string; description: string }[] = [
-  { id: 'dark', label: 'dark', description: 'DeepSeek dark palette (default)' },
-  { id: 'light', label: 'light', description: 'light palette for bright terminals' },
-  { id: 'auto', label: 'auto', description: 'follow the terminal; dark until detection lands' },
-]
+import { panelAccent } from './panel-accent.ts'
+import { getPalette, inkColor, THEMES, type ThemeName } from './theme.ts'
+import { t } from './i18n.ts'
 
 /**
  * The /theme list: one row per theme, the current one marked with ●, the
@@ -30,37 +25,38 @@ export function ThemePanel({ current, select, close }: {
   /** Theme name in force (the requested name; 'auto' included). */
   current: ThemeName
   /** Accept one theme name: applied immediately and persisted by the runner. */
-  select(name: ThemeName): void
+  select: (name: ThemeName) => void
   /** Close without changing the theme. */
-  close(): void
+  close: () => void
 }): ReactElement {
   const [cursor, setCursor] = useState(() => {
-    const index = THEME_ROWS.findIndex(theme => theme.id === current)
+    const index = THEMES.findIndex(theme => theme.id === current)
     return index < 0 ? 0 : index
   })
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
   useInput((input, key) => {
     if (key.escape || input === 'q') return close()
-    if (key.upArrow) return setCursor(value => (value + THEME_ROWS.length - 1) % THEME_ROWS.length)
-    if (key.downArrow) return setCursor(value => (value + 1) % THEME_ROWS.length)
-    if (key.return) return select(THEME_ROWS[cursor]!.id)
+    if (key.upArrow) return setCursor(value => (value + THEMES.length - 1) % THEMES.length)
+    if (key.downArrow) return setCursor(value => (value + 1) % THEMES.length)
+    if (key.return) return select(THEMES[cursor].id)
   })
   if (viewport.maxHeight === 0 || viewport.compact) {
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('/theme · esc close', viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('theme.compact'), viewport.contentColumns))
   }
   // The theme rows share the panel's body budget like every other panel: an
   // unsliced three-row list reached terminal-height equality on short
   // terminals, where Ink rewrites the whole Static region every frame.
   // Reveal-cursor slicing keeps the focused row visible instead.
   const rowBudget = Math.max(1, viewport.bodyRows)
-  const first = clampScroll(cursor, THEME_ROWS.length, rowBudget)
-  const visibleThemes = THEME_ROWS.slice(first, first + rowBudget)
-  const hiddenThemes = THEME_ROWS.length - visibleThemes.length
+  const first = clampScroll(cursor, THEMES.length, rowBudget)
+  const visibleThemes = THEMES.slice(first, first + rowBudget)
+  const hiddenThemes = THEMES.length - visibleThemes.length
+  const accent = panelAccent('theme', getPalette().dim, getPalette().brandBright)
   return createElement(
     Box,
-    { width: viewport.outerColumns, borderStyle: 'round', borderColor: inkColor(getPalette().dim), flexDirection: 'column', paddingX: 1 },
-    createElement(Text, { color: inkColor(getPalette().brandBright), wrap: 'truncate-end' }, truncateColumns('/theme — color palette', viewport.contentColumns)),
+    { width: viewport.outerColumns, borderStyle: 'round', borderColor: inkColor(accent.border), flexDirection: 'column', paddingX: 1 },
+    createElement(Text, { color: inkColor(accent.title), wrap: 'truncate-end' }, truncateColumns(t('theme.title'), viewport.contentColumns)),
     ...visibleThemes.map((theme, index) => {
       const selected = first + index === cursor
       const active = theme.id === current
@@ -71,7 +67,7 @@ export function ThemePanel({ current, select, close }: {
           color: selected ? inkColor(getPalette().brandBright) : undefined,
           wrap: 'truncate-end',
         },
-        truncateColumns(`${selected ? '› ' : '  '}${active ? '● ' : '○ '}${theme.label}${active ? ' · current' : ''} · ${theme.description}`, viewport.contentColumns),
+        truncateColumns(`${selected ? '› ' : '  '}${active ? '● ' : '○ '}${t(`theme.${theme.id}.label`)}${active ? ` · ${t('theme.current')}` : ''} · ${t(`theme.${theme.id}.description`)}`, viewport.contentColumns),
       )
     }),
     createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns(`↑↓ choose · enter apply · esc/q close${hiddenThemes > 0 ? ` · +${hiddenThemes} more` : ''}`, viewport.contentColumns)),