dsh-code 0.8.0 → 0.9.1

package/src/render/lines.ts

@@ -1,233 +1,236 @@
-/** Width-safe styled physical rows for bounded terminal panels. */
-
-import type { TranscriptEntry } from './projection.ts'
-import type { ToolDetail } from './tool-detail.ts'
-import { renderMarkdown, visibleColumns, type MdStyle } from './markdown.ts'
-import { formatTokens } from './status.ts'
-import { displayText } from './text.ts'
-
-/** Presentation classes mapped to Ink colors by the app boundary. */
-export type LineStyle = MdStyle | 'brand' | 'success' | 'error' | 'warn' | 'dimItalic'
-
-/** One styled run within a physical terminal row. */
-export interface StyledSegment {
-  text: string
-  style: LineStyle
-}
-
-/** One row guaranteed not to exceed the requested terminal width. */
-export interface StyledLine {
-  segments: readonly StyledSegment[]
-}
-
-/** Construct one segment without leaking mutable objects into cached rows. */
-export function lineSegment(text: string, style: LineStyle = 'plain'): StyledSegment {
-  return { text, style }
-}
-
-/** Append a character while merging adjacent runs with the same style. */
-function appendSegment(target: StyledSegment[], text: string, style: LineStyle): void {
-  const previous = target[target.length - 1]
-  if (previous?.style === style) {
-    target[target.length - 1] = { text: previous.text + text, style }
-    return
-  }
-  target.push({ text, style })
-}
-
-/**
- * Sanitize and hard-wrap styled content into exact physical rows.
- * Tabs become two visible spaces because terminal tab stops are contextual
- * and therefore cannot participate in a deterministic row budget.
- */
-export function styledLines(segments: readonly StyledSegment[], columns: number): readonly StyledLine[] {
-  const width = Math.max(1, Math.floor(columns))
-  const lines: StyledLine[] = []
-  let current: StyledSegment[] = []
-  let used = 0
-  const flush = (): void => {
-    lines.push({ segments: current })
-    current = []
-    used = 0
-  }
-
-  for (const segment of segments) {
-    const safe = displayText(segment.text).replaceAll('\t', '  ').replaceAll('\r', '')
-    for (const char of safe) {
-      if (char === '\n') {
-        flush()
-        continue
-      }
-      const cells = visibleColumns(char)
-      if (used > 0 && used + cells > width) flush()
-      appendSegment(current, char, segment.style)
-      used += cells
-    }
-  }
-  if (current.length > 0 || lines.length === 0) flush()
-  return lines
-}
-
-/** Plain/dim text convenience over {@link styledLines}. */
-export function textLines(text: string, columns: number, style: LineStyle = 'plain'): readonly StyledLine[] {
-  return styledLines([lineSegment(text, style)], columns)
-}
-
-/** Markdown rows re-hardened so a single long word cannot escape the budget. */
-export function markdownLines(text: string, columns: number): readonly StyledLine[] {
-  const width = Math.max(1, Math.floor(columns))
-  const parsed = renderMarkdown(displayText(text), Math.max(10, width))
-  return parsed.flatMap(line => styledLines(
-    line.segments.map(segment => lineSegment(segment.text, segment.style)),
-    width,
-  ))
-}
-
-/**
- * Codex-style reasoning rows: the marker occupies the reply gutter and every
- * wrapped or explicit continuation starts with the same two-column indent, so
- * reasoning content and assistant Markdown share one left edge.
- */
-export function reasoningLines(text: string, columns: number): readonly StyledLine[] {
-  const width = Math.max(1, Math.floor(columns))
-  if (width < 3) return textLines(text, width, 'dimItalic')
-  const contentWidth = width - 2
-  const content = displayText(text).replaceAll('\t', '  ').replaceAll('\r', '')
-    .split('\n')
-    .flatMap(line => styledLines([lineSegment(line, 'dimItalic')], contentWidth))
-  return content.map((line, index) => ({
-    segments: [
-      lineSegment(index === 0 ? '✻ ' : '  ', 'dimItalic'),
-      ...line.segments,
-    ],
-  }))
-}
-
-/** Expanded structured tool detail as scrollable, width-safe rows. */
-function toolDetailLines(detail: ToolDetail, columns: number): readonly StyledLine[] {
-  switch (detail.kind) {
-    case 'diff':
-      return detail.diffs.flatMap(diff => [
-        ...styledLines([
-          lineSegment('  ── ', 'dim'),
-          lineSegment(diff.path, 'dim'),
-          lineSegment(diff.truncated ? ' (diff truncated)' : '', 'dim'),
-        ], columns),
-        ...diff.lines.flatMap(line => styledLines([
-          lineSegment(`  ${line.mark}${line.text}`, line.mark === '+' ? 'success' : line.mark === '-' ? 'error' : 'dim'),
-        ], columns)),
-      ])
-    case 'read':
-      return [
-        ...textLines(
-          `  ── ${detail.path} · lines ${detail.offset}-${detail.lines.length > 0 ? detail.lines[detail.lines.length - 1]!.number : detail.offset - 1} of ${detail.totalLines}${detail.truncated ? ' (window truncated)' : ''}`,
-          columns,
-          'dim',
-        ),
-        ...detail.lines.flatMap(line => textLines(`  ${String(line.number).padStart(5, ' ')} | ${line.text}`, columns, 'dim')),
-      ]
-    case 'web-search':
-      return [
-        ...detail.sources.flatMap(source => [
-          ...styledLines([
-            lineSegment(`  ? ${source.title ?? source.url}`, 'brand'),
-            lineSegment(` - ${source.url}`, 'dim'),
-          ], columns),
-          ...(source.snippet === '' ? [] : textLines(`    ${source.snippet}`, columns, 'dim')),
-        ]),
-        ...textLines(`  ${detail.sources.length} sources${detail.truncated ? ' (capped)' : ''}`, columns, 'dim'),
-      ]
-    case 'web-fetch':
-      return textLines(`  ${detail.url} · HTTP ${detail.statusCode}`, columns, 'dim')
-    case 'raw':
-      return [
-        ...textLines(`  ${detail.text}`, columns, 'dim'),
-        ...textLines(detail.truncated ? '  … (output truncated)' : '  (end of output)', columns, 'dim'),
-      ]
-    default: {
-      const exhaustive: never = detail
-      return exhaustive
-    }
-  }
-}
-
-/**
- * Convert one durable transcript entry to its complete scrollable row model.
- * The source entry stays intact; only the caller's visible slice is rendered.
- */
-export function transcriptEntryLines(entry: TranscriptEntry, columns: number): readonly StyledLine[] {
-  const width = Math.max(1, Math.floor(columns))
-  switch (entry.kind) {
-    case 'user':
-      return styledLines([
-        lineSegment(entry.notice ? '⤷ ' : '❯ ', entry.notice ? 'dim' : 'brand'),
-        lineSegment(entry.text, entry.notice ? 'dim' : 'plain'),
-      ], width)
-    case 'pending':
-      // Codex PendingSteer: a queued prompt renders exactly like an ordinary
-      // user row, so the durable user/message retires it without any flicker.
-      return styledLines([
-        lineSegment('❯ ', 'brand'),
-        lineSegment(entry.text, 'plain'),
-      ], width)
-    case 'assistant': {
-      const reasoning = entry.reasoning === '' ? [] : reasoningLines(entry.reasoning, width)
-      // Every reply row carries the composer's two-column gutter, so reply
-      // text aligns with the input cursor (Codex LIVE_PREFIX alignment); the
-      // wrap budget shrinks by the same amount so no line double-wraps.
-      const body = markdownLines(entry.text, Math.max(10, width - 2))
-        .map(line => ({ segments: [{ text: '  ', style: 'plain' as const }, ...line.segments] }))
-      return [...reasoning, ...body]
-    }
-    case 'tool': {
-      const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
-      const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
-      return [
-        ...styledLines([
-          lineSegment(`${mark} `, markStyle),
-          lineSegment(entry.name, 'brand'),
-          lineSegment(entry.preview === '' ? '' : ` ${entry.preview}`, 'dim'),
-        ], width),
-        ...(entry.summary === '' ? [] : textLines(`  ⎿ ${entry.summary}`, width, entry.state === 'error' ? 'error' : 'dim')),
-        ...(entry.detail === undefined ? [] : toolDetailLines(entry.detail, width)),
-      ]
-    }
-    case 'command': {
-      const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
-      const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
-      return [
-        ...styledLines([
-          lineSegment(`${mark} `, markStyle),
-          lineSegment(`/${entry.name}`, 'brand'),
-          lineSegment(entry.args === '' ? '' : ` ${entry.args}`, 'dim'),
-        ], width),
-        ...(entry.summary === '' ? [] : textLines(`  ⎿ ${entry.summary}`, width, entry.state === 'error' ? 'error' : 'dim')),
-      ]
-    }
-    case 'turn-marker':
-      return textLines(`  ⏹ ${entry.text}`, width, 'dim')
-    case 'compaction':
-      return textLines(entry.ok
-        ? `  ⧉ compacted ~${formatTokens(entry.tokens)} tokens`
-        : `  ⧉ compaction failed: ${entry.error}`, width, 'dim')
-    case 'retry':
-      return textLines(
-        `  ↻ retry ${entry.attempt}/${entry.max} · ${entry.code} · ${Math.round(entry.delayMs / 100) / 10}s`,
-        width,
-        entry.state === 'running' ? 'warn' : 'dim',
-      )
-    case 'files':
-      return entry.paths.length === 0
-        ? textLines('  ⎄ no changed files', width, 'dim')
-        : [
-          ...textLines(`  ⎄ ${entry.paths.length} changed file${entry.paths.length === 1 ? '' : 's'}`, width, 'dim'),
-          ...entry.paths.flatMap(path => textLines(`    ${path}`, width, 'dim')),
-        ]
-    case 'error':
-      return textLines(entry.text, width, 'error')
-    default: {
-      const exhaustive: never = entry
-      return exhaustive
-    }
-  }
-}
+/** Width-safe styled physical rows for bounded terminal panels. */
+
+import type { TranscriptEntry } from './projection.ts'
+import type { ToolDetail } from './tool-detail.ts'
+import { renderMarkdown, visibleColumns, type MdStyle } from './markdown.ts'
+import { formatTokens } from './status.ts'
+import { displayText } from './text.ts'
+
+/** Presentation classes mapped to Ink colors by the app boundary. */
+export type LineStyle = MdStyle | 'brand' | 'success' | 'error' | 'warn' | 'dimItalic'
+
+/** One styled run within a physical terminal row. */
+export interface StyledSegment {
+  text: string
+  style: LineStyle
+}
+
+/** One row guaranteed not to exceed the requested terminal width. */
+export interface StyledLine {
+  segments: readonly StyledSegment[]
+}
+
+/** Construct one segment without leaking mutable objects into cached rows. */
+export function lineSegment(text: string, style: LineStyle = 'plain'): StyledSegment {
+  return { text, style }
+}
+
+/** Append a character while merging adjacent runs with the same style. */
+function appendSegment(target: StyledSegment[], text: string, style: LineStyle): void {
+  const previous = target[target.length - 1]
+  if (previous?.style === style) {
+    target[target.length - 1] = { text: previous.text + text, style }
+    return
+  }
+  target.push({ text, style })
+}
+
+/**
+ * Sanitize and hard-wrap styled content into exact physical rows.
+ * Tabs become two visible spaces because terminal tab stops are contextual
+ * and therefore cannot participate in a deterministic row budget.
+ */
+export function styledLines(segments: readonly StyledSegment[], columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  const lines: StyledLine[] = []
+  let current: StyledSegment[] = []
+  let used = 0
+  const flush = (): void => {
+    lines.push({ segments: current })
+    current = []
+    used = 0
+  }
+
+  for (const segment of segments) {
+    const safe = displayText(segment.text).replaceAll('\t', '  ').replaceAll('\r', '')
+    for (const char of safe) {
+      if (char === '\n') {
+        flush()
+        continue
+      }
+      const cells = visibleColumns(char)
+      if (used > 0 && used + cells > width) flush()
+      appendSegment(current, char, segment.style)
+      used += cells
+    }
+  }
+  if (current.length > 0 || lines.length === 0) flush()
+  return lines
+}
+
+/** Plain/dim text convenience over {@link styledLines}. */
+export function textLines(text: string, columns: number, style: LineStyle = 'plain'): readonly StyledLine[] {
+  return styledLines([lineSegment(text, style)], columns)
+}
+
+/** Markdown rows re-hardened so a single long word cannot escape the budget. */
+export function markdownLines(text: string, columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  const parsed = renderMarkdown(displayText(text), Math.max(10, width))
+  return parsed.flatMap(line => styledLines(
+    line.segments.map(segment => lineSegment(segment.text, segment.style)),
+    width,
+  ))
+}
+
+/**
+ * Codex-style reasoning rows: the marker occupies the reply gutter and every
+ * wrapped or explicit continuation starts with the same two-column indent, so
+ * reasoning content and assistant Markdown share one left edge.
+ */
+export function reasoningLines(text: string, columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  if (width < 3) return textLines(text, width, 'dimItalic')
+  const contentWidth = width - 2
+  const content = displayText(text).replaceAll('\t', '  ').replaceAll('\r', '')
+    .split('\n')
+    .flatMap(line => styledLines([lineSegment(line, 'dimItalic')], contentWidth))
+  return content.map((line, index) => ({
+    segments: [
+      lineSegment(index === 0 ? '✻ ' : '  ', 'dimItalic'),
+      ...line.segments,
+    ],
+  }))
+}
+
+/** Expanded structured tool detail as scrollable, width-safe rows. */
+function toolDetailLines(detail: ToolDetail, columns: number): readonly StyledLine[] {
+  switch (detail.kind) {
+    case 'diff':
+      return detail.diffs.flatMap(diff => [
+        ...styledLines([
+          lineSegment('  ── ', 'dim'),
+          lineSegment(diff.path, 'dim'),
+          lineSegment(diff.truncated ? ' (diff truncated)' : '', 'dim'),
+        ], columns),
+        ...diff.lines.flatMap(line => styledLines([
+          lineSegment(`  ${line.mark}${line.text}`, line.mark === '+' ? 'success' : line.mark === '-' ? 'error' : 'dim'),
+        ], columns)),
+      ])
+    case 'read':
+      return [
+        ...textLines(
+          `  ── ${detail.path} · lines ${detail.offset}-${detail.lines.length > 0 ? detail.lines[detail.lines.length - 1]!.number : detail.offset - 1} of ${detail.totalLines}${detail.truncated ? ' (window truncated)' : ''}`,
+          columns,
+          'dim',
+        ),
+        ...detail.lines.flatMap(line => textLines(`  ${String(line.number).padStart(5, ' ')} | ${line.text}`, columns, 'dim')),
+      ]
+    case 'web-search':
+      return [
+        ...detail.sources.flatMap(source => [
+          ...styledLines([
+            lineSegment(`  ? ${source.title ?? source.url}`, 'brand'),
+            lineSegment(` - ${source.url}`, 'dim'),
+          ], columns),
+          ...(source.snippet === '' ? [] : textLines(`    ${source.snippet}`, columns, 'dim')),
+        ]),
+        ...textLines(`  ${detail.sources.length} sources${detail.truncated ? ' (capped)' : ''}`, columns, 'dim'),
+      ]
+    case 'web-fetch':
+      return textLines(`  ${detail.url} · HTTP ${detail.statusCode}`, columns, 'dim')
+    case 'raw':
+      return [
+        ...textLines(`  ${detail.text}`, columns, 'dim'),
+        ...textLines(detail.truncated ? '  … (output truncated)' : '  (end of output)', columns, 'dim'),
+      ]
+    default: {
+      const exhaustive: never = detail
+      return exhaustive
+    }
+  }
+}
+
+/**
+ * Convert one durable transcript entry to its complete scrollable row model.
+ * The source entry stays intact; only the caller's visible slice is rendered.
+ */
+export function transcriptEntryLines(entry: TranscriptEntry, columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  switch (entry.kind) {
+    case 'user':
+      return styledLines([
+        lineSegment(entry.notice ? '⤷ ' : '❯ ', entry.notice ? 'dim' : 'brand'),
+        lineSegment(entry.text, entry.notice ? 'dim' : 'plain'),
+      ], width)
+    case 'pending':
+      // Codex PendingSteer: a queued prompt renders exactly like an ordinary
+      // user row, so the durable user/message retires it without any flicker.
+      return styledLines([
+        lineSegment('❯ ', 'brand'),
+        lineSegment(entry.text, 'plain'),
+      ], width)
+    case 'assistant': {
+      const reasoning = entry.reasoning === '' ? [] : reasoningLines(entry.reasoning, width)
+      // Every reply row carries the composer's two-column gutter, so reply
+      // text aligns with the input cursor (Codex LIVE_PREFIX alignment); the
+      // wrap budget shrinks by the same amount so no line double-wraps.
+      const body = markdownLines(entry.text, Math.max(10, width - 2))
+        .map(line => ({ segments: [{ text: '  ', style: 'plain' as const }, ...line.segments] }))
+      return [...reasoning, ...body]
+    }
+    case 'tool': {
+      const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
+      const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
+      return [
+        ...styledLines([
+          lineSegment(`${mark} `, markStyle),
+          lineSegment(entry.name, 'brand'),
+          lineSegment(entry.preview === '' ? '' : ` ${entry.preview}`, 'dim'),
+        ], width),
+        // A delegation card carries what the child was asked (Codex's
+        // SpawnAgent prompt preview) while it runs, before any result.
+        ...(entry.prompt === '' ? [] : textLines(`  └ ${entry.prompt}`, width, 'dim')),
+        ...(entry.summary === '' ? [] : textLines(`  ⎿ ${entry.summary}`, width, entry.state === 'error' ? 'error' : 'dim')),
+        ...(entry.detail === undefined ? [] : toolDetailLines(entry.detail, width)),
+      ]
+    }
+    case 'command': {
+      const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
+      const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
+      return [
+        ...styledLines([
+          lineSegment(`${mark} `, markStyle),
+          lineSegment(`/${entry.name}`, 'brand'),
+          lineSegment(entry.args === '' ? '' : ` ${entry.args}`, 'dim'),
+        ], width),
+        ...(entry.summary === '' ? [] : textLines(`  ⎿ ${entry.summary}`, width, entry.state === 'error' ? 'error' : 'dim')),
+      ]
+    }
+    case 'turn-marker':
+      return textLines(`  ⏹ ${entry.text}`, width, 'dim')
+    case 'compaction':
+      return textLines(entry.ok
+        ? `  ⧉ compacted ~${formatTokens(entry.tokens)} tokens`
+        : `  ⧉ compaction failed: ${entry.error}`, width, 'dim')
+    case 'retry':
+      return textLines(
+        `  ↻ retry ${entry.attempt}/${entry.max} · ${entry.code} · ${Math.round(entry.delayMs / 100) / 10}s`,
+        width,
+        entry.state === 'running' ? 'warn' : 'dim',
+      )
+    case 'files':
+      return entry.paths.length === 0
+        ? textLines('  ⎄ no changed files', width, 'dim')
+        : [
+          ...textLines(`  ⎄ ${entry.paths.length} changed file${entry.paths.length === 1 ? '' : 's'}`, width, 'dim'),
+          ...entry.paths.flatMap(path => textLines(`    ${path}`, width, 'dim')),
+        ]
+    case 'error':
+      return textLines(entry.text, width, 'error')
+    default: {
+      const exhaustive: never = entry
+      return exhaustive
+    }
+  }
+}

