dsh-code 1.0.6 → 1.2.0

package/src/update-panel.ts

@@ -0,0 +1,256 @@
+/**
+ * The /update panel: one bounded surface over the launcher update
+ * pipeline. The panel never decides versions itself — it renders the
+ * launcher `update --json` probe (plan plus refusals), takes one
+ * confirmation, then streams `update --apply` progress and reports the
+ * result with a restart hint. Every alignment guarantee (host pinned to
+ * the release peers line, companion plugins carried, downgrade and
+ * local-checkout refusals) lives in the launcher and is only displayed
+ * here.
+ */
+
+import { createElement, useEffect, useState, type ReactElement } from 'react'
+import { Box, Text, useInput, useStdout } from 'ink'
+import type { LauncherUpdateStatus } from './update.ts'
+import { clampScroll, panelViewport } from './render/inspector.ts'
+import { singleLineText, truncateColumns } from './render/text.ts'
+import { panelAccent } from './panel-accent.ts'
+import { getPalette, inkColor } from './theme.ts'
+import { t } from './i18n.ts'
+
+/** Retained apply-progress lines (ring tail; npm output is ephemeral). */
+export const UPDATE_OUTPUT_CAP = 800
+
+/** Keep the newest UPDATE_OUTPUT_CAP lines of streamed update output. */
+export function clipUpdateLines(lines: readonly string[]): readonly string[] {
+  return lines.length <= UPDATE_OUTPUT_CAP ? lines : lines.slice(lines.length - UPDATE_OUTPUT_CAP)
+}
+
+/** One display row of the update surface. */
+export interface UpdateRow {
+  readonly key: string
+  readonly text: string
+  readonly tone?: 'ok' | 'warn' | 'error' | 'dim'
+}
+
+/** The plan view derived from one probe: facts to show and whether apply may run. */
+export interface UpdatePlanView {
+  readonly rows: readonly UpdateRow[]
+  readonly runnable: boolean
+}
+
+/** Rendered facts of one probe: current/target versions, actions, refusals. */
+export function updatePlanView(status: LauncherUpdateStatus): UpdatePlanView {
+  const rows: UpdateRow[] = []
+  const latest = status.code.latest ?? 'unknown'
+  rows.push(status.aheadOfRegistry === true
+    ? { key: 'code', text: `dsh-code    ${status.code.running} (newer than npm ${latest})` }
+    : status.code.latest !== null && status.code.latest === status.code.running
+      ? { key: 'code', text: `dsh-code    ${status.code.running} (latest)` }
+      : { key: 'code', text: `dsh-code    ${status.code.running} → ${latest}` })
+  if (status.host.targetLine === null) {
+    rows.push({ key: 'host', text: 'harness     pinned line unreadable — update would install @deepseek-ai/dsh@latest', tone: 'warn' })
+  } else if (status.host.installed === null) {
+    rows.push({ key: 'host', text: `harness     not installed → ${status.host.targetLine}` })
+  } else if (status.host.installed === status.host.targetLine) {
+    rows.push({ key: 'host', text: `harness     ${status.host.installed} (on pinned line)` })
+  } else {
+    rows.push({ key: 'host', text: `harness     ${status.host.installed} → ${status.host.targetLine}` })
+  }
+  const mounted = status.profile.mounted === null
+    ? status.profile.spec ?? 'not mounted'
+    : `dsh-code ${status.profile.mounted}`
+  rows.push({
+    key: 'profile',
+    text: `profile     ${mounted}${status.profile.localCheckout ? ' · local checkout' : ''}`,
+    tone: status.profile.localCheckout ? 'dim' : undefined,
+  })
+  for (const plugin of status.plan.pluginSpecs) {
+    rows.push({ key: `plugin:${plugin}`, text: `plugin      ${plugin}`, tone: 'dim' })
+  }
+  // A blocker key may be absent entirely (JSON.stringify drops undefined);
+  // a missing value reads as "no blocker", never as an undefined row body.
+  const registryBlocker = status.blockers.registry ?? null
+  if (registryBlocker !== null) {
+    rows.push({ key: 'blocker:registry', text: registryBlocker, tone: 'error' })
+  }
+  if (status.blockers.downgrade) {
+    rows.push({
+      key: 'blocker:downgrade',
+      text: `refusing to downgrade the host: dsh-code@${latest} needs ${status.host.targetLine ?? 'the pinned line'}, but ${status.host.installed ?? 'the installed host'} is newer — wait for the next dsh-code release`,
+      tone: 'error',
+    })
+  }
+  const checkoutBlocker = status.blockers.localCheckout ?? null
+  if (checkoutBlocker !== null) {
+    for (const [index, line] of checkoutBlocker.entries()) {
+      rows.push({ key: `blocker:checkout:${index}`, text: line, tone: 'error' })
+    }
+  }
+  if (status.aheadOfRegistry === true) {
+    rows.push({ key: 'ahead', text: 'this install is newer than npm latest — refusing to downgrade', tone: 'warn' })
+  } else if (status.upToDate) {
+    rows.push({ key: 'uptodate', text: 'everything is already on the pinned line — nothing to update', tone: 'ok' })
+  }
+  const runnable = status.upToDate !== true
+    && registryBlocker === null
+    && status.blockers.downgrade !== true
+    && checkoutBlocker === null
+  return { rows, runnable }
+}
+
+/** Panel lifecycle phases; the footer names the keys each phase accepts. */
+export type UpdatePhase = 'probe' | 'error' | 'plan' | 'apply' | 'done'
+
+/** Footer hint line per phase; the plan phase names the confirm key only when runnable. */
+export function updateFooter(phase: UpdatePhase, runnable: boolean, upToDate: boolean, aheadOfRegistry = false): string {
+  if (phase === 'probe') return t('panel.update.footer.probe')
+  if (phase === 'error') return t('panel.update.footer.error')
+  if (phase === 'apply') return t('panel.update.footer.apply')
+  if (phase === 'done') return t('panel.update.footer.error')
+  if (aheadOfRegistry) return t('panel.update.footer.ahead')
+  if (upToDate) return t('panel.update.footer.current')
+  return runnable ? t('panel.update.footer.update') : t('panel.update.footer.blocked')
+}
+
+/**
+ * The /update surface: probe on open (and on r), confirm with enter/y,
+ * stream the aligned apply, and land on a bounded result view. Escape is
+ * locked while the apply child runs — killing npm mid-install is exactly
+ * the half-updated state this command exists to prevent.
+ */
+export function UpdatePanel({ probe, apply, close, notify }: {
+  /** Read-only probe of the launcher update status (never installs). */
+  probe: () => Promise<LauncherUpdateStatus>
+  /** Run the aligned update; streams sanitized progress lines. */
+  apply: (onLine: (line: string) => void, plan: LauncherUpdateStatus['plan']) => Promise<number>
+  /** Close the panel (App keeps ownership of the flag). */
+  close: () => void
+  /** One bounded cross-surface notice (phase completions). */
+  notify: (text: string, tone?: 'info' | 'warning' | 'error') => void
+}): ReactElement {
+  const [phase, setPhase] = useState<UpdatePhase>('probe')
+  const [status, setStatus] = useState<LauncherUpdateStatus>()
+  const [probeError, setProbeError] = useState<string>()
+  const [lines, setLines] = useState<readonly string[]>([])
+  const [exit, setExit] = useState<number>()
+  const [applyError, setApplyError] = useState<string>()
+  // Viewport anchor: 'tail' follows new output; a number pins the first
+  // visible row (up moves away from the tail, down onto it re-follows).
+  const [anchor, setAnchor] = useState<'tail' | number>('tail')
+  const [epoch, setEpoch] = useState(0)
+  useEffect(() => {
+    let disposed = false
+    setPhase('probe')
+    setStatus(undefined)
+    setProbeError(undefined)
+    setAnchor('tail')
+    probe().then(value => {
+      if (disposed) return
+      setStatus(value)
+      setPhase('plan')
+    }, reason => {
+      if (disposed) return
+      setProbeError(reason instanceof Error ? reason.message : String(reason))
+      setPhase('error')
+    })
+    return () => { disposed = true }
+  }, [epoch, probe])
+  const stdout = useStdout().stdout
+  const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
+  const start = (): void => {
+    if (phase !== 'plan' || status === undefined) return
+    if (!updatePlanView(status).runnable) return
+    setPhase('apply')
+    setLines([])
+    setExit(undefined)
+    setApplyError(undefined)
+    setAnchor('tail')
+    apply(line => {
+      setLines(previous => clipUpdateLines([...previous, singleLineText(line)]))
+    }, status.plan).then(code => {
+      setExit(code)
+      setPhase('done')
+      notify(code === 0 ? 'update installed — restart dsh to activate' : `update failed (exit ${code})`, code === 0 ? 'info' : 'error')
+    }, reason => {
+      const message = reason instanceof Error ? reason.message : String(reason)
+      setApplyError(message)
+      setPhase('done')
+      notify(`update failed: ${message}`, 'error')
+    })
+  }
+  const planView = status === undefined ? undefined : updatePlanView(status)
+  const rows: readonly UpdateRow[] = phase === 'probe'
+    ? [{ key: 'probe', text: 'checking npm for the aligned update…', tone: 'dim' }]
+    : phase === 'error'
+      ? [{ key: 'error', text: singleLineText(probeError ?? 'probe failed'), tone: 'error' }]
+      : phase === 'plan' && planView !== undefined
+        ? planView.rows
+        : phase === 'apply'
+          ? lines.map((line, index) => ({ key: `out:${index}`, text: line, tone: 'dim' as const }))
+          : [
+            ...(exit === 0 ? [{ key: 'ok', text: 'update installed — restart dsh to load the new version (/quit or ctrl+c)', tone: 'ok' as const }] : []),
+            ...(exit !== undefined && exit !== 0 ? [{ key: 'fail', text: `update failed (exit ${exit})`, tone: 'error' as const }] : []),
+            ...(applyError !== undefined ? [{ key: 'fail:start', text: singleLineText(applyError), tone: 'error' as const }] : []),
+            ...lines.map((line, index) => ({ key: `out:${index}`, text: line, tone: 'dim' as const })),
+          ]
+  const budget = Math.max(1, viewport.bodyRows)
+  const tailOffset = clampScroll(Math.max(0, rows.length - budget), rows.length, budget)
+  const offset = anchor === 'tail' ? tailOffset : clampScroll(anchor, rows.length, budget)
+  useInput((input, key) => {
+    if (phase === 'apply') {
+      // Scroll-only while the installer runs: escape stays locked.
+      if (key.upArrow) setAnchor(offset <= 0 ? 0 : offset - 1)
+      if (key.downArrow && offset >= tailOffset) setAnchor('tail')
+      else if (key.downArrow) setAnchor(offset + 1)
+      return
+    }
+    if (key.escape || input === 'q') return close()
+    if (input === 'r') {
+      setEpoch(value => value + 1)
+      return
+    }
+    if (key.return || input === 'y') {
+      void start()
+      return
+    }
+    if (key.upArrow) setAnchor(offset <= 0 ? 0 : offset - 1)
+    if (key.downArrow && offset >= tailOffset) setAnchor('tail')
+    else if (key.downArrow) setAnchor(offset + 1)
+  })
+  if (viewport.maxHeight === 0 || viewport.compact) {
+    const summary = phase === 'probe' ? t('panel.update.checking')
+      : phase === 'error' ? t('panel.update.probeFailed')
+      : phase === 'apply' ? singleLineText(lines[lines.length - 1] ?? t('panel.update.updating'))
+      : phase === 'done' ? (exit === 0 ? t('panel.update.installed') : t('panel.update.failed'))
+      : status?.aheadOfRegistry === true ? t('panel.update.aheadOfNpm') : status?.upToDate === true ? t('panel.update.upToDate') : planView?.runnable === true ? t('panel.update.enter') : t('panel.update.blocked')
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(singleLineText(t('panel.update.compact', { summary })), viewport.contentColumns))
+  }
+  const visible = rows.slice(offset, offset + budget)
+  const toneColor = (tone: UpdateRow['tone']): ReturnType<typeof inkColor> | undefined => tone === 'ok'
+    ? inkColor(getPalette().success)
+    : tone === 'error'
+    ? inkColor(getPalette().error)
+    : tone === 'warn'
+    ? inkColor(getPalette().warn)
+    : tone === 'dim'
+    ? inkColor(getPalette().dim)
+    : undefined
+  const title = status === undefined
+    ? t('panel.update.title')
+    : status.aheadOfRegistry === true
+      ? `/update · dsh-code ${status.code.running}`
+      : `/update · dsh-code ${status.code.running}${status.code.latest !== null && status.code.latest !== status.code.running ? ` → ${status.code.latest}` : ''}`
+  const accent = panelAccent('update', getPalette().dim, getPalette().brandBright)
+  return createElement(
+    Box,
+    { width: viewport.outerColumns, borderStyle: 'round', borderColor: inkColor(accent.border), flexDirection: 'column', paddingX: 1 },
+    createElement(Text, { color: inkColor(accent.title), wrap: 'truncate-end' }, truncateColumns(singleLineText(title), viewport.contentColumns)),
+    ...visible.map(row => createElement(Text, {
+      key: row.key,
+      color: toneColor(row.tone),
+      wrap: 'truncate-end',
+    }, truncateColumns(`  ${singleLineText(row.text)}`, viewport.contentColumns))),
+    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns(singleLineText(updateFooter(phase, planView?.runnable ?? false, status?.upToDate === true, status?.aheadOfRegistry === true)), viewport.contentColumns)),
+  )
+}

