@davstack/tui 0.2.0 → 0.3.0

package/src/hooks/useAgentTimeline.ts

@@ -0,0 +1,176 @@
+import fs from "node:fs"
+import { useEffect, useMemo, useRef, useState } from "react"
+
+import { readJob, type JobRecord } from "@davstack/open-agents/core/jobs"
+import { walkToolUses } from "@davstack/open-agents/core/parse"
+import type { ParsedEvent, RunSummary } from "@davstack/open-agents/adapters/types"
+import type { MutableRefObject } from "react"
+
+import { adapterForJob } from "./useAdapterFor.ts"
+import { useRingBuffer, type LogLine } from "./useRingBuffer.ts"
+import {
+  formatEventLines,
+  formatResultSummaryLine,
+  formatStartLine,
+} from "../lib/format-agent-timeline.ts"
+
+const TERMINAL = new Set(["done", "failed", "cancelled"])
+
+export interface UseAgentTimelineResult {
+  job: JobRecord | null
+  lines: LogLine[]
+  summary: RunSummary | null
+  done: boolean
+  clear: () => void
+}
+
+export function useAgentTimeline(
+  repoPath: string,
+  id: string,
+  noColor: boolean,
+): UseAgentTimelineResult {
+  const { lines, push, clear } = useRingBuffer()
+  const eventsRef = useRef<ParsedEvent[]>([])
+  const offsetRef = useRef(0)
+  const startLineRef = useRef(false)
+  const summaryRef = useRef<RunSummary | null>(null)
+  const [job, setJob] = useState<JobRecord | null>(null)
+  const [done, setDone] = useState(false)
+  const [summaryTick, setSummaryTick] = useState(0)
+
+  const adapter = useMemo(() => (job ? adapterForJob(job) : cursorAdapterFallback()), [job])
+
+  useEffect(() => {
+    eventsRef.current = []
+    offsetRef.current = 0
+    startLineRef.current = false
+    summaryRef.current = null
+    setDone(false)
+    setSummaryTick(0)
+    clear()
+  }, [repoPath, id, clear])
+
+  useEffect(() => {
+    let cancelled = false
+
+    const poll = () => {
+      if (cancelled) return
+      const fresh = readJob(repoPath, id)
+      if (!fresh) return
+      setJob(fresh)
+
+      if (!startLineRef.current) {
+        startLineRef.current = true
+        const start = formatStartLine({ prompt: fresh.prompt, noColor })
+        push({ ts: Date.now(), stream: "out", text: start.text })
+      }
+
+      if (fs.existsSync(fresh.rawLogPath)) {
+        const txt = fs.readFileSync(fresh.rawLogPath, "utf8")
+        if (txt.length > offsetRef.current) {
+          const slice = txt.slice(offsetRef.current)
+          offsetRef.current = txt.length
+          ingestLines({ adapter, chunk: slice, eventsRef, push, noColor })
+        }
+      }
+
+      if (TERMINAL.has(fresh.status)) {
+        setDone(true)
+        if (!summaryRef.current) {
+          summaryRef.current = adapter.summarise(eventsRef.current)
+          const toolCalls = countToolCalls(eventsRef.current)
+          const usage = pickUsage(eventsRef.current)
+          const cost = pickCostFromEvents(eventsRef.current)
+          const summaryLine = formatResultSummaryLine({
+            toolCallCount: toolCalls,
+            filesChanged: summaryRef.current.filesChanged,
+            usage,
+            cost,
+            noColor,
+          })
+          push({ ts: Date.now(), stream: "out", text: summaryLine.text })
+          setSummaryTick((t) => t + 1)
+        }
+      }
+    }
+
+    poll()
+    const idTimer = setInterval(poll, 700)
+    return () => {
+      cancelled = true
+      clearInterval(idTimer)
+    }
+  }, [repoPath, id, adapter, push, noColor])
+
+  const summary = useMemo(() => summaryRef.current, [summaryTick, done])
+
+  return { job, lines, summary, done, clear }
+}
+
+function ingestLines(opts: {
+  adapter: ReturnType<typeof adapterForJob>
+  chunk: string
+  eventsRef: MutableRefObject<ParsedEvent[]>
+  push: (line: LogLine) => void
+  noColor: boolean
+}): void {
+  for (const line of opts.chunk.split("\n")) {
+    if (!line.trim()) continue
+    const ev = opts.adapter.parseLine(line)
+    if (!ev) continue
+    opts.eventsRef.current.push(ev)
+    for (const row of formatEventLines({ ev, noColor: opts.noColor })) {
+      opts.push({ ts: Date.now(), stream: "out", text: row.text })
+    }
+  }
+}
+
+function countToolCalls(events: ParsedEvent[]): number {
+  let n = 0
+  for (const ev of events) {
+    for (const _ of walkToolUses(ev)) n += 1
+    const type = ev.type
+    if (type === "tool_use" || type === "tool_call") n += 1
+  }
+  return n
+}
+
+function pickUsage(events: ParsedEvent[]): { input?: number; output?: number } | undefined {
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    const ev = events[i]
+    if (ev?.type !== "result") continue
+    const usage = ev.usage as Record<string, unknown> | undefined
+    if (!usage) continue
+    const input =
+      typeof usage.input_tokens === "number"
+        ? usage.input_tokens
+        : typeof usage.input === "number"
+          ? usage.input
+          : undefined
+    const output =
+      typeof usage.output_tokens === "number"
+        ? usage.output_tokens
+        : typeof usage.output === "number"
+          ? usage.output
+          : undefined
+    if (input != null || output != null) return { input, output }
+  }
+  return undefined
+}
+
+function pickCostFromEvents(events: ParsedEvent[]): string | undefined {
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    const ev = events[i]
+    if (ev?.type !== "result") continue
+    if (typeof ev.cost === "number") return `$${ev.cost.toFixed(2)}`
+    if (typeof ev.cost === "string") return ev.cost
+    const pricing = ev.pricing as Record<string, unknown> | undefined
+    if (pricing && typeof pricing.total === "number") return `$${pricing.total.toFixed(2)}`
+    if (pricing && typeof pricing.total_cost === "number") return `$${pricing.total_cost.toFixed(2)}`
+  }
+  return undefined
+}
+
+function cursorAdapterFallback(): ReturnType<typeof adapterForJob> {
+  return adapterForJob({ model: "composer-2.5" })
+}

