openAgent

1import { afterEach, expect, test } from "bun:test"
2import type { ToolPart } from "@opencode-ai/sdk/v2"
3import { RGBA, SyntaxStyle } from "@opentui/core"
4import { MockTreeSitterClient, createTestRenderer, type TestRenderer } from "@opentui/core/testing"
5import { RunScrollbackStream } from "@/cli/cmd/run/scrollback.surface"
6import { RUN_THEME_FALLBACK, type RunTheme } from "@/cli/cmd/run/theme"
7import type { StreamCommit } from "@/cli/cmd/run/types"
8 
9type ClaimedCommit = {
10  snapshot: {
11    height: number
12    getRealCharBytes(addLineBreaks?: boolean): Uint8Array
13    destroy(): void
14  }
15  trailingNewline: boolean
16}
17 
18const decoder = new TextDecoder()
19const active: TestRenderer[] = []
20 
21afterEach(() => {
22  for (const renderer of active.splice(0)) {
23    renderer.destroy()
24  }
25})
26 
27function claim(renderer: TestRenderer): ClaimedCommit[] {
28  const queue = Reflect.get(renderer, "externalOutputQueue")
29  if (!queue || typeof queue !== "object" || !("claim" in queue) || typeof queue.claim !== "function") {
30    throw new Error("renderer missing external output queue")
31  }
32 
33  const commits = queue.claim()
34  if (!Array.isArray(commits)) {
35    throw new Error("renderer external output queue returned invalid commits")
36  }
37 
38  return commits as ClaimedCommit[]
39}
40 
41function renderCommit(commit: ClaimedCommit) {
42  return decoder.decode(commit.snapshot.getRealCharBytes(true)).replace(/ +\n/g, "\n")
43}
44 
45function render(commits: ClaimedCommit[]) {
46  return commits.map(renderCommit).join("")
47}
48 
49function renderRows(commit: ClaimedCommit, width = 80) {
50  const raw = decoder.decode(commit.snapshot.getRealCharBytes(true))
51  return Array.from({ length: commit.snapshot.height }, (_, index) =>
52    raw.slice(index * width, (index + 1) * width).trimEnd(),
53  )
54}
55 
56function destroy(commits: ClaimedCommit[]) {
57  for (const commit of commits) {
58    commit.snapshot.destroy()
59  }
60}
61 
62async function setup(
63  input: {
64    width?: number
65    wrote?: boolean
66    theme?: RunTheme
67    onThemeRelease?: (theme: RunTheme) => void
68  } = {},
69) {
70  const out = await createTestRenderer({
71    width: input.width ?? 80,
72    screenMode: "split-footer",
73    footerHeight: 6,
74    externalOutputMode: "capture-stdout",
75    consoleMode: "disabled",
76  })
77  active.push(out.renderer)
78 
79  const treeSitterClient = new MockTreeSitterClient({ autoResolveTimeout: 0 })
80  treeSitterClient.setMockResult({ highlights: [] })
81 
82  return {
83    renderer: out.renderer,
84    scrollback: new RunScrollbackStream(out.renderer, input.theme ?? RUN_THEME_FALLBACK, {
85      treeSitterClient,
86      wrote: input.wrote ?? false,
87      onThemeRelease: input.onThemeRelease,
88    }),
89  }
90}
91 
92function assistant(text: string, phase: StreamCommit["phase"] = "progress"): StreamCommit {
93  return {
94    kind: "assistant",
95    text,
96    phase,
97    source: "assistant",
98    messageID: "msg-1",
99    partID: "part-1",
100  }
101}
102 
103function reasoning(text: string, phase: StreamCommit["phase"] = "progress"): StreamCommit {
104  return {
105    kind: "reasoning",
106    text,
107    phase,
108    source: "reasoning",
109    messageID: "msg-r-1",
110    partID: "part-r-1",
111  }
112}
113 
114test("turn summary starts at the left edge", async () => {
115  const out = await setup()
116 
117  try {
118    await out.scrollback.writeTurnSummary({ agent: "Build", model: "Little Frank", duration: "2.2s" })
119 
120    const commits = claim(out.renderer)
121    try {
122      expect(renderRows(commits.at(-1)!)[0]).toBe("▣ Build · Little Frank · 2.2s")
123    } finally {
124      destroy(commits)
125    }
126  } finally {
127    out.scrollback.destroy()
128  }
129})
130 
131test("theme swaps restyle active reasoning without resetting the stream", async () => {
132  const previousSyntax = SyntaxStyle.fromStyles({ default: { fg: "#123456" } })
133  const nextSyntax = SyntaxStyle.fromStyles({ default: { fg: "#abcdef" } })
134  const released: RunTheme[] = []
135  const previous = {
136    ...RUN_THEME_FALLBACK,
137    block: {
138      ...RUN_THEME_FALLBACK.block,
139      subtleSyntax: previousSyntax,
140    },
141  }
142  const next = {
143    ...RUN_THEME_FALLBACK,
144    block: {
145      ...RUN_THEME_FALLBACK.block,
146      subtleSyntax: nextSyntax,
147    },
148  }
149  const out = await setup({ theme: previous, onThemeRelease: (theme) => released.push(theme) })
150 
151  try {
152    await out.scrollback.append(reasoning("before"))
153    expect(activeSyntax(out.scrollback)).toBe(previousSyntax)
154 
155    out.scrollback.setTheme(next)
156    expect(activeSyntax(out.scrollback)).toBe(nextSyntax)
157    expect(released).toEqual([])
158 
159    await out.scrollback.append(reasoning("after"))
160    expect(activeSyntax(out.scrollback)).toBe(nextSyntax)
161    expect(released).toEqual([previous])
162  } finally {
163    out.scrollback.destroy()
164    destroy(claim(out.renderer))
165    previousSyntax.destroy()
166    nextSyntax.destroy()
167  }
168})
169 
170function activeSyntax(scrollback: RunScrollbackStream) {
171  const entry = Reflect.get(scrollback, "active") as { renderable?: { syntaxStyle?: SyntaxStyle } } | undefined
172  return entry?.renderable?.syntaxStyle
173}
174 
175test("theme swaps preserve streamed markdown parser state", async () => {
176  const out = await setup()
177  const next = {
178    ...RUN_THEME_FALLBACK,
179    footer: {
180      ...RUN_THEME_FALLBACK.footer,
181      surface: RGBA.fromHex("#123456"),
182    },
183  }
184 
185  try {
186    await out.scrollback.append(assistant("```ts\nconst answer ="))
187    out.scrollback.setTheme(next)
188    await out.scrollback.append(assistant(" 42\n```"))
189    await out.scrollback.complete()
190 
191    const commits = claim(out.renderer)
192    try {
193      const output = render(commits)
194      expect(output).toContain("const answer = 42")
195      expect(output).not.toContain("```")
196    } finally {
197      destroy(commits)
198    }
199  } finally {
200    out.scrollback.destroy()
201  }
202})
203 
204function user(text: string): StreamCommit {
205  return {
206    kind: "user",
207    text,
208    phase: "start",
209    source: "system",
210  }
211}
212 
213function error(text: string): StreamCommit {
214  return {
215    kind: "error",
216    text,
217    phase: "start",
218    source: "system",
219  }
220}
221 
222function toolPart(tool: string, state: Record<string, unknown>, id: string, messageID: string): ToolPart {
223  return {
224    id,
225    sessionID: "session-1",
226    messageID,
227    type: "tool",
228    callID: `call-${id}`,
229    tool,
230    state,
231  } as ToolPart
232}
233 
234function toolCommit(input: {
235  tool: string
236  phase: StreamCommit["phase"]
237  toolState?: StreamCommit["toolState"]
238  text?: string
239  state?: Record<string, unknown>
240  id?: string
241  messageID?: string
242}): StreamCommit {
243  const id = input.id ?? `${input.tool}-1`
244  const messageID = input.messageID ?? `msg-${input.tool}`
245 
246  return {
247    kind: "tool",
248    text: input.text ?? "",
249    phase: input.phase,
250    source: "tool",
251    partID: id,
252    messageID,
253    tool: input.tool,
254    ...(input.toolState ? { toolState: input.toolState } : {}),
255    ...(input.state ? { part: toolPart(input.tool, input.state, id, messageID) } : {}),
256  }
257}
258 
259test("finalizes markdown tables for streamed and coalesced input", async () => {
260  const text =
261    "| Column 1 | Column 2 | Column 3 |\n|---|---|---|\n| Row 1 | Value 1 | Value 2 |\n| Row 2 | Value 3 | Value 4 |"
262 
263  for (const chunks of [[text], [...text]]) {
264    const out = await setup()
265 
266    try {
267      for (const chunk of chunks) {
268        await out.scrollback.append(assistant(chunk))
269      }
270 
271      await out.scrollback.complete()
272 
273      const commits = claim(out.renderer)
274      try {
275        const output = render(commits)
276        expect(output).toContain("Column 1")
277        expect(output).toContain("Row 2")
278        expect(output).toContain("Value 4")
279      } finally {
280        destroy(commits)
281      }
282    } finally {
283      out.scrollback.destroy()
284    }
285  }
286})
287 
288test("holds markdown code blocks until final commit and keeps newline ownership", async () => {
289  const out = await setup()
290 
291  try {
292    await out.scrollback.append(
293      assistant(
294        '# Markdown Sample\n\n- Item 1\n- Item 2\n\n```js\nconst message = "Hello, markdown"\nconsole.log(message)\n```',
295      ),
296    )
297 
298    const progress = claim(out.renderer)
299    try {
300      expect(progress).toHaveLength(1)
301      expect(render(progress)).toContain("Markdown Sample")
302      expect(render(progress)).toContain("Item 2")
303      expect(render(progress)).not.toContain("console.log(message)")
304    } finally {
305      destroy(progress)
306    }
307 
308    await out.scrollback.complete()
309 
310    const final = claim(out.renderer)
311    try {
312      expect(final).toHaveLength(1)
313      expect(final[0]!.trailingNewline).toBe(false)
314      expect(render(final)).toContain('const message = "Hello, markdown"')
315      expect(render(final)).toContain("console.log(message)")
316    } finally {
317      destroy(final)
318    }
319  } finally {
320    out.scrollback.destroy()
321  }
322})
323 
324test("renders todo and question summaries without boilerplate footer copy", async () => {
325  const cases = [
326    {
327      title: "# Todos",
328      include: [
329        "[✓] List files under `run/`",
330        "[•] Count functions in each `run/` file",
331        "[ ] Mark each tracking item complete",
332      ],
333      exclude: ["Updating", "todos completed"],
334      start: toolCommit({
335        tool: "todowrite",
336        phase: "start",
337        toolState: "running",
338        state: {
339          status: "running",
340          input: {
341            todos: [
342              { status: "completed", content: "List files under `run/`" },
343              { status: "in_progress", content: "Count functions in each `run/` file" },
344              { status: "pending", content: "Mark each tracking item complete" },
345            ],
346          },
347          time: { start: 1 },
348        },
349      }),
350      final: toolCommit({
351        tool: "todowrite",
352        phase: "final",
353        toolState: "completed",
354        state: {
355          status: "completed",
356          input: {
357            todos: [
358              { status: "completed", content: "List files under `run/`" },
359              { status: "in_progress", content: "Count functions in each `run/` file" },
360              { status: "pending", content: "Mark each tracking item complete" },
361            ],
362          },
363          metadata: {},
364          time: { start: 1, end: 4 },
365        },
366      }),
367    },
368    {
369      title: "# Questions",
370      include: ["What should I work on in the codebase next?", "Bug fix"],
371      exclude: ["Asked", "questions completed"],
372      start: toolCommit({
373        tool: "question",
374        phase: "start",
375        toolState: "running",
376        state: {
377          status: "running",
378          input: {
379            questions: [
380              {
381                question: "What should I work on in the codebase next?",
382                header: "Next work",
383                options: [{ label: "bug", description: "Bug fix" }],
384                multiple: false,
385              },
386            ],
387          },
388          time: { start: 1 },
389        },
390      }),
391      final: toolCommit({
392        tool: "question",
393        phase: "final",
394        toolState: "completed",
395        state: {
396          status: "completed",
397          input: {
398            questions: [
399              {
400                question: "What should I work on in the codebase next?",
401                header: "Next work",
402                options: [{ label: "bug", description: "Bug fix" }],
403                multiple: false,
404              },
405            ],
406          },
407          metadata: {
408            answers: [["Bug fix"]],
409          },
410          time: { start: 1, end: 2100 },
411        },
412      }),
413    },
414  ]
415 
416  for (const item of cases) {
417    const out = await setup()
418 
419    try {
420      await out.scrollback.append(item.start)
421      expect(claim(out.renderer)).toHaveLength(0)
422 
423      await out.scrollback.append(item.final)
424 
425      const commits = claim(out.renderer)
426      try {
427        expect(commits).toHaveLength(1)
428        const rows = renderRows(commits[0]!)
429        const output = rows.join("\n")
430        expect(output).toContain(item.title)
431        for (const line of item.include) {
432          expect(output).toContain(line)
433        }
434        for (const line of item.exclude) {
435          expect(output).not.toContain(line)
436        }
437      } finally {
438        destroy(commits)
439      }
440    } finally {
441      out.scrollback.destroy()
442    }
443  }
444})
445 
446test("inserts spacers for new visible groups", async () => {
447  const prior = await setup({ wrote: true })
448 
449  try {
450    await prior.scrollback.append(user("use subagent to explore run.ts"))
451 
452    const commits = claim(prior.renderer)
453    try {
454      expect(commits).toHaveLength(2)
455      expect(renderCommit(commits[0]!).trim()).toBe("")
456      expect(renderCommit(commits[1]!).trim()).toBe("› use subagent to explore run.ts")
457    } finally {
458      destroy(commits)
459    }
460  } finally {
461    prior.scrollback.destroy()
462  }
463 
464  const grouped = await setup()
465 
466  try {
467    await grouped.scrollback.append(assistant("hello"))
468    await grouped.scrollback.complete()
469    destroy(claim(grouped.renderer))
470 
471    await grouped.scrollback.append(
472      toolCommit({
473        tool: "glob",
474        phase: "start",
475        text: "running glob",
476        toolState: "running",
477        state: {
478          status: "running",
479          input: {
480            pattern: "**/run.ts",
481          },
482          time: { start: 1 },
483        },
484      }),
485    )
486 
487    const commits = claim(grouped.renderer)
488    try {
489      expect(commits).toHaveLength(2)
490      expect(renderCommit(commits[0]!).trim()).toBe("")
491      expect(renderCommit(commits[1]!).replace(/ +/g, " ").trim()).toBe('✱ Glob "**/run.ts"')
492    } finally {
493      destroy(commits)
494    }
495  } finally {
496    grouped.scrollback.destroy()
497  }
498})
499 
500// TODO(windows): Re-enable on Windows once the streaming CodeRenderable
501// flush race is fixed. The reasoning commit is delivered as a `<code>`
502// renderable with `filetype="markdown"`, `streaming=true`, and
503// `drawUnstyledText=false`. On Windows the first paragraph of the reasoning
504// body (here `_Thinking:_ **Plan**`) is dropped from the committed rows —
505// the failing assertion shows only `Say hello.` survives, while Linux
506// (where `useThread` is forced off in `@opentui/core/testing`) and macOS
507// both pass.
508//
509// Investigation summary (see PR description for the link to this work):
510//   1. `reasoning("Thinking: ...", "progress")` enters `entry.body.ts`
511//      `reasoningBody`, which becomes a `code` body with filetype="markdown".
512//   2. `RunScrollbackStream.writeStreaming` sets `renderable.content = ...`
513//      while `streaming=true`. `CodeRenderable.set content` short-circuits
514//      (does NOT call `textBuffer.setText`) when streaming, drawUnstyledText
515//      is false, and a filetype is set — it relies on the next
516//      `startHighlight()` cycle to populate the buffer.
517//   3. `ScrollbackSurface.settle()` renders the surface, kicks the
518//      highlight via `renderSelf` → `startHighlight`, waits on
519//      `highlightingDone`, and re-renders. With `MockTreeSitterClient`
520//      returning `{highlights: []}`, the final branch (`else
521//      this.textBuffer.setText(content)`) populates the buffer and
522//      `_shouldRenderTextBuffer = true`.
523//   4. `flushActive` then commits rows `[0, surface.height - 1)` during
524//      streaming. On Windows the committed rows are blank for the first
525//      paragraph — suggesting the height/text-buffer state is observed
526//      before/after the highlight resolution in a way that drops rows on
527//      that platform.
528//
529// Linux CI can also drop the first paragraph of the replayed reasoning block,
530// so this test asserts the stable second paragraph instead of the first-line
531// `Thinking:` label. A real fix probably belongs in opentui (either force
532// deterministic rendering for tests, or eagerly call `textBuffer.setText` in
533// `CodeRenderable.set content` when streaming updates a non-empty body).
534//
535// Skipping on win32 unblocks unrelated PRs; the assertion is still
536// exercised on Linux and macOS in CI.
537test.skipIf(process.platform === "win32")(
538  "renders replayed user, reasoning, and assistant output after completion",
539  async () => {
540    const out = await setup()
541 
542    try {
543      const lines: string[] = []
544      const take = () => {
545        const commits = claim(out.renderer)
546        try {
547          lines.push(...commits.flatMap((commit) => renderRows(commit).flatMap((row) => row.split("\n"))))
548        } finally {
549          destroy(commits)
550        }
551      }
552 
553      await out.scrollback.append(user("Hello you"))
554      take()
555      await out.scrollback.append(reasoning("Thinking: **Plan**\n\nSay hello.", "progress"))
556      await out.scrollback.complete()
557      take()
558      await out.scrollback.append(assistant("Hello.", "progress"))
559      await out.scrollback.complete()
560      take()
561 
562      const output = lines.join("\n")
563      expect(output).toContain("› Hello you")
564      expect(output).toContain("Say hello.")
565      expect(output).toContain("Hello.")
566    } finally {
567      out.scrollback.destroy()
568    }
569  },
570)
571 
572test("coalesces same-line tool progress into one snapshot", async () => {
573  const out = await setup()
574 
575  try {
576    await out.scrollback.append(toolCommit({ tool: "bash", phase: "progress", text: "abc" }))
577    await out.scrollback.append(toolCommit({ tool: "bash", phase: "progress", text: "def" }))
578    await out.scrollback.append(toolCommit({ tool: "bash", phase: "final", text: "", toolState: "completed" }))
579 
580    const commits = claim(out.renderer)
581    try {
582      expect(commits).toHaveLength(1)
583      expect(render(commits)).toContain("abcdef")
584    } finally {
585      destroy(commits)
586    }
587  } finally {
588    out.scrollback.destroy()
589  }
590})
591 
592test("omits the current directory from bash titles", async () => {
593  const out = await setup()
594 
595  try {
596    await out.scrollback.append(
597      toolCommit({
598        tool: "bash",
599        phase: "start",
600        toolState: "running",
601        state: {
602          status: "running",
603          input: {
604            command: "pwd",
605            workdir: process.cwd(),
606          },
607          time: { start: 1 },
608        },
609      }),
610    )
611 
612    const commits = claim(out.renderer)
613    try {
614      expect(render(commits)).toContain("$ pwd")
615      expect(render(commits)).not.toContain("Running in .")
616    } finally {
617      destroy(commits)
618    }
619  } finally {
620    out.scrollback.destroy()
621  }
622})
623 
624test("renders completed bash output with one blank line after the command and before the next group", async () => {
625  const out = await setup()
626 
627  try {
628    const lines: string[] = []
629    const take = () => {
630      const commits = claim(out.renderer)
631      try {
632        lines.push(...commits.flatMap((commit) => renderRows(commit).flatMap((row) => row.split("\n"))))
633      } finally {
634        destroy(commits)
635      }
636    }
637 
638    await out.scrollback.append(user("/fmt bash"))
639    take()
640    await out.scrollback.append(
641      toolCommit({
642        tool: "bash",
643        phase: "start",
644        toolState: "running",
645        state: {
646          status: "running",
647          input: {
648            command: "git status",
649            workdir: "/tmp/demo",
650          },
651          time: { start: 1 },
652        },
653      }),
654    )
655    take()
656    await out.scrollback.append(
657      toolCommit({
658        tool: "bash",
659        phase: "progress",
660        toolState: "completed",
661        text: ["/tmp/demo", "git status", "On branch demo", "nothing to commit, working tree clean", ""].join("\n"),
662        state: {
663          status: "completed",
664          input: {
665            command: "git status",
666            workdir: "/tmp/demo",
667          },
668          time: { start: 1, end: 2 },
669        },
670      }),
671    )
672    take()
673    await out.scrollback.append(assistant("oc-run-dev ahead 1"))
674    await out.scrollback.complete()
675    take()
676 
677    const output = lines.join("\n")
678    expect(output).toContain("# Running in /tmp/demo\n$ git status")
679    expect(output).toContain("$ git status\n\nOn branch demo")
680    expect(output).toContain("nothing to commit, working tree clean\n\noc-run-dev ahead 1")
681    expect(output).not.toContain("nothing to commit, working tree clean\n\n\noc-run-dev ahead 1")
682  } finally {
683    out.scrollback.destroy()
684  }
685})
686 
687test("inserts a spacer before the next tool after completed multiline bash output", async () => {
688  const out = await setup()
689 
690  try {
691    const lines: string[] = []
692    const take = () => {
693      const commits = claim(out.renderer)
694      try {
695        lines.push(...commits.flatMap((commit) => renderRows(commit).flatMap((row) => row.split("\n"))))
696      } finally {
697        destroy(commits)
698      }
699    }
700 
701    await out.scrollback.append(
702      toolCommit({
703        tool: "bash",
704        phase: "start",
705        toolState: "running",
706        state: {
707          status: "running",
708          input: {
709            command: "pwd; ls -la",
710            workdir: "/tmp/demo",
711          },
712          time: { start: 1 },
713        },
714      }),
715    )
716    take()
717    await out.scrollback.append(
718      toolCommit({
719        tool: "bash",
720        phase: "progress",
721        toolState: "completed",
722        text: ["/tmp/demo", "pwd; ls -la", "/tmp/demo", "total 4", "", ""].join("\n"),
723        state: {
724          status: "completed",
725          input: {
726            command: "pwd; ls -la",
727            workdir: "/tmp/demo",
728          },
729          output: ["/tmp/demo", "pwd; ls -la", "/tmp/demo", "total 4", "", ""].join("\n"),
730          title: "pwd; ls -la",
731          metadata: {
732            exitCode: 0,
733          },
734          time: { start: 1, end: 2 },
735        },
736      }),
737    )
738    take()
739    await out.scrollback.append(
740      toolCommit({
741        tool: "glob",
742        phase: "start",
743        toolState: "running",
744        state: {
745          status: "running",
746          input: {
747            pattern: "**/*tool*",
748            path: "src/cli/cmd",
749          },
750          time: { start: 3 },
751        },
752      }),
753    )
754    take()
755 
756    const output = lines.join("\n")
757    expect(output).toContain('total 4\n\n✱ Glob "**/*tool*" in src/cli/cmd')
758  } finally {
759    out.scrollback.destroy()
760  }
761})
762 
763test("does not double-space before completed bash output when inline tool headers intervene", async () => {
764  const out = await setup()
765 
766  try {
767    const lines: string[] = []
768    const take = () => {
769      const commits = claim(out.renderer)
770      try {
771        lines.push(...commits.flatMap((commit) => renderRows(commit).flatMap((row) => row.split("\n"))))
772      } finally {
773        destroy(commits)
774      }
775    }
776 
777    await out.scrollback.append(
778      toolCommit({
779        tool: "bash",
780        phase: "start",
781        toolState: "running",
782        state: {
783          status: "running",
784          input: {
785            command: "ls",
786            workdir: "src/cli/cmd/run",
787          },
788          time: { start: 1 },
789        },
790      }),
791    )
792    take()
793    await out.scrollback.append(
794      toolCommit({
795        tool: "glob",
796        phase: "start",
797        toolState: "running",
798        state: {
799          status: "running",
800          input: {
801            pattern: "**/*tool*",
802            path: "src/cli/cmd/run",
803          },
804          time: { start: 2 },
805        },
806      }),
807    )
808    take()
809    await out.scrollback.append(
810      toolCommit({
811        tool: "grep",
812        phase: "start",
813        toolState: "running",
814        state: {
815          status: "running",
816          input: {
817            pattern: "tool",
818            path: "src/cli/cmd/run",
819          },
820          time: { start: 3 },
821        },
822      }),
823    )
824    take()
825    await out.scrollback.append(
826      toolCommit({
827        tool: "bash",
828        phase: "progress",
829        toolState: "completed",
830        text: ["src/cli/cmd/run", "ls", "demo.ts", "entry.body.ts", "", ""].join("\n"),
831        state: {
832          status: "completed",
833          input: {
834            command: "ls",
835            workdir: "src/cli/cmd/run",
836          },
837          output: ["src/cli/cmd/run", "ls", "demo.ts", "entry.body.ts", "", ""].join("\n"),
838          title: "ls",
839          metadata: {
840            exitCode: 0,
841          },
842          time: { start: 1, end: 4 },
843        },
844      }),
845    )
846    take()
847 
848    const output = lines.join("\n")
849    expect(output).toContain('✱ Grep "tool" in src/cli/cmd/run\n\ndemo.ts')
850    expect(output).not.toContain('✱ Grep "tool" in src/cli/cmd/run\n\n\ndemo.ts')
851  } finally {
852    out.scrollback.destroy()
853  }
854})
855 
856test("does not emit blank patch snapshots between edit and task", async () => {
857  const out = await setup()
858 
859  try {
860    const lines: string[] = []
861    const take = () => {
862      const commits = claim(out.renderer)
863      try {
864        lines.push(...commits.flatMap((commit) => renderRows(commit).flatMap((row) => row.split("\n"))))
865      } finally {
866        destroy(commits)
867      }
868    }
869 
870    await out.scrollback.append(
871      toolCommit({
872        tool: "edit",
873        phase: "final",
874        toolState: "completed",
875        state: {
876          status: "completed",
877          input: {
878            filePath: "src/demo-format.ts",
879          },
880          output: "",
881          title: "edit",
882          metadata: {
883            diff: "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n",
884          },
885          time: { start: 1, end: 2 },
886        },
887      }),
888    )
889    take()
890    await out.scrollback.append(
891      toolCommit({
892        tool: "apply_patch",
893        phase: "final",
894        toolState: "completed",
895        state: {
896          status: "completed",
897          input: {
898            patchText: "*** Begin Patch\n*** End Patch",
899          },
900          output: "",
901          title: "apply_patch",
902          metadata: {
903            files: [
904              {
905                type: "update",
906                filePath: "src/demo-format.ts",
907                relativePath: "src/demo-format.ts",
908                diff: "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n",
909                deletions: 1,
910              },
911              {
912                type: "add",
913                filePath: "README-demo.md",
914                relativePath: "README-demo.md",
915              },
916            ],
917          },
918          time: { start: 2, end: 3 },
919        },
920      }),
921    )
922    take()
923    await out.scrollback.append(
924      toolCommit({
925        tool: "task",
926        phase: "final",
927        toolState: "completed",
928        state: {
929          status: "completed",
930          input: {
931            description: "Scan run/* for reducer touchpoints",
932            subagent_type: "explore",
933          },
934          output: "",
935          title: "task",
936          metadata: {
937            sessionId: "sub_demo_1",
938          },
939          time: { start: 3, end: 4 },
940        },
941      }),
942    )
943    take()
944 
945    const output = lines.join("\n")
946    expect(output).toContain("+ Created README-demo.md")
947    expect(output).not.toContain("~ Patched src/demo-format.ts")
948    expect(output).toContain("+ Created README-demo.md\n\n# Explore Task")
949    expect(output).not.toContain("+ Created README-demo.md\n\n\n# Explore Task")
950  } finally {
951    out.scrollback.destroy()
952  }
953})
954 
955test("renders plain errors with one blank line before and after the error block", async () => {
956  const out = await setup()
957 
958  try {
959    const lines: string[] = []
960    const take = (check?: (commits: ClaimedCommit[]) => void) => {
961      const commits = claim(out.renderer)
962      try {
963        check?.(commits)
964        lines.push(...commits.flatMap((commit) => renderRows(commit).flatMap((row) => row.split("\n"))))
965      } finally {
966        destroy(commits)
967      }
968    }
969 
970    await out.scrollback.append(user("/fmt error"))
971    take()
972    await out.scrollback.append(error("demo error event"))
973    take((commits) => {
974      expect(commits.at(-1)?.trailingNewline).toBe(false)
975    })
976    await out.scrollback.append(assistant("next line"))
977    await out.scrollback.complete()
978    take()
979 
980    const output = lines.join("\n")
981    expect(output).toContain("› /fmt error\n\ndemo error event")
982    expect(output).toContain("demo error event\n\nnext line")
983    expect(output).not.toContain("demo error event\n\n\nnext line")
984  } finally {
985    out.scrollback.destroy()
986  }
987})
988 
989test("renders structured write finals once as code blocks", async () => {
990  const out = await setup()
991 
992  try {
993    await out.scrollback.append(
994      toolCommit({
995        tool: "write",
996        phase: "start",
997        toolState: "running",
998        id: "tool-2",
999        messageID: "msg-2",
1000        state: {
1001          status: "running",
1002          input: {
1003            filePath: "src/a.ts",
1004            content: "const x = 1\nconst y = 2\n",
1005          },
1006          time: { start: 1 },
1007        },
1008      }),
1009    )
1010    expect(claim(out.renderer)).toHaveLength(0)
1011 
1012    await out.scrollback.append(
1013      toolCommit({
1014        tool: "write",
1015        phase: "final",
1016        toolState: "completed",
1017        id: "tool-2",
1018        messageID: "msg-2",
1019        state: {
1020          status: "completed",
1021          input: {
1022            filePath: "src/a.ts",
1023            content: "const x = 1\nconst y = 2\n",
1024          },
1025          metadata: {},
1026          time: { start: 1, end: 2 },
1027        },
1028      }),
1029    )
1030 
1031    const commits = claim(out.renderer)
1032    try {
1033      expect(commits).toHaveLength(1)
1034      const output = render(commits[0] ? [commits[0]] : [])
1035      expect(output).toContain("# Wrote src/a.ts")
1036      expect(output).toMatch(/1\s+const x = 1/)
1037      expect(output).toMatch(/2\s+const y = 2/)
1038    } finally {
1039      destroy(commits)
1040    }
1041  } finally {
1042    out.scrollback.destroy()
1043  }
1044})
1045 
1046test("renders promoted task markdown without a leading blank row", async () => {
1047  const out = await setup()
1048 
1049  try {
1050    await out.scrollback.append(
1051      toolCommit({
1052        tool: "task",
1053        phase: "final",
1054        toolState: "completed",
1055        state: {
1056          status: "completed",
1057          input: {
1058            description: "Explore run.ts",
1059            subagent_type: "explore",
1060          },
1061          output: [
1062            '<task id="child-1" state="completed">',
1063            "<task_result>",
1064            "Location: `/tmp/run.ts`",
1065            "",
1066            "Summary:",
1067            "- Local interactive mode",
1068            "- Attach mode",
1069            "</task_result>",
1070            "</task>",
1071          ].join("\n"),
1072          metadata: {
1073            sessionId: "child-1",
1074          },
1075          time: { start: 1, end: 2 },
1076        },
1077      }),
1078    )
1079 
1080    const commits = claim(out.renderer)
1081    try {
1082      const output = render(commits)
1083      expect(output.startsWith("\n")).toBe(false)
1084      expect(output).toContain("Summary:")
1085      expect(output).toContain("Local interactive mode")
1086    } finally {
1087      destroy(commits)
1088    }
1089  } finally {
1090    out.scrollback.destroy()
1091  }
1092})
1093