package/src/update.ts

@@ -0,0 +1,126 @@
+/**
+ * Child-process adapter for the launcher update pipeline. The launcher
+ * (bin/deepseek.mjs) stays the single owner of update semantics — plan,
+ * guards, and the aligned install sequence — so the TUI only spawns
+ * `update --json` (read-only probe) and `update --apply` (streamed run)
+ * and never re-implements version-line decisions.
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+/** Spawn double acceptable to the adapter (tests inject an EventEmitter). */
+export type SpawnLike = (command: string, args: readonly string[], options: { readonly stdio: readonly string[]; readonly windowsHide: boolean }) => ChildProcess
+
+/** Structured `update --json` payload; mirrors the launcher buildUpdateStatus. */
+export interface LauncherUpdateStatus {
+  readonly code: { readonly running: string; readonly latest: string | null }
+  readonly host: { readonly installed: string | null; readonly targetLine: string | null }
+  readonly profile: { readonly spec: string | null; readonly mounted: string | null; readonly localCheckout: boolean }
+  readonly plan: { readonly dshSpec: string; readonly codeSpec: string; readonly pluginSpecs: readonly string[] }
+  readonly blockers: { readonly registry: string | null; readonly downgrade: boolean; readonly localCheckout: readonly string[] | null }
+  readonly upToDate: boolean
+  /** True when this install is newer than npm latest (apply would downgrade). */
+  readonly aheadOfRegistry?: boolean
+}
+
+/** Exact specs the TUI confirmed; apply must install these, not re-query latest. */
+export interface LauncherUpdatePlan {
+  readonly dshSpec: string
+  readonly codeSpec: string
+  readonly pluginSpecs: readonly string[]
+}
+
+/** The launcher entrypoint that ships beside this bundle (lib/../bin). */
+export function launcherUpdateCommand(args: readonly string[], moduleUrl: string = import.meta.url): { readonly command: string; readonly args: string[] } {
+  return { command: process.execPath, args: [fileURLToPath(new URL('../bin/deepseek.mjs', moduleUrl)), ...args] }
+}
+
+/**
+ * Split a streamed chunk sequence into complete display lines: CR is
+ * stripped, a chunk boundary may split a line, and the trailing partial
+ * stays pending until its newline arrives (npm writes whole lines, but a
+ * pipe may cut anywhere). Blank lines carry no progress information and
+ * are dropped so the panel budget is not spent on gaps.
+ */
+export function createLineSplitter(onLine: (line: string) => void): (chunk: string) => void {
+  let pending = ''
+  return chunk => {
+    pending += chunk
+    for (let index = pending.indexOf('\n'); index >= 0; index = pending.indexOf('\n')) {
+      const line = pending.slice(0, index).replace(/\r$/u, '')
+      pending = pending.slice(index + 1)
+      if (line !== '') onLine(line)
+    }
+  }
+}
+
+/**
+ * Probe the aligned update status. Read-only: `update --json` never
+ * installs anything. The probe is bounded (npm view may hang on a broken
+ * network) and resolves with the parsed status.
+ */
+export async function probeLauncherUpdate(spawnProcess: SpawnLike = spawn as SpawnLike): Promise<LauncherUpdateStatus> {
+  const command = launcherUpdateCommand(['update', '--json'])
+  return await new Promise((resolve, reject) => {
+    const child = spawnProcess(command.command, command.args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
+    const timer = setTimeout(() => {
+      child.kill()
+      reject(new Error('update probe timed out'))
+    }, 30_000)
+    let stdout = ''
+    let stderr = ''
+    child.stdout?.on('data', (chunk: Buffer) => { stdout += chunk.toString() })
+    child.stderr?.on('data', (chunk: Buffer) => { stderr += chunk.toString() })
+    child.once('error', error => {
+      clearTimeout(timer)
+      reject(new Error(`update probe failed to start: ${error.message}`))
+    })
+    child.once('exit', code => {
+      clearTimeout(timer)
+      if (code === 0) {
+        try {
+          resolve(JSON.parse(stdout) as LauncherUpdateStatus)
+        } catch {
+          reject(new Error('update probe returned an unreadable status'))
+        }
+        return
+      }
+      const tail = stderr.trim().split(/\r?\n/u).pop() ?? ''
+      reject(new Error(`update probe failed${tail === '' ? '' : `: ${tail}`}`))
+    })
+  })
+}
+
+/**
+ * Run the aligned update (`update --apply`) as a child process and stream
+ * its sanitized progress lines to the caller. Resolves with the child
+ * exit code (0 success); rejects only when the process could not start.
+ * No timeout: an npm install may legitimately take minutes.
+ */
+export function applyPlanArgs(plan: LauncherUpdatePlan): string[] {
+  const args = ['update', '--apply', '--dsh', plan.dshSpec, '--code', plan.codeSpec]
+  for (const plugin of plan.pluginSpecs) args.push('--plugin', plugin)
+  return args
+}
+
+export function applyLauncherUpdate(onLine: (line: string) => void, spawnProcess?: SpawnLike, plan?: LauncherUpdatePlan): Promise<number> {
+  const spawnFn = spawnProcess ?? (spawn as SpawnLike)
+  const command = launcherUpdateCommand(plan === undefined ? ['update', '--apply'] : applyPlanArgs(plan))
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(command.command, command.args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
+    const split = createLineSplitter(onLine)
+    child.stdout?.on('data', (chunk: Buffer) => { split(chunk.toString()) })
+    child.stderr?.on('data', (chunk: Buffer) => { split(chunk.toString()) })
+    child.once('error', error => {
+      reject(new Error(`update failed to start: ${error.message}`))
+    })
+    // 'close' fires once the stdio streams have ended, so a final line the
+    // child left without its newline still reaches the panel; a bare '\n'
+    // flushes any pending partial without adding a blank row.
+    child.once('close', (code, signal) => {
+      split('\n')
+      resolve(code ?? (signal === null ? 0 : 1))
+    })
+  })
+}