package/src/hooks/useHotkeys.test.tsx

@@ -10,6 +10,7 @@ import { render } from "ink-testing-library"
 
 import { ViewProvider, useView, type View } from "../state/view-context.tsx"
 import { DaemonsProvider, useDaemons, type DaemonRow } from "../state/daemons-context.tsx"
+import { AgentsProvider } from "../state/agents-context.tsx"
 import { QuitProvider, useQuit } from "../state/quit-context.tsx"
 import { useHotkeys, type HotkeyHandlers } from "./useHotkeys.ts"
 import type { DaemonDescriptor } from "../lib/daemon-registry.ts"
@@ -66,11 +67,13 @@ function renderWithProviders(descriptors: DaemonDescriptor[], onQuit: () => void
   let captured: CapturedApis | null = null
   const r = render(
     <ViewProvider>
-      <DaemonsProvider descriptors={descriptors}>
-        <QuitProvider>
-          <Capture onQuit={onQuit} onUpdate={(api) => (captured = api)} />
-        </QuitProvider>
-      </DaemonsProvider>
+      <AgentsProvider>
+        <DaemonsProvider descriptors={descriptors}>
+          <QuitProvider>
+            <Capture onQuit={onQuit} onUpdate={(api) => (captured = api)} />
+          </QuitProvider>
+        </DaemonsProvider>
+      </AgentsProvider>
     </ViewProvider>,
   )
   if (!captured) throw new Error("Capture never published")

package/src/hooks/useHotkeys.ts

@@ -7,8 +7,8 @@ import { useCallback } from "react"
 
 import { useView } from "../state/view-context.tsx"
 import { useDaemons } from "../state/daemons-context.tsx"
+import { useAgents } from "../state/agents-context.tsx"
 import { useQuit } from "../state/quit-context.tsx"
-
 export interface KeyEvent {
   ctrl?: boolean
   escape?: boolean
@@ -39,8 +39,18 @@ export interface HotkeyHandlers {
 // it directly when no daemons are live; otherwise we route through the
 // confirm overlay (requestConfirm).
 export function useHotkeys(quit: () => void): HotkeyHandlers {
-  const { showLog, showList, setFocusedIdx, view, focusedIdx } = useView()
+  const {
+    showLog,
+    showList,
+    showAgents,
+    setFocusedIdx,
+    view,
+    focusedIdx,
+    highlightedAgentId,
+    setHighlightedAgentId,
+  } = useView()
   const { rowsRef, toggleByKey, clearByKey, takeoverByKey, anyLive } = useDaemons()
+  const { jobs, agentPane, clearAgentTimeline } = useAgents()
   const { confirming, requestConfirm, cancelConfirm } = useQuit()
 
   const onQuit = useCallback(() => {
@@ -62,8 +72,15 @@ export function useHotkeys(quit: () => void): HotkeyHandlers {
   )
 
   const onEscape = useCallback(() => {
-    if (view.kind === "log") showList()
-  }, [view, showList])
+    if (view.kind === "agent") {
+      showAgents()
+      return
+    }
+    if (view.kind === "log" || view.kind === "agents") {
+      if (view.kind === "agents") setHighlightedAgentId(undefined)
+      showList()
+    }
+  }, [view, showList, showAgents, setHighlightedAgentId])
 
   const onToggleFocused = useCallback(() => {
     const target = rowsRef.current[focusedIdx]
@@ -119,8 +136,29 @@ export function useHotkeys(quit: () => void): HotkeyHandlers {
         onQuit()
         return
       }
-      if (input === "c" && view.kind === "log") {
-        onClearLog()
+      if (input === "c") {
+        if (view.kind === "log") {
+          onClearLog()
+          return
+        }
+        if (view.kind === "agent" && agentPane === "logs") {
+          clearAgentTimeline()
+          return
+        }
+      }
+      if (input === "g") {
+        if (view.kind !== "agents") {
+          showAgents()
+          if (highlightedAgentId) {
+            const idx = jobs.findIndex((j) => j.id === highlightedAgentId)
+            if (idx >= 0) setFocusedIdx(idx)
+          }
+          return
+        }
+        const safeFocus = jobs.length === 0 ? 0 : Math.min(focusedIdx, jobs.length - 1)
+        const job = jobs[safeFocus]
+        if (job?.status === "running") setHighlightedAgentId(job.id)
+        showList()
         return
       }
       if (input === "k" && view.kind === "list") {
@@ -128,19 +166,20 @@ export function useHotkeys(quit: () => void): HotkeyHandlers {
         return
       }
       if (/^[1-9]$/.test(input)) {
+        if (view.kind === "agents") return
         onNumberKey(Number(input) - 1)
         return
       }
       if (key.leftArrow) {
-        onCycleFocus(-1)
+        if (view.kind !== "agents") onCycleFocus(-1)
         return
       }
       if (key.rightArrow) {
-        onCycleFocus(1)
+        if (view.kind !== "agents") onCycleFocus(1)
         return
       }
       if (key.tab) {
-        onCycleFocus(key.shift ? -1 : 1)
+        if (view.kind !== "agents") onCycleFocus(key.shift ? -1 : 1)
         return
       }
       if (key.escape) {
@@ -148,7 +187,27 @@ export function useHotkeys(quit: () => void): HotkeyHandlers {
         return
       }
     },
-    [confirming, cancelConfirm, quit, onQuit, onNumberKey, onEscape, onClearLog, onTakeoverFocused, onCycleFocus, view],
+    [
+      confirming,
+      cancelConfirm,
+      quit,
+      onQuit,
+      onNumberKey,
+      onEscape,
+      onClearLog,
+      onTakeoverFocused,
+      onCycleFocus,
+      showAgents,
+      showList,
+      view,
+      jobs,
+      focusedIdx,
+      highlightedAgentId,
+      setHighlightedAgentId,
+      setFocusedIdx,
+      agentPane,
+      clearAgentTimeline,
+    ],
   )
 
   return {

package/src/lib/agent-glyphs.ts

@@ -0,0 +1,52 @@
+export type AgentEventKind =
+  | "start"
+  | "system"
+  | "tool_use"
+  | "tool_result"
+  | "assistant"
+  | "result"
+  | "other"
+
+export const EVENT_GLYPH: Record<AgentEventKind, string> = {
+  start: "▶",
+  system: "◇",
+  tool_use: "◆",
+  tool_result: "▸",
+  assistant: "✎",
+  result: "■",
+  other: "·",
+}
+
+export const EVENT_GLYPH_ASCII: Record<AgentEventKind, string> = {
+  start: ">",
+  system: "*",
+  tool_use: "+",
+  tool_result: "-",
+  assistant: "~",
+  result: "#",
+  other: ".",
+}
+
+export function eventGlyph(kind: AgentEventKind, noColor: boolean): string {
+  return noColor ? EVENT_GLYPH_ASCII[kind] : EVENT_GLYPH[kind]
+}
+
+export type AgentJobStatus = "running" | "done" | "failed" | "cancelled"
+
+export const JOB_STATUS_GLYPH: Record<AgentJobStatus, string> = {
+  running: "●",
+  done: "✓",
+  failed: "✗",
+  cancelled: "○",
+}
+
+export const JOB_STATUS_GLYPH_ASCII: Record<AgentJobStatus, string> = {
+  running: "*",
+  done: "+",
+  failed: "x",
+  cancelled: "o",
+}
+
+export function jobStatusGlyph(status: AgentJobStatus, noColor: boolean): string {
+  return noColor ? JOB_STATUS_GLYPH_ASCII[status] : JOB_STATUS_GLYPH[status]
+}

package/src/lib/agent-pill.ts

@@ -0,0 +1,25 @@
+import type { JobRecord } from "@davstack/open-agents/core/jobs"
+
+export function inferAdapter(model: string): string {
+  const m = model.toLowerCase()
+  if (m.startsWith("gemini-")) return "gemini"
+  if (m.startsWith("composer-") || m.startsWith("cursor-")) return "cursor"
+  return "cursor"
+}
+
+export function jobIdSuffix(id: string): string {
+  const parts = id.split("-")
+  return parts[parts.length - 1] ?? id
+}
+
+export function formatAgentPillLabel(job: JobRecord): string {
+  const tag = job.edit ? "edit" : "explore"
+  return `${tag}:${jobIdSuffix(job.id)}`
+}
+
+export function getRunningPillJobs(jobs: JobRecord[], limit = 5): JobRecord[] {
+  return jobs
+    .filter((j) => j.status === "running")
+    .sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime())
+    .slice(0, limit)
+}

package/src/lib/agent-title.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "vitest"
+
+import { inferAgentTitle } from "./agent-title.ts"
+
+describe("inferAgentTitle", () => {
+  test("uses first markdown heading", () => {
+    const prompt = "# Phase A1 — Widen exports\n\nbody text..."
+    expect(inferAgentTitle({ prompt })).toBe("Phase A1 — Widen exports")
+  })
+
+  test("strips trailing hashes from heading", () => {
+    expect(inferAgentTitle({ prompt: "## Quick fix ##" })).toBe("Quick fix")
+  })
+
+  test("ignores leading blank lines", () => {
+    expect(inferAgentTitle({ prompt: "\n\n\n# Real title\nbody" })).toBe("Real title")
+  })
+
+  test("falls back to first 10 words when no heading", () => {
+    const prompt = "Refactor the auth flow to use JWT instead of cookies for sessions everywhere"
+    expect(inferAgentTitle({ prompt })).toBe("Refactor the auth flow to use JWT instead of cookies")
+  })
+
+  test("strips XML tags when falling back", () => {
+    const prompt = "<intent>Rename fooBar to computeFoo</intent>"
+    expect(inferAgentTitle({ prompt })).toBe("Rename fooBar to computeFoo")
+  })
+
+  test("first non-blank line that isn't a heading falls back to words", () => {
+    const prompt = "Not a heading\n# But this is\nmore"
+    expect(inferAgentTitle({ prompt })).toBe("Not a heading But this is more")
+  })
+
+  test("respects maxWords override", () => {
+    const prompt = "one two three four five six seven"
+    expect(inferAgentTitle({ prompt }, 3)).toBe("one two three")
+  })
+
+  test("empty prompt returns empty string", () => {
+    expect(inferAgentTitle({ prompt: "" })).toBe("")
+  })
+})

package/src/lib/agent-title.ts

@@ -0,0 +1,29 @@
+// Title inference for a job. Convention: spec body's first markdown
+// heading (`# …`) wins. Fallback to first 5 words of the prompt with
+// tag noise (`<goal>`, `<intent>`, etc.) stripped, so tag-based specs
+// still get a sensible label.
+
+const HEADING_RE = /^#+\s+(.+?)\s*#*\s*$/
+const TAG_OPEN_RE = /<[a-zA-Z][\w-]*>/g
+const TAG_CLOSE_RE = /<\/[a-zA-Z][\w-]*>/g
+
+export interface TitleInput {
+  prompt: string
+}
+
+export function inferAgentTitle(input: TitleInput, maxWords = 10): string {
+  const body = input.prompt ?? ""
+  for (const raw of body.split(/\r?\n/)) {
+    const line = raw.trim()
+    if (line.length === 0) continue
+    const m = HEADING_RE.exec(line)
+    if (m && m[1]) return m[1].trim()
+    break
+  }
+  const stripped = body
+    .replace(TAG_OPEN_RE, " ")
+    .replace(TAG_CLOSE_RE, " ")
+    .replace(/^\s*#+\s*/gm, " ")
+  const words = stripped.replace(/\s+/g, " ").trim().split(" ").filter(Boolean)
+  return words.slice(0, maxWords).join(" ")
+}

package/src/lib/format-agent-timeline.test.ts

@@ -0,0 +1,142 @@
+// parseLine (cursor + gemini adapters) → formatEventLines → timeline glyphs.
+
+import { describe, expect, test } from "vitest"
+
+import { cursorAdapter } from "@davstack/open-agents/adapters/cursor"
+import { geminiAdapter } from "@davstack/open-agents/adapters/gemini"
+
+import { EVENT_GLYPH, EVENT_GLYPH_ASCII } from "./agent-glyphs.ts"
+import { formatEventLines, formatStartLine } from "./format-agent-timeline.ts"
+
+const CURSOR_SYSTEM = '{"type":"system","session_id":"abc-123"}'
+const GEMINI_INIT = '{"type":"init","session_id":"s1"}'
+const CURSOR_TOOL =
+  '{"type":"tool_use","name":"read_file","input":{"path":"src/foo.ts"}}'
+const GEMINI_TOOL =
+  '{"type":"tool_use","name":"grep","input":{"pattern":"aggregationMode","glob":"**/*.tsx"}}'
+const CURSOR_ASSISTANT = '{"type":"assistant","message":{"text":"working on it"}}'
+const GEMINI_ASSISTANT =
+  '{"type":"message","role":"assistant","content":"hello from gemini"}'
+const CURSOR_TOOL_RESULT =
+  '{"type":"tool_result","content":"export function QueryBuilder() {}"}'
+
+describe("formatEventLines — cursor stream-json", () => {
+  test("system line uses ◇ glyph", () => {
+    const ev = cursorAdapter.parseLine(CURSOR_SYSTEM)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.system)).toBe(true)
+    expect(rows[0]!.text).toContain("model loaded")
+  })
+
+  test("tool_use uses ◆ glyph with path hint", () => {
+    const ev = cursorAdapter.parseLine(CURSOR_TOOL)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.tool_use)).toBe(true)
+    expect(rows[0]!.text).toContain("read_file")
+    expect(rows[0]!.text).toContain("src/foo.ts")
+  })
+
+  test("assistant text uses ✎ glyph", () => {
+    const ev = cursorAdapter.parseLine(CURSOR_ASSISTANT)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.assistant)).toBe(true)
+    expect(rows[0]!.text).toContain("working on it")
+  })
+
+  test("tool_result uses ▸ glyph", () => {
+    const ev = cursorAdapter.parseLine(CURSOR_TOOL_RESULT)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.tool_result)).toBe(true)
+  })
+})
+
+describe("formatEventLines — gemini stream-json", () => {
+  test("init line uses same ◇ glyph as cursor system", () => {
+    const ev = geminiAdapter.parseLine(GEMINI_INIT)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.system)).toBe(true)
+  })
+
+  test("tool_use uses ◆ glyph with arg summary", () => {
+    const ev = geminiAdapter.parseLine(GEMINI_TOOL)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.tool_use)).toBe(true)
+    expect(rows[0]!.text).toContain("grep")
+    expect(rows[0]!.text).toContain("aggregationMode")
+  })
+
+  test("assistant message uses ✎ glyph", () => {
+    const ev = geminiAdapter.parseLine(GEMINI_ASSISTANT)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.assistant)).toBe(true)
+    expect(rows[0]!.text).toContain("hello from gemini")
+  })
+})
+
+describe("formatEventLines — noColor", () => {
+  test("cursor tool_use falls back to ASCII + glyph", () => {
+    const ev = cursorAdapter.parseLine(CURSOR_TOOL)!
+    const rows = formatEventLines({ ev, noColor: true })
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH_ASCII.tool_use)).toBe(true)
+  })
+})
+
+test("formatStartLine uses ▶ glyph", () => {
+  const row = formatStartLine({ prompt: "audit auth flows", noColor: false })
+  expect(row.text.startsWith(EVENT_GLYPH.start)).toBe(true)
+  expect(row.text).toContain("audit auth flows")
+})
+
+describe("formatEventLines — real cursor-agent shapes", () => {
+  const CURSOR_REAL_TOOL_STARTED = JSON.stringify({
+    type: "tool_call",
+    subtype: "started",
+    call_id: "tool_abc",
+    tool_call: { readToolCall: { args: { path: "C:/foo/bar.ts", offset: 1, limit: 100 } } },
+  })
+  const CURSOR_REAL_TOOL_COMPLETED = JSON.stringify({
+    type: "tool_call",
+    subtype: "completed",
+    call_id: "tool_abc",
+    tool_call: {
+      readToolCall: {
+        args: { path: "C:/foo/bar.ts" },
+        result: { success: { content: "export function x() { return 1 }" } },
+      },
+    },
+  })
+  const CURSOR_REAL_ASSISTANT = JSON.stringify({
+    type: "assistant",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: "I'll start by reading the file." }],
+    },
+  })
+
+  test("nested tool_call.readToolCall.args renders as tool_use with name + path", () => {
+    const ev = cursorAdapter.parseLine(CURSOR_REAL_TOOL_STARTED)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.tool_use)).toBe(true)
+    expect(rows[0]!.text).toContain("read")
+    expect(rows[0]!.text).toContain("C:/foo/bar.ts")
+  })
+
+  test("tool_call subtype completed renders as tool_result with preview", () => {
+    const ev = cursorAdapter.parseLine(CURSOR_REAL_TOOL_COMPLETED)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.tool_result)).toBe(true)
+    expect(rows[0]!.text).toContain("read")
+    expect(rows[0]!.text).toContain("export function x()")
+  })
+
+  test("assistant message.content[] text block renders as ✎ line", () => {
+    const ev = cursorAdapter.parseLine(CURSOR_REAL_ASSISTANT)!
+    const rows = formatEventLines({ ev, noColor: false })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]!.text.startsWith(EVENT_GLYPH.assistant)).toBe(true)
+    expect(rows[0]!.text).toContain("I'll start by reading the file.")
+  })
+})