nastech-tui 0.0.1

package/src/components/todoPanel.tsx

@@ -0,0 +1,93 @@
+import { Box, Text } from '@nastechai/ink'
+import { memo, useState } from 'react'
+
+import { countPendingTodos } from '../lib/liveProgress.js'
+import { todoGlyph, todoTone } from '../lib/todo.js'
+import type { Theme } from '../theme.js'
+import type { TodoItem } from '../types.js'
+
+const rowColor = (t: Theme, status: TodoItem['status']) => {
+  const tone = todoTone(status)
+
+  return tone === 'active' ? t.color.text : tone === 'body' ? t.color.statusFg : t.color.muted
+}
+
+export const TodoPanel = memo(function TodoPanel({
+  collapsed,
+  defaultCollapsed = false,
+  incomplete = false,
+  onToggle,
+  t,
+  todos
+}: {
+  collapsed?: boolean
+  defaultCollapsed?: boolean
+  incomplete?: boolean
+  onToggle?: () => void
+  t: Theme
+  todos: TodoItem[]
+}) {
+  // Fallback local state for archived todos in transcript where there's no
+  // external controller. Live TodoPanel passes collapsed+onToggle from the
+  // turn store so clicks still work there.
+  const [localCollapsed, setLocalCollapsed] = useState(defaultCollapsed)
+  const isControlled = typeof collapsed === 'boolean'
+  const effectiveCollapsed = isControlled ? collapsed : localCollapsed
+
+  const handleToggle = () => {
+    if (onToggle) {
+      onToggle()
+
+      return
+    }
+
+    if (!isControlled) {
+      setLocalCollapsed(v => !v)
+    }
+  }
+
+  if (!todos.length) {
+    return null
+  }
+
+  const done = todos.filter(todo => todo.status === 'completed').length
+  const pending = countPendingTodos(todos)
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Box onClick={handleToggle}>
+        <Text color={t.color.muted}>
+          <Text color={t.color.accent}>{effectiveCollapsed ? '▸ ' : '▾ '}</Text>
+          <Text bold color={t.color.text}>
+            Todo
+          </Text>{' '}
+          <Text color={t.color.statusFg} dim>
+            ({done}/{todos.length})
+          </Text>
+          {incomplete && pending > 0 && (
+            <Text color={t.color.muted} dim>
+              {' '}
+              · incomplete · {pending} still {pending === 1 ? 'pending' : 'pending/in_progress'}
+            </Text>
+          )}
+        </Text>
+      </Box>
+
+      {!effectiveCollapsed && (
+        <Box flexDirection="column" marginLeft={2}>
+          {todos.map(todo => {
+            const tone = todoTone(todo.status)
+            const color = rowColor(t, todo.status)
+
+            return (
+              <Text color={color} dim={tone === 'dim'} key={todo.id}>
+                <Text color={color}>{todoGlyph(todo.status)} </Text>
+                {todo.content}
+              </Text>
+            )
+          })}
+        </Box>
+      )}
+    </Box>
+  )
+})

package/src/config/env.ts

