dsh-code 1.2.0 → 1.3.0

package/src/render/status.ts

@@ -17,7 +17,7 @@ import { singleLineText, truncateColumns, formatTokens } from './text.ts'
 
 // Re-exported for the callers that have always read the formatter here.
 export { formatTokens }
-import { t } from '../i18n.ts'
+import { t, type MessageKey } from '../i18n.ts'
 
 
 /**
@@ -29,7 +29,11 @@ export function formatDuration(ms: number): string {
   const s = ms / 1_000
   if (s < 60) return String(Math.round(s * 10) / 10) + 's'
   const whole = Math.round(s)
-  return Math.floor(whole / 60) + 'm' + (whole % 60) + 's'
+  const hours = Math.floor(whole / 3_600)
+  const minutes = Math.floor((whole % 3_600) / 60)
+  const seconds = whole % 60
+  if (hours > 0) return `${hours}h${minutes}m${seconds === 0 ? '' : `${seconds}s`}`
+  return `${minutes}m${seconds}s`
 }
 
 /**
@@ -251,6 +255,31 @@ export const STATUS_ITEMS: readonly StatusItemInfo[] = [
   { id: 'sandbox', label: 'sandbox', description: 'divergent sandbox-mode override', side: 'left' },
 ]
 
+const STATUSLINE_ITEM_KEYS: Record<StatusItemId, { label: MessageKey; description: MessageKey }> = {
+  model: { label: 'statusline.item.model', description: 'statusline.item.model.desc' },
+  cwd: { label: 'statusline.item.cwd', description: 'statusline.item.cwd.desc' },
+  mode: { label: 'statusline.item.mode', description: 'statusline.item.mode.desc' },
+  branch: { label: 'statusline.item.branch', description: 'statusline.item.branch.desc' },
+  context: { label: 'statusline.item.context', description: 'statusline.item.context.desc' },
+  permission: { label: 'statusline.item.permission', description: 'statusline.item.permission.desc' },
+  plan: { label: 'statusline.item.plan', description: 'statusline.item.plan.desc' },
+  turns: { label: 'statusline.item.turns', description: 'statusline.item.turns.desc' },
+  durations: { label: 'statusline.item.durations', description: 'statusline.item.durations.desc' },
+  cache: { label: 'statusline.item.cache', description: 'statusline.item.cache.desc' },
+  tokens: { label: 'statusline.item.tokens', description: 'statusline.item.tokens.desc' },
+  title: { label: 'statusline.item.title', description: 'statusline.item.title.desc' },
+  goal: { label: 'statusline.item.goal', description: 'statusline.item.goal.desc' },
+  sandbox: { label: 'statusline.item.sandbox', description: 'statusline.item.sandbox.desc' },
+}
+
+/** Picker rows with labels/descriptions in the active interface language. */
+export function localizedStatusItems(): readonly StatusItemInfo[] {
+  return STATUS_ITEMS.map(item => {
+    const keys = STATUSLINE_ITEM_KEYS[item.id]
+    return { ...item, label: t(keys.label), description: t(keys.description) }
+  })
+}
+
 /**
  * Default order: the whole catalog (matches the pre-customization bar).
  * The busy dot is not an item — it always leads the identity cluster.
@@ -292,9 +321,10 @@ export const STATUS_ROW2_INDENT = 2
 const TITLE_BUDGET = 48
 
 /**
- * Primary-row drop ranks: context drops before permission; the identity
- * cluster never drops and ellipsizes only after the right badge is gone.
- * Secondary-row groups reuse the remaining ranks independently.
+ * Primary-row drop ranks: identity never drops; permission outranks context.
+ * The drop ladder peels hint and trailing identity facts before removing
+ * the context meter, so occupancy stays visible on a typical 120-column
+ * terminal. Secondary-row groups reuse the remaining ranks independently.
  */
 const RANK_TITLE = 10
 const RANK_TOKENS = 50
@@ -358,6 +388,30 @@ function sep(): StatusSpan {
   return { text: ' · ', tone: 'label' }
 }
 
