nastech-tui 0.0.1

package/src/lib/text.ts

@@ -0,0 +1,339 @@
+import {
+  LIVE_RENDER_MAX_CHARS,
+  LIVE_RENDER_MAX_LINES,
+  THINKING_COT_MAX
+} from '../config/limits.js'
+import { VERBS } from '../content/verbs.js'
+import type { ThinkingMode } from '../types.js'
+
+const ESC = String.fromCharCode(27)
+const BEL = String.fromCharCode(7)
+const ANSI_CSI_RE = new RegExp(`${ESC}\\[[0-?]*[ -/]*[@-~]`, 'g')
+const ANSI_CSI_WITH_CMD_RE = new RegExp(`${ESC}\\[[0-?]*[ -/]*([@-~])`, 'g')
+const ANSI_INCOMPLETE_CSI_RE = new RegExp(`${ESC}\\[[0-?]*[ -/]*(?=${ESC}|\\n|$)`, 'g')
+const ANSI_OSC_RE = new RegExp(`${ESC}\\][\\s\\S]*?(?:${BEL}|${ESC}\\\\)`, 'g')
+const ANSI_STRING_RE = new RegExp(`${ESC}[PX^_][\\s\\S]*?(?:${BEL}|${ESC}\\\\)`, 'g')
+const ANSI_NON_CSI_ESC_SEQ_RE = new RegExp(`${ESC}(?!\\[|\\]|P|X|\\^|_)[ -/]*[0-~]`, 'g')
+const ANSI_STRAY_ESC_RE = new RegExp(`${ESC}(?!\\[)[\\s\\S]?`, 'g')
+const CONTROL_RE = /[\x00-\x08\x0B\x0C\x0D\x0E-\x1A\x1C-\x1F\x7F]/g
+const WS_RE = /\s+/g
+
+export const stripAnsi = (s: string) =>
+  s
+    .replace(ANSI_OSC_RE, '')
+    .replace(ANSI_STRING_RE, '')
+    .replace(ANSI_INCOMPLETE_CSI_RE, '')
+    .replace(ANSI_CSI_RE, '')
+    .replace(ANSI_INCOMPLETE_CSI_RE, '')
+    .replace(ANSI_NON_CSI_ESC_SEQ_RE, '')
+    .replace(ANSI_STRAY_ESC_RE, '')
+    .replace(CONTROL_RE, '')
+
+export const sanitizeAnsiForRender = (s: string) =>
+  s
+    .replace(ANSI_OSC_RE, '')
+    .replace(ANSI_STRING_RE, '')
+    .replace(ANSI_INCOMPLETE_CSI_RE, '')
+    .replace(ANSI_CSI_WITH_CMD_RE, (seq, cmd: string) => (cmd === 'm' ? seq : ''))
+    .replace(ANSI_INCOMPLETE_CSI_RE, '')
+    .replace(ANSI_NON_CSI_ESC_SEQ_RE, '')
+    .replace(ANSI_STRAY_ESC_RE, '')
+    .replace(CONTROL_RE, '')
+
+export const hasAnsi = (s: string) => s.includes(ESC)
+
+const renderEstimateLine = (line: string) => {
+  const trimmed = line.trim()
+
+  if (trimmed.startsWith('|')) {
+    return trimmed
+      .split('|')
+      .filter(Boolean)
+      .map(cell => cell.trim())
+      .join('  ')
+  }
+
+  return line
+    .replace(/!\[(.*?)\]\(([^)\s]+)\)/g, '[image: $1]')
+    .replace(/\[(.+?)\]\((https?:\/\/[^\s)]+)\)/g, '$1')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/\*\*(.+?)\*\*/g, '$1')
+    .replace(/(?<!\w)__(.+?)__(?!\w)/g, '$1')
+    .replace(/\*(.+?)\*/g, '$1')
+    .replace(/(?<!\w)_(.+?)_(?!\w)/g, '$1')
+    .replace(/~~(.+?)~~/g, '$1')
+    .replace(/==(.+?)==/g, '$1')
+    .replace(/\[\^([^\]]+)\]/g, '[$1]')
+    .replace(/^#{1,6}\s+/, '')
+    .replace(/^\s*[-*+]\s+\[( |x|X)\]\s+/, (_m, checked: string) => `• [${checked.toLowerCase() === 'x' ? 'x' : ' '}] `)
+    .replace(/^\s*[-*+]\s+/, '• ')
+    .replace(/^\s*(\d+)\.\s+/, '$1. ')
+    .replace(/^\s*(?:>\s*)+/, '│ ')
+}
+
+export const compactPreview = (s: string, max: number) => {
+  const one = s.replace(WS_RE, ' ').trim()
+
+  return !one ? '' : one.length > max ? one.slice(0, max - 1) + '…' : one
+}
+
+export const estimateTokensRough = (text: string) => (!text ? 0 : (text.length + 3) >> 2)
+
+export const edgePreview = (s: string, head = 16, tail = 28) => {
+  const one = s.replace(WS_RE, ' ').trim().replace(/\]\]/g, '] ]')
+
+  return !one
+    ? ''
+    : one.length <= head + tail + 4
+      ? one
+      : `${one.slice(0, head).trimEnd()}.. ${one.slice(-tail).trimStart()}`
+}
+
+export const pasteTokenLabel = (text: string, lineCount: number) => {
+  const preview = edgePreview(text)
+
+  if (!preview) {
+    return `[[ [${fmtK(lineCount)} lines] ]]`
+  }
+
+  const [head = preview, tail = ''] = preview.split('.. ', 2)
+
+  return tail
+    ? `[[ ${head.trimEnd()}.. [${fmtK(lineCount)} lines] .. ${tail.trimStart()} ]]`
+    : `[[ ${preview} [${fmtK(lineCount)} lines] ]]`
+}
+
+const THINKING_STATUS_RE = new RegExp(`^(?:${VERBS.join('|')})\\.{0,3}$`, 'i')
+const THINKING_STATUS_CHUNK_RE = new RegExp(`[^A-Za-z\n]+\\s*(?:${VERBS.join('|')})\\.{0,3}\\s*`, 'giu')
+
+export const cleanThinkingText = (reasoning: string) =>
+  reasoning
+    .split('\n')
+    .map(line => line.replace(THINKING_STATUS_CHUNK_RE, '').trim())
+    .filter(line => line && !THINKING_STATUS_RE.test(line.replace(/\.\.\.$/, '').trim()))
+    .join('\n')
+    .replace(/([^\n])(?=\*\*[^*\n][^\n]*?\*\*)/g, '$1\n\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+
+export const thinkingPreview = (reasoning: string, mode: ThinkingMode, max: number = THINKING_COT_MAX) => {
+  const raw = cleanThinkingText(reasoning)
+
+  return !raw || mode === 'collapsed' ? '' : mode === 'full' ? raw : compactPreview(raw.replace(WS_RE, ' '), max)
+}
+
+export const boundedLiveRenderText = (
+  text: string,
+  { maxChars = LIVE_RENDER_MAX_CHARS, maxLines = LIVE_RENDER_MAX_LINES } = {}
+) => boundedRenderText(text, 'showing live tail', { maxChars, maxLines })
+
+const boundedRenderText = (
+  text: string,
+  labelPrefix: string,
+  { maxChars, maxLines }: { maxChars: number; maxLines: number }
+) => {
+  if (text.length <= maxChars && text.split('\n', maxLines + 1).length <= maxLines) {
+    return text
+  }
+
+  let start = 0
+  let idx = text.length
+
+  for (let seen = 0; seen < maxLines && idx > 0; seen++) {
+    idx = text.lastIndexOf('\n', idx - 1)
+    start = idx < 0 ? 0 : idx + 1
+
+    if (idx < 0) {
+      break
+    }
+  }
+
+  const lineStart = start
+  start = Math.max(lineStart, text.length - maxChars)
+
+  if (start > lineStart) {
+    const nextBreak = text.indexOf('\n', start)
+
+    if (nextBreak >= 0 && nextBreak < text.length - 1) {
+      start = nextBreak + 1
+    }
+  }
+
+  const tail = text.slice(start).trimStart()
+  const omittedLines = countNewlines(text, start)
+  const omittedChars = Math.max(0, text.length - tail.length)
+
+  const label =
+    omittedLines > 0
+      ? `[${labelPrefix}; omitted ${fmtK(omittedLines)} lines / ${fmtK(omittedChars)} chars]\n`
+      : `[${labelPrefix}; omitted ${fmtK(omittedChars)} chars]\n`
+
+  return `${label}${tail}`
+}
+
+const countNewlines = (text: string, end: number) => {
+  let count = 0
+
+  for (let i = 0; i < end; i++) {
+    if (text.charCodeAt(i) === 10) {
+      count++
+    }
+  }
+
+  return count
+}
+
+export const stripTrailingPasteNewlines = (text: string) => (/[^\n]/.test(text) ? text.replace(/\n+$/, '') : text)
+
+export const toolTrailLabel = (name: string) =>
+  name
+    .split('_')
+    .filter(Boolean)
+    .map(p => p[0]!.toUpperCase() + p.slice(1))
+    .join(' ') || name
+
+export const formatToolCall = (name: string, context = '') => {
+  const label = toolTrailLabel(name)
+  const preview = compactPreview(context, 64)
+
+  return preview ? `${label}("${preview}")` : label
+}
+
+export const buildToolTrailLine = (
+  name: string,
+  context: string,
+  error?: boolean,
+  note?: string,
+  duration?: number
+) => {
+  const detail = compactPreview(note ?? '', 72)
+  const took = duration !== undefined ? ` (${duration.toFixed(1)}s)` : ''
+
+  return `${formatToolCall(name, context)}${took}${detail ? ` :: ${detail}` : ''} ${error ? '✗' : '✓'}`
+}
+
+const verboseToolBlock = (label: string, text?: string) => {
+  const body = (text ?? '').trim()
+
+  return body ? `${label}:\n${boundedLiveRenderText(body)}` : ''
+}
+
+export const buildVerboseToolTrailLine = (
+  name: string,
+  context: string,
+  error?: boolean,
+  duration?: number,
+  argsText?: string,
+  resultText?: string
+) => {
+  const detail = [verboseToolBlock('Args', argsText), verboseToolBlock(error ? 'Error' : 'Result', resultText)]
+    .filter(Boolean)
+    .join('\n')
+  const took = duration !== undefined ? ` (${duration.toFixed(1)}s)` : ''
+
+  return `${formatToolCall(name, context)}${took}${detail ? ` :: ${detail}` : ''} ${error ? '✗' : '✓'}`
+}
+
+export const isToolTrailResultLine = (line: string) => line.endsWith(' ✓') || line.endsWith(' ✗')
+
+export const parseToolTrailResultLine = (line: string) => {
+  if (!isToolTrailResultLine(line)) {
+    return null
+  }
+
+  const mark = line.endsWith(' ✗') ? '✗' : '✓'
+  const body = line.slice(0, -2)
+  const sep = body.indexOf(' :: ')
+
+  if (sep >= 0) {
+    return { call: body.slice(0, sep), detail: body.slice(sep + 4), mark }
+  }
+
+  const legacy = body.indexOf(': ')
+
+  if (legacy > 0) {
+    return { call: body.slice(0, legacy), detail: body.slice(legacy + 2), mark }
+  }
+
+  return { call: body, detail: '', mark }
+}
+
+export const splitToolDuration = (call: string) => {
+  const match = call.match(/^(.*?)( \(\d+(?:\.\d)?s\))$/)
+
+  return match ? { label: match[1]!, duration: match[2]! } : { label: call, duration: '' }
+}
+
+export const isTransientTrailLine = (line: string) => line.startsWith('drafting ') || line === 'analyzing tool output…'
+
+export const sameToolTrailGroup = (label: string, entry: string) =>
+  entry === `${label} ✓` ||
+  entry === `${label} ✗` ||
+  entry.startsWith(`${label}(`) ||
+  entry.startsWith(`${label} ::`) ||
+  entry.startsWith(`${label}:`)
+
+export const lastCotTrailIndex = (trail: readonly string[]) => {
+  for (let i = trail.length - 1; i >= 0; i--) {
+    if (!isToolTrailResultLine(trail[i]!)) {
+      return i
+    }
+  }
+
+  return -1
+}
+
+export const estimateRows = (text: string, w: number, compact = false) => {
+  let fence: { char: '`' | '~'; len: number } | null = null
+  let rows = 0
+
+  for (const raw of text.split('\n')) {
+    const line = stripAnsi(raw)
+    const maybeFence = line.match(/^\s*(`{3,}|~{3,})(.*)$/)
+
+    if (maybeFence) {
+      const marker = maybeFence[1]!
+      const lang = maybeFence[2]!.trim()
+
+      if (!fence) {
+        fence = { char: marker[0] as '`' | '~', len: marker.length }
+
+        if (lang) {
+          rows += Math.ceil((`─ ${lang}`.length || 1) / w)
+        }
+      } else if (marker[0] === fence.char && marker.length >= fence.len) {
+        fence = null
+      }
+
+      continue
+    }
+
+    const inCode = Boolean(fence)
+    const trimmed = line.trim()
+
+    if (!inCode && trimmed.startsWith('|') && /^[|\s:-]+$/.test(trimmed)) {
+      continue
+    }
+
+    const rendered = inCode ? line : renderEstimateLine(line)
+
+    if (compact && !rendered.trim()) {
+      continue
+    }
+
+    rows += Math.ceil((rendered.length || 1) / w)
+  }
+
+  return Math.max(1, rows)
+}
+
+export const flat = (r: Record<string, string[]>) => Object.values(r).flat()
+
+const COMPACT_NUMBER = new Intl.NumberFormat('en-US', { maximumFractionDigits: 1, notation: 'compact' })
+
+export const fmtK = (n: number) => COMPACT_NUMBER.format(n).replace(/[KMBT]$/, s => s.toLowerCase())
+
+export const pick = <T>(a: T[]) => a[Math.floor(Math.random() * a.length)]!
+
+export const isPasteBackedText = (text: string) =>
+  /\[\[paste:\d+(?:[^\n]*?)\]\]|\[paste #\d+ (?:attached|excerpt)(?:[^\n]*?)\]/.test(text)

package/src/lib/todo.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { todoGlyph, todoTone } from './todo.js'
+
+describe('todoGlyph', () => {
+  it('uses fixed-width ASCII markers so the active row does not render wide or emoji-like', () => {
+    expect(todoGlyph('completed')).toBe('[x]')
+    expect(todoGlyph('in_progress')).toBe('[>]')
+    expect(todoGlyph('pending')).toBe('[ ]')
+    expect(todoGlyph('cancelled')).toBe('[-]')
+  })
+})
+
+describe('todoTone', () => {
+  it('keeps todo status rows neutral instead of red/green', () => {
+    expect(todoTone('completed')).toBe('dim')
+    expect(todoTone('cancelled')).toBe('dim')
+    expect(todoTone('pending')).toBe('body')
+    expect(todoTone('in_progress')).toBe('active')
+  })
+})

package/src/lib/todo.ts

@@ -0,0 +1,9 @@
+import type { TodoItem } from '../types.js'
+
+export type TodoTone = 'active' | 'body' | 'dim'
+
+export const todoGlyph = (status: TodoItem['status']) =>
+  status === 'completed' ? '[x]' : status === 'cancelled' ? '[-]' : status === 'in_progress' ? '[>]' : '[ ]'
+
+export const todoTone = (status: TodoItem['status']): TodoTone =>
+  status === 'in_progress' ? 'active' : status === 'pending' ? 'body' : 'dim'

package/src/lib/viewportStore.ts

@@ -0,0 +1,124 @@
+import type { ScrollBoxHandle } from '@nastechai/ink'
+import type { RefObject } from 'react'
+import { useCallback, useMemo, useSyncExternalStore } from 'react'
+
+export interface ViewportSnapshot {
+  atBottom: boolean
+  bottom: number
+  pending: number
+  scrollHeight: number
+  top: number
+  viewportHeight: number
+}
+
+export interface ScrollbarSnapshot {
+  scrollHeight: number
+  top: number
+  viewportHeight: number
+}
+
+const EMPTY: ViewportSnapshot = {
+  atBottom: true,
+  bottom: 0,
+  pending: 0,
+  scrollHeight: 0,
+  top: 0,
+  viewportHeight: 0
+}
+
+const EMPTY_SCROLLBAR: ScrollbarSnapshot = {
+  scrollHeight: 0,
+  top: 0,
+  viewportHeight: 0
+}
+
+export function getViewportSnapshot(s?: ScrollBoxHandle | null): ViewportSnapshot {
+  if (!s) {
+    return EMPTY
+  }
+
+  const pending = s.getPendingDelta()
+  const top = Math.max(0, s.getScrollTop() + pending)
+  const viewportHeight = Math.max(0, s.getViewportHeight())
+  const cachedScrollHeight = Math.max(viewportHeight, s.getScrollHeight())
+  let scrollHeight = cachedScrollHeight
+  const bottom = top + viewportHeight
+  let atBottom = s.isSticky() || bottom >= scrollHeight - 2
+
+  if (!atBottom) {
+    scrollHeight = Math.max(viewportHeight, s.getFreshScrollHeight?.() ?? cachedScrollHeight)
+    atBottom = s.isSticky() || bottom >= scrollHeight - 2
+  }
+
+  return {
+    atBottom,
+    bottom,
+    pending,
+    scrollHeight,
+    top,
+    viewportHeight
+  }
+}
+
+export function viewportSnapshotKey(v: ViewportSnapshot) {
+  return `${v.atBottom ? 1 : 0}:${Math.ceil(v.top / 8) * 8}:${v.viewportHeight}:${Math.ceil(v.scrollHeight / 8) * 8}:${v.pending}`
+}
+
+export function getScrollbarSnapshot(s?: ScrollBoxHandle | null): ScrollbarSnapshot {
+  if (!s) {
+    return EMPTY_SCROLLBAR
+  }
+
+  const viewportHeight = Math.max(0, s.getViewportHeight())
+  const scrollHeight = Math.max(viewportHeight, s.getScrollHeight())
+  const maxTop = Math.max(0, scrollHeight - viewportHeight)
+
+  return {
+    scrollHeight,
+    top: Math.max(0, Math.min(maxTop, s.getScrollTop())),
+    viewportHeight
+  }
+}
+
+export function scrollbarSnapshotKey(v: ScrollbarSnapshot) {
+  return `${v.top}:${v.viewportHeight}:${v.scrollHeight}`
+}
+
+export function useViewportSnapshot(scrollRef: RefObject<ScrollBoxHandle | null>): ViewportSnapshot {
+  const key = useSyncExternalStore(
+    useCallback((cb: () => void) => scrollRef.current?.subscribe(cb) ?? (() => {}), [scrollRef]),
+    () => viewportSnapshotKey(getViewportSnapshot(scrollRef.current)),
+    () => viewportSnapshotKey(EMPTY)
+  )
+
+  return useMemo(() => {
+    const [atBottom = '1', top = '0', viewportHeight = '0', scrollHeight = '0', pending = '0'] = key.split(':')
+
+    return {
+      atBottom: atBottom === '1',
+      bottom: Number(top) + Number(viewportHeight),
+      pending: Number(pending),
+      scrollHeight: Number(scrollHeight),
+      top: Number(top),
+      viewportHeight: Number(viewportHeight)
+    }
+  }, [key])
+}
+
+export function useScrollbarSnapshot(scrollRef: RefObject<ScrollBoxHandle | null>): ScrollbarSnapshot {
+  const key = useSyncExternalStore(
+    useCallback((cb: () => void) => scrollRef.current?.subscribe(cb) ?? (() => {}), [scrollRef]),
+    () => scrollbarSnapshotKey(getScrollbarSnapshot(scrollRef.current)),
+    () => scrollbarSnapshotKey(EMPTY_SCROLLBAR)
+  )
+
+  return useMemo(() => {
+    const [top = '0', viewportHeight = '0', scrollHeight = '0'] = key.split(':')
+
+    return {
+      scrollHeight: Number(scrollHeight),
+      top: Number(top),
+      viewportHeight: Number(viewportHeight)
+    }
+  }, [key])
+}

package/src/lib/virtualHeights.ts

@@ -0,0 +1,145 @@
+import { TERMUX_TUI_MODE } from '../config/env.js'
+import type { Msg } from '../types.js'
+
+import { transcriptBodyWidth } from './inputMetrics.js'
+
+const hashText = (text: string) => {
+  let h = 5381
+
+  for (let i = 0; i < text.length; i++) {
+    h = ((h << 5) + h) ^ text.charCodeAt(i)
+  }
+
+  return (h >>> 0).toString(36)
+}
+
+export const messageHeightKey = (msg: Msg) => {
+  const todoSig = msg.todos?.map(t => `${t.status}:${t.content}`).join('\u0001') ?? ''
+
+  const panelSig =
+    msg.panelData?.sections
+      .map(s => `${s.title ?? ''}:${s.text?.length ?? 0}:${s.items?.length ?? 0}:${s.rows?.length ?? 0}`)
+      .join('\u0001') ?? ''
+
+  const introSig = msg.kind === 'intro' ? (msg.info?.version ?? '') : ''
+
+  return [
+    msg.role,
+    msg.kind ?? '',
+    hashText([msg.text, msg.thinking ?? '', msg.tools?.join('\n') ?? '', todoSig, panelSig, introSig].join('\0'))
+  ].join(':')
+}
+
+// Hard cap on rows the estimator will count. Each row above this is
+// invisible to the estimator (gets clipped to MAX_ESTIMATE_LINES), but
+// post-mount Yoga measurement converges to the real height on first
+// render. Without this, a long assistant turn (10k+ chars) costs O(text)
+// per offset rebuild × every uncached item — cold-mounting a 1000-row
+// transcript becomes a multi-million-char wrap walk that blocks the UI.
+//
+// 800 covers any realistic assistant message (the prior history-clip
+// ceiling was 16 lines, then full text — this is the sane middle).
+const MAX_ESTIMATE_LINES = 800
+
+export const wrappedLines = (text: string, width: number, maxLines: number = MAX_ESTIMATE_LINES) => {
+  const w = Math.max(1, width)
+  // Worst case: every cell is its own row at width=1, plus a small
+  // slack for the trailing partial line. Walking past this byte budget
+  // cannot increase n any further once n is already past maxLines, so
+  // bail. Saves O(text) walks on multi-megabyte single-line messages.
+  const budget = Math.min(text.length, maxLines * w + maxLines)
+  let n = 0
+  let start = 0
+
+  for (let i = 0; i <= budget; i++) {
+    if (i === text.length || i === budget || text.charCodeAt(i) === 10) {
+      const rows = Math.max(1, Math.ceil((i - start) / w))
+      n += rows >= maxLines - n ? maxLines - n : rows
+      start = i + 1
+
+      if (n >= maxLines) {
+        return maxLines
+      }
+    }
+  }
+
+  return n
+}
+
+export const estimatedMsgHeight = (
+  msg: Msg,
+  cols: number,
+  {
+    compact,
+    details,
+    thinkingVisible = details,
+    toolsVisible = details,
+    userPrompt = '',
+    withSeparator = false
+  }: {
+    compact: boolean
+    details: boolean
+    thinkingVisible?: boolean
+    toolsVisible?: boolean
+    userPrompt?: string
+    withSeparator?: boolean
+  }
+) => {
+  if (msg.kind === 'intro') {
+    return msg.info?.version ? 9 : 5
+  }
+
+  if (msg.kind === 'panel') {
+    return Math.max(3, (msg.panelData?.sections.length ?? 1) * 2 + 1)
+  }
+
+  if (msg.kind === 'trail' && msg.todos?.length) {
+    if (msg.todoCollapsedByDefault) {
+      return 2
+    }
+
+    return Math.max(2, msg.todos.length + 2)
+  }
+
+  const bodyWidth = transcriptBodyWidth(cols, msg.role, userPrompt, TERMUX_TUI_MODE)
+  const text = msg.text
+  let h = wrappedLines(text || ' ', bodyWidth)
+
+  if (!compact && msg.role === 'assistant') {
+    // Paragraph gaps add up to 6 extra rows of breathing room. Slice
+    // first so the regex never walks more than the first ~16k chars of
+    // a giant assistant message — post-mount Yoga measurement converges
+    // to the real height regardless of how the estimate undercounts.
+    const scan = text.length > 16_000 ? text.slice(0, 16_000) : text
+    h += Math.min(6, (scan.match(/\n\s*\n/g) ?? []).length)
+  }
+
+  if (details) {
+    const hasVisibleTools = toolsVisible && Boolean(msg.tools?.length)
+    const hasVisibleThinking = thinkingVisible && /\S/.test(msg.thinking ?? '')
+    const hasVisibleDetails = hasVisibleTools || hasVisibleThinking
+
+    if (hasVisibleDetails) {
+      h += (hasVisibleTools ? (msg.tools?.length ?? 0) : 0) + (hasVisibleThinking ? wrappedLines(msg.thinking ?? '', bodyWidth) : 0)
+
+      if (msg.role === 'assistant' && /\S/.test(msg.text)) {
+        h += 2
+      }
+    }
+  }
+
+  if (msg.role === 'user' || msg.kind === 'diff') {
+    h += 2
+  } else if (msg.kind === 'slash') {
+    h++
+  }
+
+  // Inter-turn separator above non-first user messages (1 rule row + 1
+  // top-margin row). The render-side gate is in appLayout.tsx; we trust
+  // the caller to pass `withSeparator` only when it matches that gate.
+  if (withSeparator) {
+    h += 2
+  }
+
+  return Math.max(1, h)
+}