@@ -0,0 +1,64 @@
+import type { MouseTrackingMode } from '@nastechai/ink'
+import { isTermuxTuiMode } from '../lib/termux.js'
+
+const truthy = (v?: string) => /^(?:1|true|yes|on)$/i.test((v ?? '').trim())
+const falsy = (v?: string) => /^(?:0|false|no|off)$/i.test((v ?? '').trim())
+
+const parseToggle = (v?: string): boolean | null => {
+  const raw = (v ?? '').trim()
+
+  if (!raw) {
+    return null
+  }
+
+  if (truthy(raw)) {
+    return true
+  }
+
+  if (falsy(raw)) {
+    return false
+  }
+
+  return null
+}
+
+export const TERMUX_TUI_MODE = isTermuxTuiMode()
+
+export const STARTUP_RESUME_ID = (process.env.NASTECH_TUI_RESUME ?? '').trim()
+export const STARTUP_QUERY = (process.env.NASTECH_TUI_QUERY ?? '').trim()
+export const STARTUP_IMAGE = (process.env.NASTECH_TUI_IMAGE ?? '').trim()
+
+// Mouse tracking mode resolution at startup. Per-mode selection (off|wheel|
+// buttons|all) lives in display.mouse_tracking in config.yaml — these env
+// vars only set the boot-time default before that config is applied.
+//
+// Precedence (highest first):
+//
+// - NASTECH_TUI_MOUSE_TRACKING (truthy/falsy) explicitly overrides everything.
+//   This is the "force a value" knob and intentionally beats the legacy
+//   kill-switch and the Termux default.
+// - NASTECH_TUI_DISABLE_MOUSE=1 forces mouse off — the legacy kill switch.
+// - On Termux the default is mouse off so touch selection isn't intercepted
+//   by terminal mouse protocols. Desktop defaults to 'all' to preserve prior
+//   behavior.
+const mouseTrackingOverride = parseToggle(process.env.NASTECH_TUI_MOUSE_TRACKING)
+const mouseTrackingDisabledLegacy = truthy(process.env.NASTECH_TUI_DISABLE_MOUSE)
+const resolvedBootMouseEnabled =
+  mouseTrackingOverride ?? (TERMUX_TUI_MODE ? false : !mouseTrackingDisabledLegacy)
+export const MOUSE_TRACKING: MouseTrackingMode = resolvedBootMouseEnabled ? 'all' : 'off'
+
+export const NO_CONFIRM_DESTRUCTIVE = truthy(process.env.NASTECH_TUI_NO_CONFIRM)
+
+const inlineOverride = parseToggle(process.env.NASTECH_TUI_INLINE)
+
+// Skip AlternateScreen — TUI renders into the primary buffer so the host
+// terminal's native scrollback captures whatever scrolls off the top.
+//
+// On Termux we default this on: users often background/foreground the app,
+// and primary-buffer rendering makes long-thread review and copy/paste much
+// less fragile. Override explicitly with NASTECH_TUI_INLINE=0/1.
+export const INLINE_MODE = inlineOverride ?? TERMUX_TUI_MODE
+
+// Live FPS counter overlay, fed by ink's onFrame (real render rate, not a
+// synthetic timer).
+export const SHOW_FPS = truthy(process.env.NASTECH_TUI_FPS)

package/src/config/limits.ts

@@ -0,0 +1,13 @@
+export const LARGE_PASTE = { lines: 5 }
+
+export const LIVE_RENDER_MAX_CHARS = 16_000
+export const LIVE_RENDER_MAX_LINES = 240
+
+export const LONG_MSG = 300
+export const MAX_HISTORY = 800
+export const THINKING_COT_MAX = 160
+
+// Rows per wheel event (pre-accel). 1 keeps Ink's DECSTBM fast path live
+// (each scroll < viewport-1) and produces smooth motion. wheelAccel.ts
+// ramps this on sustained scrolls.
+export const WHEEL_SCROLL_STEP = 1

package/src/config/timing.ts

@@ -0,0 +1,6 @@
+export const STREAM_BATCH_MS = 16
+export const STREAM_IDLE_BATCH_MS = 16
+export const STREAM_SCROLL_BATCH_MS = 96
+export const STREAM_TYPING_BATCH_MS = 80
+export const TYPING_IDLE_MS = 250
+export const REASONING_PULSE_MS = 700

package/src/content/charms.ts

@@ -0,0 +1 @@
+export const LONG_RUN_CHARMS = ['still cooking…', 'polishing edges…', 'asking the void nicely…']

package/src/content/faces.ts