+/** True for the dim ` · ` that joins identity facts. */
+function isIdentitySep(span: StatusSpan): boolean {
+  return span.text === ' · ' && span.tone === 'label'
+}
+
+/**
+ * Drop the trailing identity fact (branch, then mode, then cwd) so the
+ * context meter can keep a column. Returns undefined once only the busy
+ * dot and model remain.
+ */
+function peelIdentityFact(spans: readonly StatusSpan[]): StatusSpan[] | undefined {
+  if (spans.length < 3) return undefined
+  const last = spans[spans.length - 1]
+  const before = spans[spans.length - 2]
+  const modeSep = spans[spans.length - 3]
+  if (last?.tone === 'accent' && modeSep !== undefined && isIdentitySep(modeSep) && before?.tone === 'label') {
+    return spans.slice(0, -3)
+  }
+  if ((last?.tone === 'branch' || last?.tone === 'path') && before !== undefined && isIdentitySep(before)) {
+    return spans.slice(0, -2)
+  }
+  return undefined
+}
+
 /** Total visible columns of a span list (separators ride inside the spans). */
 function spansWidth(spans: readonly StatusSpan[]): number {
   let width = 0
@@ -511,8 +565,8 @@ function buildCandidates(
       group: {
         spans: [{
           text: facts.goal.phase === 'active'
-            ? '◎ round ' + facts.goal.rounds + '/' + facts.goal.max
-            : '◎ ' + safe(facts.goal.phase),
+            ? t('status.goal.round', { current: facts.goal.rounds, max: facts.goal.max })
+            : t('status.goal.phase', { phase: safe(facts.goal.phase) }),
           tone: 'accent',
         }],
       },
@@ -523,7 +577,7 @@ function buildCandidates(
   // The sandbox override stays implicit when it merely echoes the preset.
   const sandbox = safe(facts.sandbox ?? '')
   if (sandbox !== '' && sandbox.toLowerCase() !== facts.permission.toLowerCase() && enabled.has('sandbox')) {
-    row2.push({ group: { spans: [{ text: 'sandbox ' + sandbox, tone: 'warn' }] }, rank: RANK_SANDBOX, id: 'sandbox' })
+    row2.push({ group: { spans: [{ text: t('status.label.sandbox') + ' ' + sandbox, tone: 'warn' }] }, rank: RANK_SANDBOX, id: 'sandbox' })
   }
   const permission = safe(facts.permission)
   let badge = -1
@@ -536,7 +590,7 @@ function buildCandidates(
   if (permission !== '' && enabled.has('permission')) {
     right.push({
       span: planStation
-        ? { text: 'plan on', tone: 'plan' }
+        ? { text: t('status.plan.on'), tone: 'plan' }
         : { text: permission, tone: permissionTone(permission) },
       rank: RANK_BADGE,
       id: 'permission',
@@ -544,7 +598,7 @@ function buildCandidates(
     badge = right.length - 1
   }
   if (facts.plan && enabled.has('plan')) {
-    row2.push({ group: { spans: [{ text: '⧉ plan', tone: 'accent' }] }, rank: RANK2_PLAN, id: 'plan' })
+    row2.push({ group: { spans: [{ text: t('status.plan.mark'), tone: 'accent' }] }, rank: RANK2_PLAN, id: 'plan' })
   }
   return { left, right, badge, row2 }
 }
@@ -552,7 +606,8 @@ function buildCandidates(
 /**
  * Compose the two-row footer layout under a column budget. Row 1 keeps model,
  * cwd, mode, branch, context, then the right-pinned permission badge and cycle
- * hint. It drops hint, context, and permission before ellipsizing identity.
+ * hint. It shrinks the context bar, drops the hint, and peels trailing
+ * identity facts before removing the context group or the permission badge.
  * Row 2 fits all secondary figures and state within its own budget.
  * @param facts - identity facts resolved by the runner.
  * @param stats - session figures folded from the durable log.
@@ -623,11 +678,10 @@ export function layoutStatusBar(
   }
 
   while (width() > budget) {
-    // Context is the lowest-priority visual group: the bar shrinks inside
-    // its own budget first (the absolute readout survives), then the
-    // readout degrades to the bare percent, and only then does the whole
-    // group go — before the permission badge or its Shift+Tab affordance
-    // is touched.
+    // Occupancy outranks the cycle hint and trailing identity facts
+    // (cwd/mode/branch): shrink the bar, drop the hint, then peel those
+    // facts before removing the context group. Permission stays until
+    // context is already gone.
     if (leftKept.some(entry => entry.id === 'context')) {
       if (contextWidth > CONTEXT_MIN_WIDTH) {
         const overflow = width() - budget
@@ -640,24 +694,21 @@ export function layoutStatusBar(
         rebuildContext()
         continue
       }
-      leftKept.splice(leftKept.findIndex(entry => entry.id === 'context'), 1)
+    }
+    if (hint) {
+      hint = false
       continue
     }
-    if (hint && rightKept.length > 0 && leftKept.length > 0) {
-      const identity = leftKept[0]
-      const identityText = identity.group.spans.map(span => span.text).join('')
-      const rightWidth = joinWidth(rightKept.map(entry => visibleColumns(entry.span.text)), itemSeparator)
-      const identityBudget = budget - rightWidth - LEFT_RIGHT_GAP - visibleColumns(statusCycleHint())
-      if (identityBudget > 0 && visibleColumns(identityText) > identityBudget) {
-        leftKept[0] = {
-          ...identity,
-          group: { spans: [{ text: truncateColumns(identityText, identityBudget), tone: 'model' }] },
-        }
+    const identityEntry = leftKept[0]
+    if (identityEntry?.id === 'identity') {
+      const peeled = peelIdentityFact(identityEntry.group.spans)
+      if (peeled !== undefined) {
+        leftKept[0] = { ...identityEntry, group: { spans: peeled } }
         continue
       }
     }
-    if (hint) {
-      hint = false
+    if (leftKept.some(entry => entry.id === 'context')) {
+      leftKept.splice(leftKept.findIndex(entry => entry.id === 'context'), 1)
       continue
     }
     let dropLeft = -1

package/src/render/text.ts

@@ -23,7 +23,8 @@ export function formatTokens(n: number): string {
   const scaled = (v: number): string =>
     v >= 100 ? String(Math.round(v)) : String(Math.round(v * 10) / 10)
   if (n < 1_000) return String(n)
-  if (n < 1_000_000) return scaled(n / 1_000) + 'K'
+  // 999,500+ rounds to 1000K; step up to M instead of printing four digits.
+  if (n < 999_500) return scaled(n / 1_000) + 'K'
   return scaled(n / 1_000_000) + 'M'
 }
 

package/src/session-directory.ts

@@ -2,7 +2,7 @@
 
 import { basename, dirname, resolve } from 'node:path'
 import { realpathSync } from 'node:fs'
-import { SESSION_FORMAT_VERSION, type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session'
+import { SESSION_FORMAT_VERSION, SessionId, type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session'
 import { t } from './i18n.ts'
 
 export interface SessionRecord {
@@ -11,6 +11,52 @@ export interface SessionRecord {
   readonly persisted: boolean
 }
 
+/** Minimal write handle retained while a planned deletion touches artifacts. */
+export interface SessionDeletionLease {
+  close(): Promise<void>
+}
+
+/** Public persistence operation used to acquire the backend's write lease. */
+export interface SessionDeletionPersistence {
+  open(id: SessionId, access: 'write'): Promise<SessionDeletionLease>
+}
+
+/**
+ * Acquire every subtree member's cross-process write lease before deleting
+ * any artifact. A partial acquisition is rolled back, so callers either hold
+ * the whole deletion boundary or touch nothing.
+ */
+export async function acquireSessionDeletionLeases(
+  persistence: SessionDeletionPersistence,
+  ids: readonly string[],
+): Promise<readonly SessionDeletionLease[]> {
+  const leases: SessionDeletionLease[] = []
+  try {
+    for (const id of ids) leases.push(await persistence.open(SessionId(id), 'write'))
+    return leases
+  } catch (error: unknown) {
+    try {
+      await releaseSessionDeletionLeases(leases)
+    } catch (releaseError: unknown) {
+      throw new AggregateError([error, releaseError], 'session deletion lease acquisition and rollback failed')
+    }
+    throw error
+  }
+}
+
+/** Release deletion leases in reverse acquisition order. */
+export async function releaseSessionDeletionLeases(leases: readonly SessionDeletionLease[]): Promise<void> {
+  const failures: unknown[] = []
+  for (const lease of [...leases].reverse()) {
+    try {
+      await lease.close()
+    } catch (error: unknown) {
+      failures.push(error)
+    }
+  }
+  if (failures.length > 0) throw new AggregateError(failures, 'failed to release session deletion leases')
+}
+
 export interface TitleObservationResult {
   readonly sessionId: string
   readonly status: 'fulfilled' | 'rejected'
@@ -105,6 +151,26 @@ export function matchSessionId(headers: readonly SessionHeader[], wanted: string
   return matches[0]
 }
 
+/**
+ * Unique picker-row match by exact id, unique prefix, or unique suffix.
+ * The resume list shows `id.slice(-12)`, so `/delete` arguments are often
+ * that tail rather than a leading prefix.
+ */
+export function matchSessionRow(rows: readonly SessionRow[], wanted: string): SessionRow {
+  const needle = wanted.trim()
+  if (needle === '') throw new Error('no persisted session matches ""')
+  const exact = rows.filter(row => row.id === needle)
+  if (exact[0] !== undefined && exact.length === 1) return exact[0]
+  const prefixed = rows.filter(row => row.id.startsWith(needle))
+  if (prefixed[0] !== undefined && prefixed.length === 1) return prefixed[0]
+  const suffixed = rows.filter(row => row.id.endsWith(needle))
+  if (suffixed[0] !== undefined && suffixed.length === 1) return suffixed[0]
+  if (prefixed.length > 1 || suffixed.length > 1) {
+    throw new Error(`session prefix "${needle}" is ambiguous (${Math.max(prefixed.length, suffixed.length)} matches): use more of the id`)
+  }
+  throw new Error(`no persisted session matches "${needle}"`)
+}
+
 /** The newest persisted ROOT session pinned to this cwd, or undefined. */
 export function newestRootForCwd(headers: readonly SessionHeader[], cwd: string): SessionHeader | undefined {
   const local = headers
@@ -151,12 +217,19 @@ export function projectSessionRows(
         preset: record.header.agentPreset ?? 'standard',
       }
     })
-    .filter(row => needle === '' || `${row.id} ${row.cwd} ${row.workspace} ${row.preset}`.toLowerCase().includes(needle))
+    .filter(row => sessionRowMatchesQuery(row, needle))
     .sort((left, right) => options.sort === 'newest'
       ? right.updatedAt - left.updatedAt || right.createdAt - left.createdAt
       : left.updatedAt - right.updatedAt || left.createdAt - right.createdAt)
 }
 
+/** True when the picker query hits id, path, preset, or the displayed title. */
+export function sessionRowMatchesQuery(row: Pick<SessionRow, 'id' | 'cwd' | 'workspace' | 'preset' | 'title'>, query: string): boolean {
+  const needle = query.trim().toLowerCase()
+  if (needle === '') return true
+  return `${row.id} ${row.cwd} ${row.workspace} ${row.preset} ${row.title ?? ''}`.toLowerCase().includes(needle)
+}
+
 /** Merge page-local title observations without disturbing directory order. */
 export function mergeSessionTitles(
   rows: readonly SessionRow[],
@@ -300,7 +373,13 @@ export function jsonlSessionRoot(persistence: unknown): string | undefined {
  */
 export function collectDeletionSubtree(records: readonly SessionRecord[], id: string): string[] {
   const parentOf = new Map<string, string | undefined>()
-  for (const record of records) parentOf.set(record.header.id, record.header.parentSession)
+  for (const record of records) {
+    // Only delegated subagents ride their parent's deletion. A fork is an
+    // independent conversation that merely shares lineage: deleting its
+    // origin must never take the branch's own log with it.
+    if (!isSubagentSession(record.header)) continue
+    parentOf.set(record.header.id, record.header.parentSession)
+  }
   const doomed = new Set<string>([id])
   // Iterate to a fixed point: children may be listed before their parents.
   for (let pass = 0; pass < 2; pass += 1) {

package/src/session-switch.ts

@@ -13,6 +13,7 @@ interface Request<T> {
 export class SessionSwitchQueue<T> {
   private pending: Request<T> | undefined
   private pumping = false
+  private running = false
 
   constructor(
     private readonly execute: (value: T) => Promise<void>,
@@ -34,6 +35,16 @@ export class SessionSwitchQueue<T> {
     return true
   }
 
+  /**
+   * Whether a queued change is being activated right now. Between the idle
+   * wait and the handoff the old session is still installed, so a submission
+   * made in that window would start a turn the handoff then discards; callers
+   * use this to refuse one instead of losing it.
+   */
+  get activating(): boolean {
+    return this.running
+  }
+
   private async pump(): Promise<void> {
     this.pumping = true
     try {
@@ -43,10 +54,13 @@ export class SessionSwitchQueue<T> {
         // Another request replaced this one while the turn was converging.
         if (this.pending !== observed) continue
         this.pending = undefined
+        this.running = true
         try {
           await this.execute(observed.value)
         } catch (error: unknown) {
           this.failed(error)
+        } finally {
+          this.running = false
         }
       }
     } finally {

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/update-panel.ts

@@ -11,7 +11,7 @@
 
 import { createElement, useEffect, useState, type ReactElement } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink'
-import type { LauncherUpdateStatus } from './update.ts'
+import type { LauncherUpdatePlan, LauncherUpdateStatus } from './update.ts'
 import { clampScroll, panelViewport } from './render/inspector.ts'
 import { singleLineText, truncateColumns } from './render/text.ts'
 import { panelAccent } from './panel-accent.ts'
@@ -26,6 +26,84 @@ export function clipUpdateLines(lines: readonly string[]): readonly string[] {
   return lines.length <= UPDATE_OUTPUT_CAP ? lines : lines.slice(lines.length - UPDATE_OUTPUT_CAP)
 }
 
+/** One in-flight `update --apply`. Closing the panel must not start a second. */
+interface UpdateApplyJob {
+  readonly promise: Promise<number>
+  readonly lines: string[]
+  readonly lineListeners: Set<(line: string) => void>
+}
+
+let updateApplyJob: UpdateApplyJob | undefined
+const updateApplyRunningListeners = new Set<(running: boolean) => void>()
+
+function emitUpdateApplyRunning(running: boolean): void {
+  for (const listener of updateApplyRunningListeners) listener(running)
+}
+
+/** True while an apply child is alive, even if the /update panel is closed. */
+export function isUpdateApplyRunning(): boolean {
+  return updateApplyJob !== undefined
+}
+
+/** Subscribe to apply-running changes (frozen-hint "esc waits"). */
+export function subscribeUpdateApplyRunning(listener: (running: boolean) => void): () => void {
+  updateApplyRunningListeners.add(listener)
+  listener(updateApplyJob !== undefined)
+  return () => { updateApplyRunningListeners.delete(listener) }
+}
+
+/** The live apply job, if any: lines already streamed plus the shared promise. */
+export function currentUpdateApply(): UpdateApplyJob | undefined {
+  return updateApplyJob
+}
+
+/**
+ * Run `apply` once. A second call while the child is alive reuses the same
+ * promise and replays buffered lines — closing /update and opening it again
+ * must not spawn a second `npm install`.
+ */
+export function runUpdateApply(
+  apply: (onLine: (line: string) => void, plan: LauncherUpdatePlan) => Promise<number>,
+  plan: LauncherUpdatePlan,
+  onLine?: (line: string) => void,
+): Promise<number> {
+  if (updateApplyJob !== undefined) {
+    if (onLine !== undefined) {
+      for (const line of updateApplyJob.lines) onLine(line)
+      updateApplyJob.lineListeners.add(onLine)
+    }
+    return updateApplyJob.promise
+  }
+  const lines: string[] = []
+  const lineListeners = new Set<(line: string) => void>()
+  if (onLine !== undefined) lineListeners.add(onLine)
+  const promise = apply(line => {
+    const text = singleLineText(line)
+    lines.push(text)
+    if (lines.length > UPDATE_OUTPUT_CAP) lines.splice(0, lines.length - UPDATE_OUTPUT_CAP)
+    for (const listener of lineListeners) listener(text)
+  }, plan)
+  updateApplyJob = { promise, lines, lineListeners }
+  emitUpdateApplyRunning(true)
+  const settle = (): void => {
+    if (updateApplyJob?.promise === promise) {
+      updateApplyJob = undefined
+      emitUpdateApplyRunning(false)
+    }
+  }
+  // Handle both outcomes directly. `finally()` mirrors a rejected source
+  // promise onto its returned promise; discarding that returned promise would
+  // create an unhandled rejection when the update child cannot start.
+  void promise.then(settle, settle)
+  return promise
+}
+
+/** Drop a leftover job between tests. */
+export function resetUpdateApply(): void {
+  updateApplyJob = undefined
+  emitUpdateApplyRunning(false)
+}
+
 /** One display row of the update surface. */
 export interface UpdateRow {
   readonly key: string
@@ -139,8 +217,35 @@ export function UpdatePanel({ probe, apply, close, notify }: {
   // 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)
+  const appendLine = (line: string): void => {
+    setLines(previous => clipUpdateLines([...previous, line]))
+  }
   useEffect(() => {
     let disposed = false
+    const existing = currentUpdateApply()
+    if (existing !== undefined) {
+      // The apply child outlives the panel: closing for an approval or
+      // Ctrl+C must reconnect to the same job, not probe-and-confirm again.
+      setPhase('apply')
+      setLines(existing.lines)
+      setExit(undefined)
+      setApplyError(undefined)
+      setAnchor('tail')
+      existing.lineListeners.add(appendLine)
+      void existing.promise.then(code => {
+        if (disposed) return
+        setExit(code)
+        setPhase('done')
+      }, reason => {
+        if (disposed) return
+        setApplyError(reason instanceof Error ? reason.message : String(reason))
+        setPhase('done')
+      })
+      return () => {
+        disposed = true
+        existing.lineListeners.delete(appendLine)
+      }
+    }
     setPhase('probe')
     setStatus(undefined)
     setProbeError(undefined)
@@ -154,21 +259,23 @@ export function UpdatePanel({ probe, apply, close, notify }: {
       setProbeError(reason instanceof Error ? reason.message : String(reason))
       setPhase('error')
     })
-    return () => { disposed = true }
+    return () => {
+      disposed = true
+      currentUpdateApply()?.lineListeners.delete(appendLine)
+    }
   }, [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
+    if (isUpdateApplyRunning()) return
     setPhase('apply')
     setLines([])
     setExit(undefined)
     setApplyError(undefined)
     setAnchor('tail')
-    apply(line => {
-      setLines(previous => clipUpdateLines([...previous, singleLineText(line)]))
-    }, status.plan).then(code => {
+    runUpdateApply(apply, status.plan, appendLine).then(code => {
       setExit(code)
       setPhase('done')
       notify(code === 0 ? 'update installed — restart dsh to activate' : `update failed (exit ${code})`, code === 0 ? 'info' : 'error')

package/src/version.ts

@@ -17,6 +17,11 @@ function readPackageVersion(manifest = new URL('../package.json', import.meta.ur
 /** Version of the installed dsh-code package. */
 export const DSH_CODE_VERSION = readPackageVersion()
 
+/** Header brand line: hide a missing-manifest fallback so we never paint v0.0.0. */
+export function headerBrandTitle(version: string = DSH_CODE_VERSION): string {
+  return version === '0.0.0' ? 'DeepSeek Harness' : `DeepSeek Harness · v${version}`
+}
+
 /** The harness host package: the dsh CLI whose process runs the TUI plugin. */
 const DSH_HOST_PACKAGE_NAME = '@deepseek-ai/dsh'