package/src/version.ts

@@ -1,6 +1,7 @@
 /** Installed dsh-code version exposed by the terminal header. */
 
-import { readFileSync } from 'node:fs'
+import { readFileSync, realpathSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import { dirname, join, resolve } from 'node:path'
 
 /** Read one package manifest version without making terminal startup depend on it. */
@@ -22,27 +23,28 @@ const DSH_HOST_PACKAGE_NAME = '@deepseek-ai/dsh'
 /** Parent levels above the host entry allowed to hold its package manifest. */
 const DSH_HOST_WALK_LIMIT = 4
 
-/**
- * Resolve the running dsh CLI host's version from its entry file
- * (`process.argv[1]`, e.g. `.../@deepseek-ai/dsh/lib/bin.js`). Only a manifest
- * literally named `@deepseek-ai/dsh` counts, so an unrelated entry (vitest, a
- * plain node script) resolves to undefined instead of faking a kernel version.
- */
-export function resolveDshHostVersion(entry: string | undefined = process.argv[1]): string | undefined {
-  if (entry === undefined || entry === '') return undefined
+/** Read `@deepseek-ai/dsh`'s version from a directory's package.json, or undefined. */
+function readHostVersion(directory: string): string | undefined {
+  try {
+    const parsed = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8')) as {
+      name?: unknown
+      version?: unknown
+    }
+    if (parsed.name === DSH_HOST_PACKAGE_NAME && typeof parsed.version === 'string' && parsed.version.length > 0) {
+      return parsed.version
+    }
+  } catch {
+    // No readable host manifest at this level.
+  }
+  return undefined
+}
+
+/** Climb from an entry file toward a host package.json. */
+function walkFrom(entry: string): string | undefined {
   let directory = dirname(resolve(entry))
   for (let depth = 0; depth < DSH_HOST_WALK_LIMIT; depth += 1) {
-    try {
-      const parsed = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8')) as {
-        name?: unknown
-        version?: unknown
-      }
-      if (parsed.name === DSH_HOST_PACKAGE_NAME && typeof parsed.version === 'string' && parsed.version.length > 0) {
-        return parsed.version
-      }
-    } catch {
-      // No readable manifest at this level: keep climbing.
-    }
+    const version = readHostVersion(directory)
+    if (version !== undefined) return version
     const parent = dirname(directory)
     if (parent === directory) return undefined
     directory = parent
@@ -50,6 +52,42 @@ export function resolveDshHostVersion(entry: string | undefined = process.argv[1
   return undefined
 }
 
+/**
+ * Resolve the host package via Node's module lookup from an entry file.
+ * Covers global `bin/dsh` shims that are not inside the package tree.
+ */
+function resolveFromNode(from: string): string | undefined {
+  try {
+    const manifest = createRequire(from).resolve(`${DSH_HOST_PACKAGE_NAME}/package.json`)
+    return readHostVersion(dirname(manifest))
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Resolve the running dsh CLI host's version from its entry file
+ * (`process.argv[1]`, e.g. `.../@deepseek-ai/dsh/lib/bin.js` or a PATH
+ * symlink `.../bin/dsh` → that file). Only a manifest literally named
+ * `@deepseek-ai/dsh` counts, so an unrelated entry (vitest, a plain node
+ * script) resolves to undefined instead of faking a kernel version.
+ */
+export function resolveDshHostVersion(entry: string | undefined = process.argv[1]): string | undefined {
+  if (entry === undefined || entry === '') return undefined
+  const fromWalk = walkFrom(entry)
+  if (fromWalk !== undefined) return fromWalk
+  try {
+    const real = realpathSync(entry)
+    if (real !== resolve(entry)) {
+      const fromReal = walkFrom(real)
+      if (fromReal !== undefined) return fromReal
+    }
+  } catch {
+    // Broken or missing symlink: fall through to Node resolution.
+  }
+  return resolveFromNode(resolve(entry))
+}
+
 let cachedDshKernelVersion: string | undefined
 let dshKernelVersionResolved = false
 

package/src/whale-glyph.ts

@@ -1,23 +1,23 @@
-// GENERATED by scripts/gen-whale-glyph.ts — do not edit by hand. Rerun the
-// generator after changing the FishLogo path. Half-block rendering of the
-// DeepSeek fish logo (figma I39:24057;88:8943 fillGeometry, exact extract;
-// native 23.16x17.04 → 26 columns × 8 half-block rows).
-// Blank cells are part of the glyph's fixed 26-column grid: pad, never trim.
-
-/** Half-block whale glyph rows; render with the brand color. */
-export const WHALE_GLYPH: readonly string[] = [
-  '    ▄▄▄▄▄▄▄▄█    ▄█▄     ▄',
-  ' ▄▄██████████▄▄  ▀███▄████',
-  '▄███████████████▄  ███▀▀▀ ',
-  '██     ▀▀█████▄▀██████    ',
-  '██▄       ▀████▄▄████     ',
-  ' ██▄        ▀██████▀      ',
-  '  ▀██▄▄  ██▄  ▀███▄▄      ',
-  '     ▀▀███████▀▀ ▀▀▀      ',
-]
-
-/** Fixed glyph width in terminal columns. */
-export const WHALE_GLYPH_COLUMNS = 26
-
-/** Fixed glyph height in half-block rows. */
-export const WHALE_GLYPH_ROWS = 8
+// GENERATED by scripts/gen-whale-glyph.ts — do not edit by hand. Rerun the
+// generator after changing the FishLogo path. Half-block rendering of the
+// DeepSeek fish logo (figma I39:24057;88:8943 fillGeometry, exact extract;
+// native 23.16x17.04 → 26 columns × 8 half-block rows).
+// Blank cells are part of the glyph's fixed 26-column grid: pad, never trim.
+
+/** Half-block whale glyph rows; render with the brand color. */
+export const WHALE_GLYPH: readonly string[] = [
+  '    ▄▄▄▄▄▄▄▄█    ▄█▄     ▄',
+  ' ▄▄██████████▄▄  ▀███▄████',
+  '▄███████████████▄  ███▀▀▀ ',
+  '██     ▀▀█████▄▀██████    ',
+  '██▄       ▀████▄▄████     ',
+  ' ██▄        ▀██████▀      ',
+  '  ▀██▄▄  ██▄  ▀███▄▄      ',
+  '     ▀▀███████▀▀ ▀▀▀      ',
+]
+
+/** Fixed glyph width in terminal columns. */
+export const WHALE_GLYPH_COLUMNS = 26
+
+/** Fixed glyph height in half-block rows. */
+export const WHALE_GLYPH_ROWS = 8