@@ -0,0 +1,17 @@
+export const FACES = [
+  '(｡•́︿•̀｡)',
+  '(◔_◔)',
+  '(¬‿¬)',
+  '( •_•)>⌐■-■',
+  '(⌐■_■)',
+  '(´･_･`)',
+  '◉_◉',
+  '(°ロ°)',
+  '( ˘⌣˘)♡',
+  'ヽ(>∀<☆)☆',
+  '٩(๑❛ᴗ❛๑)۶',
+  '(⊙_⊙)',
+  '(¬_¬)',
+  '( ͡° ͜ʖ ͡°)',
+  'ಠ_ಠ'
+]

package/src/content/fortunes.ts

@@ -0,0 +1,30 @@
+const FORTUNES = [
+  'you are one clean refactor away from clarity',
+  'a tiny rename today prevents a huge bug tomorrow',
+  'your next commit message will be immaculate',
+  'the edge case you are ignoring is already solved in your head',
+  'minimal diff, maximal calm',
+  'today favors bold deletions over new abstractions',
+  'the right helper is already in your codebase',
+  'you will ship before overthinking catches up',
+  'tests are about to save your future self',
+  'your instincts are correctly suspicious of that one branch'
+]
+
+const LEGENDARY = [
+  'legendary drop: one-line fix, first try',
+  'legendary drop: every flaky test passes cleanly',
+  'legendary drop: your diff teaches by itself'
+]
+
+const hash = (s: string) => [...s].reduce((h, c) => Math.imul(h ^ c.charCodeAt(0), 16777619), 2166136261) >>> 0
+
+const fromScore = (n: number) => {
+  const rare = n % 20 === 0
+  const bag = rare ? LEGENDARY : FORTUNES
+
+  return `${rare ? '🌟' : '🔮'} ${bag[n % bag.length]}`
+}
+
+export const randomFortune = () => fromScore(Math.floor(Math.random() * 0x7fffffff))
+export const dailyFortune = (seed: null | string) => fromScore(hash(`${seed || 'anon'}|${new Date().toDateString()}`))

package/src/content/hotkeys.ts

@@ -0,0 +1,37 @@
+import { isMac, isRemoteShell } from '../lib/platform.js'
+
+const action = isMac ? 'Cmd' : 'Ctrl'
+const paste = isMac ? 'Cmd' : 'Alt'
+
+const copyHotkeys: [string, string][] = isMac
+  ? [
+      ['Cmd+C', 'copy selection'],
+      ['Ctrl+C', 'interrupt / clear draft / exit']
+    ]
+  : isRemoteShell()
+    ? [
+        ['Cmd+C', 'copy selection when forwarded by the terminal'],
+        ['Ctrl+C', 'copy selection / interrupt / clear draft / exit']
+      ]
+    : [['Ctrl+C', 'copy selection / interrupt / clear draft / exit']]
+
+export const HOTKEYS: [string, string][] = [
+  ...copyHotkeys,
+  [action + '+D', 'exit'],
+  [action + '+G / Alt+G', 'open $EDITOR (Alt+G fallback for VSCode/Cursor)'],
+  [action + '+L', 'redraw / repaint'],
+  [paste + '+V / /paste', 'paste text; /paste attaches clipboard image'],
+  ['Tab', 'apply completion'],
+  ['↑/↓', 'completions / queue edit / history'],
+  ['Ctrl+X', 'open live session switcher (deletes queued message while editing)'],
+  [action + '+A/E', 'home / end of line'],
+  [action + '+Z / ' + action + '+Y', 'undo / redo input edits'],
+  [action + '+W', 'delete word'],
+  [action + '+U/K', 'delete to start / end'],
+  [action + '+←/→', 'jump word'],
+  ['Home/End', 'start / end of line'],
+  ['Shift+Enter / Alt+Enter', 'insert newline'],
+  ['\\+Enter', 'multi-line continuation (fallback)'],
+  ['!<cmd>', 'run a shell command (e.g. !ls, !git status)'],
+  ['{!<cmd>}', 'interpolate shell output inline (e.g. "branch is {!git branch --show-current}")']
+]

package/src/content/placeholders.ts

