dsh-code 0.7.0 → 0.9.0

package/src/render/tool-preview.ts

@@ -1,34 +1,77 @@
-/**
- * Bounded preview line for a tool invocation's raw JSON arguments: the first
- * human-meaningful string among the well-known keys (command, path, query, …)
- * with a fallback to the bounded raw JSON. Shared by the tool card in the
- * transcript and the approval bar's command preview.
- *
- * @module @deepseek-ai/dsh-code/render/tool-preview
- */
-
-/** Keys searched in declaration order when building a preview. */
-const PREVIEW_KEYS = ['command', 'cmd', 'description', 'path', 'pattern', 'query'] as const
-
-/**
- * Resolve one bounded preview for raw tool arguments.
- * @param args - raw JSON arguments string as the model produced it.
- * @param toolName - the tool the arguments belong to (fallback label).
- * @returns the preview line; empty when nothing useful resolves.
- */
-export function toolArgumentsPreview(args: string, toolName: string): string {
-  if (args === '') return toolName
-  try {
-    const parsed: unknown = JSON.parse(args)
-    if (parsed !== null && typeof parsed === 'object') {
-      const record = parsed as Record<string, unknown>
-      for (const key of PREVIEW_KEYS) {
-        const value = record[key]
-        if (typeof value === 'string' && value !== '') return value
-      }
-    }
-  } catch {
-    // Raw JSON parse failed: fall through to the bounded raw arguments.
-  }
-  return args.length > 80 ? `${args.slice(0, 77)}...` : args
-}
+/**
+ * Bounded preview line for a tool invocation's raw JSON arguments: the first
+ * human-meaningful string among the well-known keys (command, path, query, …)
+ * with a fallback to the bounded raw JSON. Shared by the tool card in the
+ * transcript and the approval bar's command preview. Arguments longer than
+ * {@link MAX_PARSE_CHARS} are never parsed: the preview is a display concern,
+ * and a synchronous `JSON.parse` plus string copies of an unbounded model
+ * payload must not run on the approval or projection paths.
+ *
+ * @module @deepseek-ai/dsh-code/render/tool-preview
+ */
+
+/** Keys searched in declaration order when building a preview. */
+const PREVIEW_KEYS = ['command', 'cmd', 'description', 'path', 'pattern', 'query'] as const
+
+/**
+ * Raw arguments longer than this are skipped without parsing and fall back
+ * to the bounded raw preview. Well above any realistic command/path/query
+ * string while keeping the synchronous parse cost negligible.
+ */
+const MAX_PARSE_CHARS = 4096
+
+/** Bounded raw-arguments fallback shared by the skip-parse and parse-failure paths. */
+function boundedRawPreview(args: string): string {
+  return args.length > 80 ? `${args.slice(0, 77)}...` : args
+}
+
+/**
+ * Resolve one bounded preview for raw tool arguments.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @param toolName - the tool the arguments belong to (fallback label).
+ * @returns the preview line; empty when nothing useful resolves.
+ */
+export function toolArgumentsPreview(args: string, toolName: string): string {
+  if (args === '') return toolName
+  if (args.length > MAX_PARSE_CHARS) return boundedRawPreview(args)
+  try {
+    const parsed: unknown = JSON.parse(args)
+    if (parsed !== null && typeof parsed === 'object') {
+      const record = parsed as Record<string, unknown>
+      for (const key of PREVIEW_KEYS) {
+        const value = record[key]
+        if (typeof value === 'string' && value !== '') return value
+      }
+    }
+  } catch {
+    // Raw JSON parse failed: fall through to the bounded raw arguments.
+  }
+  return boundedRawPreview(args)
+}
+
+/** Visible budget for one delegation prompt row on the tool card. */
+const MAX_PROMPT_CHARS = 160
+
+/**
+ * Bounded prompt preview for delegation-style tools (`subagent`): the
+ * `prompt` argument rendered as the card's second row, so the transcript
+ * shows what the child agent was asked — not just its description label —
+ * while it runs (Codex's SpawnAgent card preview). Anything else returns ''.
+ * @param toolName - the tool the arguments belong to.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @returns the one-line prompt preview, or '' when none applies.
+ */
+export function toolPromptPreview(toolName: string, args: string): string {
+  if (toolName !== 'subagent' || args === '' || args.length > MAX_PARSE_CHARS) return ''
+  try {
+    const parsed: unknown = JSON.parse(args)
+    if (parsed === null || typeof parsed !== 'object') return ''
+    const prompt = (parsed as Record<string, unknown>)['prompt']
+    if (typeof prompt !== 'string' || prompt === '') return ''
+    const flat = prompt.replace(/\s+/gu, ' ').trim()
+    return flat.length > MAX_PROMPT_CHARS ? `${flat.slice(0, MAX_PROMPT_CHARS - 1)}…` : flat
+  } catch {
+    // Malformed arguments degrade to no prompt row, never a thrown parse.
+    return ''
+  }
+}