package/src/render/projection.ts

@@ -22,7 +22,7 @@ import type {} from '@deepseek-ai/dsh-plan-mode'
 import type {} from '@deepseek-ai/dsh-permission-presets'
 import type {} from '@deepseek-ai/dsh-sandbox-policy'
 import type {} from '@deepseek-ai/dsh-session-title'
-import { toolArgumentsPreview } from './tool-preview.ts'
+import { toolArgumentsPreview, toolPromptPreview } from './tool-preview.ts'
 import { toolResultDetail, type ToolDetail } from './tool-detail.ts'
 
 /** In-flight UI buffers are tails; the assembled assistant message is authoritative. */
@@ -85,6 +85,8 @@ export interface ToolEntry {
   arguments: string
   /** Bounded human-meaningful arguments preview for the tool card. */
   preview: string
+  /** Bounded delegation prompt (subagent cards' second row), '' when none. */
+  prompt: string
   /** Execution state; `running` until the paired result lands. */
   state: 'running' | 'done' | 'error'
   /** Bounded first text block of the result, empty until it lands. */
@@ -525,6 +527,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           name: data.name,
           arguments: data.arguments,
           preview: toolArgumentsPreview(data.arguments, data.name),
+          prompt: toolPromptPreview(data.name, data.arguments),
           state: 'running',
           summary: '',
           detail: undefined,
@@ -1098,6 +1101,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         name: data.name,
         arguments: data.arguments,
         preview: toolArgumentsPreview(data.arguments, data.name),
+        prompt: toolPromptPreview(data.name, data.arguments),
         state: 'running',
         summary: '',
         detail: undefined,

package/src/render/tool-preview.ts

@@ -1,50 +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. 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)
-}
+/**
+ * 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 ''
+  }
+}