@@ -0,0 +1,13 @@
+import { pick } from '../lib/text.js'
+
+export const PLACEHOLDERS = [
+  'Ask me anything…',
+  'Try "explain this codebase"',
+  'Try "write a test for…"',
+  'Try "refactor the auth module"',
+  'Try "/help" for commands',
+  'Try "fix the lint errors"',
+  'Try "how does the config loader work?"'
+]
+
+export const PLACEHOLDER = pick(PLACEHOLDERS)

package/src/content/setup.ts

@@ -0,0 +1,17 @@
+import type { PanelSection } from '../types.js'
+
+export const SETUP_REQUIRED_TITLE = 'Setup Required'
+
+export const buildSetupRequiredSections = (): PanelSection[] => [
+  {
+    text: 'NasTech needs a model provider before the TUI can start a session.'
+  },
+  {
+    rows: [
+      ['/model', 'configure provider + model in-place'],
+      ['/setup', 'run full first-time setup wizard in-place'],
+      ['Ctrl+C', 'exit and run `nastech setup` manually']
+    ],
+    title: 'Actions'
+  }
+]

package/src/content/verbs.ts

@@ -0,0 +1,38 @@
+export const TOOL_VERBS: Record<string, string> = {
+  browser: 'browsing',
+  clarify: 'asking',
+  create_file: 'creating',
+  delegate_task: 'delegating',
+  delete_file: 'deleting',
+  execute_code: 'executing',
+  image_generate: 'generating',
+  list_files: 'listing',
+  memory: 'remembering',
+  patch: 'patching',
+  read_file: 'reading',
+  run_command: 'running',
+  search_code: 'searching',
+  search_files: 'searching',
+  terminal: 'terminal',
+  web_extract: 'extracting',
+  web_search: 'searching',
+  write_file: 'writing'
+}
+
+export const VERBS = [
+  'pondering',
+  'contemplating',
+  'musing',
+  'cogitating',
+  'ruminating',
+  'deliberating',
+  'mulling',
+  'reflecting',
+  'processing',
+  'reasoning',
+  'analyzing',
+  'computing',
+  'synthesizing',
+  'formulating',
+  'brainstorming'
+]

package/src/domain/blockLayout.ts