package/src/session-directory.ts

@@ -1,6 +1,7 @@
 /** Lightweight session-directory projection for the /resume picker. */
 
-import { basename, resolve } from 'node:path'
+import { basename, dirname, resolve } from 'node:path'
+import { realpathSync } from 'node:fs'
 import type { SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session'
 
 export interface SessionRecord {
@@ -42,6 +43,8 @@ export interface SessionDirectoryOptions {
 export interface SessionRow {
   readonly id: string
   readonly createdAt: number
+  /** Last-activity timestamp: artifact mtime when known, else createdAt. */
+  readonly updatedAt: number
   readonly cwd: string
   readonly workspace: string
   readonly parent?: string
@@ -53,24 +56,88 @@ export interface SessionRow {
   readonly title?: string
 }
 
-function samePath(left: string | undefined, right: string): boolean {
+/** Case-insensitive filesystems (Windows, macOS) compare paths by lowercased form. */
+const CASE_INSENSITIVE_FS = process.platform === 'win32' || process.platform === 'darwin'
+
+/** True when the header describes a subagent conversation (durable lineage). */
+export function isSubagentSession(header: SessionHeader): boolean {
+  return header.origin === 'subagent' || header.parentSession !== undefined
+}
+
+function comparablePath(value: string): string {
+  const resolved = resolve(value)
+  // Codex's paths_match_after_normalization pattern: canonicalize through the
+  // filesystem when the path exists (resolving symlinks, subst drives, and
+  // junctions that plain `resolve` keeps distinct), falling back to lexical
+  // resolution when the directory no longer does.
+  const fold = (path: string): string => CASE_INSENSITIVE_FS ? path.toLowerCase() : path
+  try {
+    return fold(realpathSync(resolved))
+  } catch {
+    return fold(resolved)
+  }
+}
+
+/** Platform-consistent path equality for session cwd comparisons. */
+export function samePath(left: string | undefined, right: string): boolean {
   if (left === undefined) return false
-  return resolve(left).toLowerCase() === resolve(right).toLowerCase()
+  return comparablePath(left) === comparablePath(right)
 }
 
-/** Filter/sort header-only records. No session log is loaded here. */
-export function projectSessionRows(records: readonly SessionRecord[], options: SessionDirectoryOptions): SessionRow[] {
+/**
+ * Unique header match by exact id or unique id prefix (root and subagent
+ * headers alike); the caller applies any lineage gate.
+ * @param headers - the persisted headers.
+ * @param wanted - the id or id prefix.
+ * @returns the uniquely matched header.
+ * @throws when nothing matches or the prefix is ambiguous.
+ */
+export function matchSessionId(headers: readonly SessionHeader[], wanted: string): SessionHeader {
+  const exact = headers.filter(header => header.id === wanted)
+  const matches = exact.length > 0 ? exact : headers.filter(header => header.id.startsWith(wanted))
+  if (matches.length === 0) throw new Error(`no persisted session matches "${wanted}"`)
+  if (matches.length > 1) {
+    throw new Error(`session prefix "${wanted}" is ambiguous (${matches.length} matches): use more of the id`)
+  }
+  return matches[0]!
+}
+
+/** The newest persisted ROOT session pinned to this cwd, or undefined. */
+export function newestRootForCwd(headers: readonly SessionHeader[], cwd: string): SessionHeader | undefined {
+  const local = headers
+    .filter(header => !isSubagentSession(header) && samePath(header.cwd, cwd))
+    .sort((left, right) => right.createdAt - left.createdAt)
+  return local[0]
+}
+
+/**
+ * Filter/sort header-only records. No session log is loaded here. Sorting is
+ * by LAST ACTIVITY (`updated` — artifact mtime when the caller resolved one,
+ * else createdAt), matching the codex resume picker's default UpdatedAt
+ * ordering: a session you kept talking in outranks one created later but idle.
+ * @param records - the header-only records.
+ * @param options - filter/sort options.
+ * @param updated - per-session last-activity timestamps, when resolved.
+ */
+export function projectSessionRows(
+  records: readonly SessionRecord[],
+  options: SessionDirectoryOptions,
+  updated?: ReadonlyMap<string, number>,
+): SessionRow[] {
   const needle = options.query.trim().toLowerCase()
   return records
-    .filter(record => options.sessions === 'all'
-      || (record.header.parentSession === undefined && record.header.origin !== 'subagent'))
+    .filter(record => options.sessions === 'all' || !isSubagentSession(record.header))
     .filter(record => options.cwd === 'all' || samePath(record.header.cwd, options.currentCwd))
     .map(record => {
       const cwd = record.header.cwd ?? ''
-      const subagent = record.header.origin === 'subagent' || record.header.parentSession !== undefined
+      const subagent = isSubagentSession(record.header)
+      const activity = updated?.get(record.header.id)
       return {
         id: record.header.id,
         createdAt: record.header.createdAt,
+        updatedAt: activity === undefined || !Number.isFinite(activity) || activity < record.header.createdAt
+          ? record.header.createdAt
+          : activity,
         cwd,
         workspace: cwd === '' ? '(no workspace)' : basename(cwd),
         parent: record.header.parentSession,
@@ -83,8 +150,8 @@ export function projectSessionRows(records: readonly SessionRecord[], options: S
     })
     .filter(row => needle === '' || `${row.id} ${row.cwd} ${row.workspace} ${row.preset}`.toLowerCase().includes(needle))
     .sort((left, right) => options.sort === 'newest'
-      ? right.createdAt - left.createdAt
-      : left.createdAt - right.createdAt)
+      ? right.updatedAt - left.updatedAt || right.createdAt - left.createdAt
+      : left.updatedAt - right.updatedAt || left.createdAt - right.createdAt)
 }
 
 /** Merge page-local title observations without disturbing directory order. */
@@ -100,3 +167,97 @@ export function mergeSessionTitles(
   }
   return rows.map(row => titles.has(row.id) ? { ...row, title: titles.get(row.id) } : row)
 }
+
+/**
+ * Encode a session id the way the JSONL backend does for its on-disk layout
+ * (`encodeSegment`: safe units literal, everything else `~XXXX`). Used ONLY to
+ * validate that a `locate()` path really is this session's directory before
+ * any deletion touches the filesystem — a local copy of the pure upstream
+ * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+ */
+export function encodeSessionSegment(raw: string): string {
+  if (raw.length === 0) throw new Error('cannot encode an empty path segment')
+  if (raw === '.') return '~002E'
+  if (raw === '..') return '~002E~002E'
+  let out = ''
+  for (let i = 0; i < raw.length; i += 1) {
+    const code = raw.charCodeAt(i)
+    const ch = String.fromCharCode(code)
+    if (ch !== '~' && /^[A-Za-z0-9._-]$/u.test(ch)) {
+      out += ch
+    } else {
+      out += `~${code.toString(16).toUpperCase().padStart(4, '0')}`
+    }
+  }
+  return out
+}
+
+/** The session-log artifact names the JSONL backend may create. */
+export const SESSION_ARTIFACT_NAMES: readonly string[] = ['session.jsonl', 'session.jsonl.zstd']
+
+/**
+ * Guard one `locate()` artifact path before deletion (codex's scoped-path
+ * check, adapted to the JSONL layout): the file must be a `session.jsonl`
+ * artifact sitting in the directory named exactly `encodeSegment(id)`.
+ * @param artifact - the path the persistence backend located.
+ * @param id - the session id the artifact claims to belong to.
+ * @returns the owning session directory, or undefined when the layout is unexpected.
+ */
+export function sessionArtifactDirectory(artifact: string, id: string): string | undefined {
+  if (basename(artifact) !== 'session.jsonl' && basename(artifact) !== 'session.jsonl.zstd') return undefined
+  const dir = dirname(artifact)
+  if (basename(dir) !== encodeSessionSegment(id)) return undefined
+  return dir
+}
+
+/**
+ * Collect one session's deletion subtree: the id plus every record whose
+ * parent chain leads to it (codex deletes subagent threads with their root).
+ * @param records - the full directory listing.
+ * @param id - the root session id to delete.
+ * @returns the ids to delete, root first.
+ */
+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)
+  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) {
+    for (const candidate of parentOf.keys()) {
+      if (doomed.has(candidate)) continue
+      let ancestor = parentOf.get(candidate)
+      let depth = 0
+      while (ancestor !== undefined && depth < 64) {
+        if (doomed.has(ancestor)) {
+          doomed.add(candidate)
+          break
+        }
+        ancestor = parentOf.get(ancestor)
+        depth += 1
+      }
+    }
+  }
+  return [...doomed]
+}
+
+/**
+ * Codex-style relative time for session rows ("now", "5m ago", "3h ago",
+ * "2d ago"; older than a week falls back to the local date).
+ * @param timestamp - epoch milliseconds of the last activity.
+ * @param now - the pinned reference clock (one value per list render).
+ */
+export function formatRelativeTime(timestamp: number, now: number): string {
+  const seconds = Math.round((now - timestamp) / 1000)
+  if (seconds < 0) return 'now'
+  if (seconds < 60) return 'now'
+  const minutes = Math.round(seconds / 60)
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.round(minutes / 60)
+  if (hours < 24) return `${hours}h ago`
+  const days = Math.round(hours / 24)
+  if (days < 7) return `${days}d ago`
+  const date = new Date(timestamp)
+  const month = `${date.getMonth() + 1}`.padStart(2, '0')
+  const day = `${date.getDate()}`.padStart(2, '0')
+  return `${date.getFullYear()}-${month}-${day}`
+}

package/src/skills.ts

@@ -69,12 +69,15 @@ export function watchSkills(ctx: Context): SkillsWatch {
   const listeners = new Set<() => void>()
 
   const reload = (): void => {
-    const currentAgent = agent
-    if (skills === undefined || currentAgent === undefined) return
+    const target = agent
+    if (skills === undefined || target === undefined) return
     Promise.resolve().then(() => skills.list({
-      cwd: currentAgent.session.header.cwd,
-      scope: currentAgent,
+      cwd: target.session.header.cwd,
+      scope: target,
     })).then((summaries: readonly SkillSummary[]) => {
+      // A retarget landed while this catalog was loading: the rows belong to
+      // another agent's workspace and must never overwrite the current view.
+      if (agent !== target) return
       const next = toRows(summaries)
       const unchanged = next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name)
       rows = next
@@ -83,6 +86,7 @@ export function watchSkills(ctx: Context): SkillsWatch {
       if (unchanged && !recovered) return
       for (const listener of listeners) listener()
     }).catch((cause: unknown) => {
+      if (agent !== target) return
       // Discovery failure keeps the last good rows; the next skills/change
       // notification is the retry surface (mirrors the web directory).
       rows = [...rows]

package/src/store.ts

@@ -1,8 +1,19 @@
 /**
  * Observable transcript store: folds session events into the projection view
  * and notifies subscribers. The renderer subscribes through
- * `useSyncExternalStore`; the runner owns event feeding. The store owns no
- * timing — listeners fire synchronously after each applied event.
+ * `useSyncExternalStore`; the runner owns event feeding.
+ *
+ * Notification coalescing: the fold stays synchronous — `getView()` always
+ * returns the latest state the moment `apply` returns — but listener
+ * notification is scheduled on a microtask and deduplicated, so N events
+ * delivered inside one synchronous drain (the zai/GLM adapter drains its
+ * token buffer in sub-millisecond bursts) produce ONE React re-render.
+ * Synchronous per-event notification instead cascades one
+ * `useSyncExternalStore` force-update per token inside a single flush; the
+ * reconciler counts those as nested passive updates and floods React's
+ * "Maximum update depth exceeded" warning past 50 events, besides rendering
+ * the whole live tree once per token. A microtask keeps latency within the
+ * same macrotask, before Ink's throttled paint.
  *
  * @module @deepseek-ai/dsh-tui/store
  */
@@ -35,6 +46,17 @@ export interface TranscriptStore {
 export function createTranscriptStore(replay?: readonly SessionEvent[]): TranscriptStore {
   let view = replay === undefined ? createTranscriptView() : projectEvents(replay)
   const listeners = new Set<() => void>()
+  let scheduled = false
+  const notify = (): void => {
+    if (scheduled) return
+    scheduled = true
+    queueMicrotask(() => {
+      scheduled = false
+      for (const listener of listeners) {
+        listener()
+      }
+    })
+  }
   return {
     getView: () => view,
     subscribe(listener: () => void): () => void {
@@ -47,15 +69,11 @@ export function createTranscriptStore(replay?: readonly SessionEvent[]): Transcr
       const next = projectEvent(view, event)
       if (next === view) return
       view = next
-      for (const listener of listeners) {
-        listener()
-      }
+      notify()
     },
     reset(): void {
       view = createTranscriptView()
-      for (const listener of listeners) {
-        listener()
-      }
+      notify()
     },
   }
 }

package/src/subagents.ts

@@ -0,0 +1,165 @@
+/**
+ * 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}. Rows are advisory display state, rebuilt from
+ * live events; nothing here persists or replays. Notification is coalesced
+ * to one microtask per delivery burst, mirroring the transcript store's
+ * contract (per-token synchronous notify once cascaded past React's nested
+ * update limit on the GLM thinking path).
+ *
+ * @module @deepseek-ai/dsh-code/subagents
+ */
+
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+
+/** Hard row cap: a fan-out larger than this stays summarized by the head. */
+export const MAX_SUBAGENT_ROWS = 8
+
+/** 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[]
+}
+
+/** 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/chunk':
+      return { ...base, state: 'running', activity: 'thinking…', 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 listeners = new Set<() => void>()
+  let scheduled = false
+  const notify = (): void => {
+    if (scheduled) return
+    scheduled = true
+    queueMicrotask(() => {
+      scheduled = false
+      for (const listener of listeners) listener()
+    })
+  }
+  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 (next === previous) return
+      if (index === -1 && rows.length >= MAX_SUBAGENT_ROWS) return
+      rows = Object.freeze(index === -1 ? [...rows, next] : rows.map((row, at) => at === index ? next : row))
+      notify()
+    },
+    reset(): void {
+      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
+    },
+  }
+}

package/src/version.ts

@@ -0,0 +1,16 @@
+/** Installed dsh-code version exposed by the terminal header. */
+
+import { readFileSync } from 'node:fs'
+
+/** Read one package manifest version without making terminal startup depend on it. */
+export function readPackageVersion(manifest = new URL('../package.json', import.meta.url)): string {
+  try {
+    const parsed = JSON.parse(readFileSync(manifest, 'utf8')) as { version?: unknown }
+    return typeof parsed.version === 'string' && parsed.version.length > 0 ? parsed.version : '0.0.0'
+  } catch {
+    return '0.0.0'
+  }
+}
+
+/** Version of the installed dsh-code package. */
+export const DSH_CODE_VERSION = readPackageVersion()