@@ -0,0 +1,146 @@
+import type { DetailsMode, Msg, SectionVisibility } from '../types.js'
+
+import { sectionMode } from './details.js'
+
+/**
+ * Visual group a transcript block belongs to. Blocks in the same group render
+ * flush; a single blank line opens at each group boundary. So a run of tool
+ * trails (or model paragraphs) reads as one section and the eye only catches a
+ * gap where the *kind* of content actually changes — the boundary between
+ * reasoning/tool trails, model prose, and notes/errors.
+ *
+ *   user   — the human turn (owns its separator + margins in MessageLine)
+ *   model  — assistant prose, the model's voice
+ *   trail  — reasoning + tool-call trails (the agent's working area)
+ *   note   — system notes and errors (a quieter band)
+ *   diff   — inline patch segments (an island, owns its own margins)
+ *   slash  — slash-command echoes (owns its margin)
+ *   intro  — banner / panels (rendered out-of-band, never gapped here)
+ */
+export type BlockGroup = 'diff' | 'intro' | 'model' | 'note' | 'slash' | 'trail' | 'user'
+
+export const messageGroup = (msg: Pick<Msg, 'kind' | 'role'>): BlockGroup => {
+  switch (msg.kind) {
+    case 'intro':
+    case 'panel':
+      return 'intro'
+    case 'slash':
+      return 'slash'
+    case 'diff':
+      return 'diff'
+    case 'trail':
+      return 'trail'
+  }
+
+  if (msg.role === 'user') {
+    return 'user'
+  }
+
+  // Assistant prose is the model's voice; system notes/errors are their own
+  // band. (No runtime block uses role 'tool' — tool *results* fold into
+  // trails — so a stray 'tool' falls through to the note band harmlessly.)
+  return msg.role === 'assistant' ? 'model' : 'note'
+}
+
+// Groups whose leading gap is already owned by their own chrome in
+// MessageLine (the turn separator + top margin for user, the top margin for
+// slash, the top+bottom margins for diff) or that are painted out-of-band
+// (intro). The grouping primitive only spaces the model working area —
+// model prose, reasoning/tool trails, and notes/errors.
+const SELF_SPACED: ReadonlySet<BlockGroup> = new Set(['diff', 'intro', 'slash', 'user'])
+
+// Groups that already paint a trailing blank line beneath themselves
+// (marginBottom in MessageLine), so the block that follows must not add its
+// own leading gap or the single boundary would become a double gap.
+const PAINTS_TRAILING_GAP: ReadonlySet<BlockGroup> = new Set(['diff', 'user'])
+
+/**
+ * Whether `cur` renders one blank line above it, given the block rendered
+ * directly above it (`prev`). True only where the visual group changes, and
+ * only for the model-working-area bands (model / trail / note) — user, slash,
+ * diff, and intro keep their existing spacing.
+ *
+ * Streaming-safe by construction: the result depends on the *predecessor's*
+ * group, never on `cur`'s own (live, changing) content. The actively-streaming
+ * assistant block therefore computes the same gap while it streams as the
+ * settled segment does once it flushes, so the live area never jumps.
+ */
+export const hasLeadGap = (
+  prev: Pick<Msg, 'kind' | 'role'> | undefined,
+  cur: Pick<Msg, 'kind' | 'role'>
+): boolean => {
+  const group = messageGroup(cur)
+
+  if (SELF_SPACED.has(group)) {
+    return false
+  }
+
+  if (!prev) {
+    return false
+  }
+
+  const prevGroup = messageGroup(prev)
+
+  return prevGroup !== group && !PAINTS_TRAILING_GAP.has(prevGroup)
+}
+
+export interface DetailsCtx {
+  commandOverride?: boolean
+  detailsMode: DetailsMode
+  sections?: SectionVisibility
+}
+
+const trailAllHidden = (ctx: DetailsCtx): boolean =>
+  sectionMode('thinking', ctx.detailsMode, ctx.sections, ctx.commandOverride) === 'hidden' &&
+  sectionMode('tools', ctx.detailsMode, ctx.sections, ctx.commandOverride) === 'hidden' &&
+  sectionMode('activity', ctx.detailsMode, ctx.sections, ctx.commandOverride) === 'hidden'
+
+/**
+ * Whether a settled transcript block paints anything. A trail renders nothing
+ * when it has no reasoning/tools/todos to show (e.g. the finalDetails segment
+ * that carries only a token tally) or when every section it does have is hidden
+ * (`/details hidden`); every other block draws at least one row. A block that
+ * renders nothing is *transparent* to grouping: the block below it draws its
+ * boundary against the nearest visible block instead (see prevRenderedMsg), so
+ * a hidden or content-less trail never leaves a floating blank line, doubles
+ * the gap after a user prompt, or pads the space above the final reply. In the
+ * default/collapsed modes content-bearing trails always render, so this is a
+ * no-op there.
+ */
+export const blockRenders = (msg: Pick<Msg, 'kind' | 'thinking' | 'todos' | 'tools'>, ctx: DetailsCtx): boolean => {
+  if (msg.kind !== 'trail') {
+    return true
+  }
+
+  if (msg.todos?.length) {
+    return true
+  }
+
+  if (!(msg.tools?.length || msg.thinking?.trim())) {
+    return false
+  }
+
+  return !trailAllHidden(ctx)
+}
+
+/**
+ * The nearest block above `index` that actually renders, resolved through a
+ * lazy accessor so it works over either the virtualized history rows or the
+ * live block list. This is the grouping predecessor — using it (instead of the
+ * literal previous row) keeps hidden trails from interrupting the rhythm.
+ */
+export const prevRenderedMsg = (
+  msgAt: (i: number) => Msg | undefined,
+  index: number,
+  ctx: DetailsCtx
+): Msg | undefined => {
+  for (let i = index - 1; i >= 0; i--) {
+    const candidate = msgAt(i)
+
+    if (candidate && blockRenders(candidate, ctx)) {
+      return candidate
+    }
+  }
+
+  return undefined
+}

package/src/domain/details.ts

@@ -0,0 +1,76 @@
+import type { DetailsMode, SectionName, SectionVisibility } from '../types.js'
+
+const MODES = ['hidden', 'collapsed', 'expanded'] as const
+
+export const SECTION_NAMES = ['thinking', 'tools', 'subagents', 'activity'] as const
+
+// Out-of-the-box per-section defaults — applied when the user hasn't pinned
+// an explicit override and layered ABOVE the global details_mode:
+//
+//   - thinking / tools: expanded — stream open so the turn reads like a
+//     live transcript (reasoning + tool calls side by side) instead of a
+//     wall of chevrons the user has to click every turn.
+//   - activity: hidden — ambient meta (gateway hints, terminal-parity
+//     nudges, background notifications) is noise for typical use.  Tool
+//     failures still render inline on the failing tool row, and ambient
+//     errors/warnings surface via the floating-alert backstop when every
+//     panel resolves to hidden.
+//   - subagents: not set — falls through to the global details_mode so
+//     Spawn trees stay under a chevron until a delegation actually happens.
+//
+// Opt out of any of these with `display.sections.<name>` in config.yaml
+// or at runtime via `/details <name> collapsed|hidden`.
+const SECTION_DEFAULTS: SectionVisibility = {
+  thinking: 'expanded',
+  tools: 'expanded',
+  activity: 'hidden'
+}
+
+const THINKING_FALLBACK: Record<string, DetailsMode> = {
+  collapsed: 'collapsed',
+  full: 'expanded',
+  truncated: 'collapsed'
+}
+
+const norm = (v: unknown) =>
+  String(v ?? '')
+    .trim()
+    .toLowerCase()
+
+export const parseDetailsMode = (v: unknown): DetailsMode | null => MODES.find(m => m === norm(v)) ?? null
+
+export const isSectionName = (v: unknown): v is SectionName =>
+  typeof v === 'string' && (SECTION_NAMES as readonly string[]).includes(v)
+
+export const resolveDetailsMode = (d?: { details_mode?: unknown; thinking_mode?: unknown } | null): DetailsMode =>
+  parseDetailsMode(d?.details_mode) ?? THINKING_FALLBACK[norm(d?.thinking_mode)] ?? 'collapsed'
+
+// Build SectionVisibility from a free-form blob.  Unknown section names and
+// invalid modes are dropped silently — partial overrides are intentional, so
+// missing keys fall through to SECTION_DEFAULTS / global at lookup time.
+export const resolveSections = (raw: unknown): SectionVisibility =>
+  raw && typeof raw === 'object' && !Array.isArray(raw)
+    ? (Object.fromEntries(
+        Object.entries(raw as Record<string, unknown>)
+          .map(([k, v]) => [k, parseDetailsMode(v)] as const)
+          .filter(([k, m]) => !!m && isSectionName(k))
+      ) as SectionVisibility)
+    : {}
+
+// Effective mode for one section: explicit override → global command mode →
+// built-in live-stream defaults → global config mode.
+//
+// The `commandOverride` flag is set for in-session `/details <mode>` changes.
+// That command should immediately apply to every section, including sections
+// with built-in defaults like thinking/tools=expanded and activity=hidden. On
+// startup/config sync we keep those defaults layered above the persisted global
+// config so the TUI still opens live reasoning/tools by default unless the user
+// pins explicit per-section overrides.
+export const sectionMode = (
+  name: SectionName,
+  global: DetailsMode,
+  sections?: SectionVisibility,
+  commandOverride = false
+): DetailsMode => sections?.[name] ?? (commandOverride ? global : (SECTION_DEFAULTS[name] ?? global))
+
+export const nextDetailsMode = (m: DetailsMode): DetailsMode => MODES[(MODES.indexOf(m) + 1) % MODES.length]!

package/src/domain/messages.ts

@@ -0,0 +1,91 @@
+import { LONG_MSG } from '../config/limits.js'
+import { buildToolTrailLine, fmtK } from '../lib/text.js'
+import type { Msg, SessionInfo } from '../types.js'
+
+export const introMsg = (info: SessionInfo): Msg => ({ info, kind: 'intro', role: 'system', text: '' })
+
+export const imageTokenMeta = (info?: ImageMeta | null) => {
+  const { width, height, token_estimate: t } = info ?? {}
+
+  return [width && height ? `${width}x${height}` : '', (t ?? 0) > 0 ? `~${fmtK(t!)} tok` : '']
+    .filter(Boolean)
+    .join(' · ')
+}
+
+export const attachedImageNotice = (info?: ({ name?: string } & ImageMeta) | null) => {
+  const meta = imageTokenMeta(info)
+  const label = info?.name ? `📎 Attached image: ${info.name}` : '📎 Attached image'
+
+  return `${label}${meta ? ` · ${meta}` : ''}`
+}
+
+export const userDisplay = (text: string) => {
+  if (text.length <= LONG_MSG) {
+    return text
+  }
+
+  const first = text.split('\n')[0]?.trim() ?? ''
+  const words = first.split(/\s+/).filter(Boolean)
+  const prefix = (words.length > 1 ? words.slice(0, 4).join(' ') : first).slice(0, 80)
+
+  return `${prefix || '(message)'} [long message]`
+}
+
+export const toTranscriptMessages = (rows: unknown): Msg[] => {
+  if (!Array.isArray(rows)) {
+    return []
+  }
+
+  const out: Msg[] = []
+  let pending: string[] = []
+
+  for (const row of rows) {
+    if (!row || typeof row !== 'object') {
+      continue
+    }
+
+    const { context, name, role, text } = row as TranscriptRow
+
+    if (role === 'tool') {
+      pending.push(buildToolTrailLine(name ?? 'tool', context ?? ''))
+
+      continue
+    }
+
+    if (typeof text !== 'string' || !text.trim()) {
+      continue
+    }
+
+    if (role === 'assistant') {
+      out.push({ role, text, ...(pending.length && { tools: pending }) })
+      pending = []
+    } else if (role === 'user' || role === 'system') {
+      out.push({ role, text })
+      pending = []
+    }
+  }
+
+  return out
+}
+
+export const fmtDuration = (ms: number) => {
+  const t = Math.max(0, Math.floor(ms / 1000))
+  const h = Math.floor(t / 3600)
+  const m = Math.floor((t % 3600) / 60)
+  const s = t % 60
+
+  return h > 0 ? `${h}h ${m}m` : m > 0 ? `${m}m ${s}s` : `${s}s`
+}
+
+interface ImageMeta {
+  height?: number
+  token_estimate?: number
+  width?: number
+}
+
+interface TranscriptRow {
+  context?: string
+  name?: string
+  role?: string
+  text?: string
+}

package/src/domain/paths.ts

@@ -0,0 +1,16 @@
+export const shortCwd = (cwd: string, max = 28) => {
+  const h = process.env.HOME
+  const p = h && cwd.startsWith(h) ? `~${cwd.slice(h.length)}` : cwd
+
+  return p.length <= max ? p : `…${p.slice(-(max - 1))}`
+}
+
+export const fmtCwdBranch = (cwd: string, branch: null | string, max = 40) => {
+  if (!branch) {
+    return shortCwd(cwd, max)
+  }
+
+  const tag = ` (${branch.length > 16 ? `…${branch.slice(-15)}` : branch})`
+
+  return `${shortCwd(cwd, Math.max(8, max - tag.length))}${tag}`
+}