feat(aircoding): AirCoding V2 baseline — deterministic multi-agent architecture

Forked from OpenCode v1.17.4 with multi-agent system:
- 5 agents: aircoding, scheduler, worker, architect, reviewer
- Deterministic DAG scheduling engine (coordinator_tick)
- Tool whitelists as hard enforcement
- AirCoding validation plugin
- System prompt injection for routing
- V1 requirements: C4 docs, ADR, AGENTS.md, debug-log.md
- Design documents in docs/

packages/tui/test/cli/cmd/tui/dialog-workspace-create.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test"
+import { recentConnectedWorkspaces } from "../../../../src/component/dialog-workspace-create"
+
+describe("recentConnectedWorkspaces", () => {
+  test("returns connected workspaces sorted by time used", () => {
+    const workspaces = [
+      { id: "wrk_a", name: "alpha", timeUsed: 700 },
+      { id: "wrk_b", name: "beta", timeUsed: 800 },
+      { id: "wrk_c", name: "gamma", timeUsed: 400 },
+      { id: "wrk_d", name: "delta", timeUsed: 300 },
+      { id: "wrk_e", name: "epsilon", timeUsed: 200 },
+    ]
+    const status = {
+      wrk_a: "connected",
+      wrk_b: "disconnected",
+      wrk_c: "error",
+      wrk_d: "connected",
+      wrk_e: "connected",
+    } as const
+
+    const { recent } = recentConnectedWorkspaces({
+      workspaces,
+      status: (workspaceID) => status[workspaceID as keyof typeof status],
+    })
+
+    expect(recent.map((workspace) => workspace.id)).toEqual(["wrk_a", "wrk_d", "wrk_e"])
+  })
+})

packages/tui/test/cli/cmd/tui/model-options.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test"
+import { sortModelOptions } from "../../../../src/component/dialog-model"
+
+describe("sortModelOptions", () => {
+  test("orders provider-scoped model choices by newest release first", () => {
+    const sorted = sortModelOptions(
+      [
+        { title: "GPT 5.2", releaseDate: "2025-12-11" },
+        { title: "GPT 5.4", releaseDate: "2026-03-05" },
+        { title: "GPT 5.1", releaseDate: "2025-11-13" },
+      ],
+      true,
+    )
+
+    expect(sorted.map((model) => model.title)).toEqual(["GPT 5.4", "GPT 5.2", "GPT 5.1"])
+  })
+
+  test("preserves free-first alphabetical ordering for the regular picker", () => {
+    const sorted = sortModelOptions(
+      [
+        { title: "Beta", releaseDate: "2026-01-01" },
+        { title: "Alpha", releaseDate: "2025-01-01", footer: "Free" },
+        { title: "Gamma", releaseDate: "2024-01-01", footer: "Free" },
+      ],
+      false,
+    )
+
+    expect(sorted.map((model) => model.title)).toEqual(["Alpha", "Gamma", "Beta"])
+  })
+})

packages/tui/test/cli/cmd/tui/notifications.test.ts

@@ -0,0 +1,267 @@
+import { describe, expect, test } from "bun:test"
+import Notifications from "../../../../src/feature-plugins/system/notifications"
+import type { Event, PermissionRequest, QuestionRequest, Session } from "@opencode-ai/sdk/v2"
+import type { TuiAttentionNotifyInput } from "@opencode-ai/plugin/tui"
+import { createTuiPluginApi } from "../../../fixture/tui-plugin"
+
+async function setup() {
+  const notifications: TuiAttentionNotifyInput[] = []
+  const handlers = new Map<Event["type"], ((event: Event) => void)[]>()
+  const session = (id: string, title: string, parentID?: string): Session => ({
+    id,
+    title,
+    slug: id,
+    projectID: "project",
+    directory: "/workspace",
+    ...(parentID && { parentID }),
+    version: "0.0.0-test",
+    time: { created: 0, updated: 0 },
+  })
+  const sessions: Record<string, Session> = {
+    session: session("session", "Demo session"),
+    subagent: session("subagent", "Subagent session", "session"),
+    abort: session("abort", "Abort session"),
+    timeout: session("timeout", "Timeout session"),
+  }
+
+  await Notifications.tui(
+    createTuiPluginApi({
+      attention: {
+        async notify(input) {
+          notifications.push(input)
+          return { ok: true, notification: true, sound: true }
+        },
+      },
+      event: {
+        on: <Type extends Event["type"]>(type: Type, handler: (event: Extract<Event, { type: Type }>) => void) => {
+          const list = handlers.get(type) ?? []
+          const wrapped = handler as (event: Event) => void
+          list.push(wrapped)
+          handlers.set(type, list)
+          return () => {
+            handlers.set(
+              type,
+              (handlers.get(type) ?? []).filter((item) => item !== wrapped),
+            )
+          }
+        },
+      },
+      state: {
+        session: {
+          get: (sessionID: string) => sessions[sessionID],
+        },
+      },
+    }),
+    undefined,
+    {} as never,
+  )
+
+  return {
+    notifications,
+    emit(event: Event) {
+      for (const handler of handlers.get(event.type) ?? []) handler(event)
+    },
+  }
+}
+
+function question(id: string, sessionID = "session"): QuestionRequest {
+  return {
+    id,
+    sessionID,
+    questions: [],
+  }
+}
+
+function permission(id: string, sessionID = "session"): PermissionRequest {
+  return {
+    id,
+    sessionID,
+    permission: "edit",
+    patterns: [],
+    metadata: {},
+    always: [],
+  }
+}
+
+const questionNotification: TuiAttentionNotifyInput = {
+  title: "Demo session",
+  message: "Question needs input",
+  notification: { when: "blurred" },
+  sound: { name: "question", when: "always" },
+}
+
+const permissionNotification: TuiAttentionNotifyInput = {
+  title: "Demo session",
+  message: "Permission needs input",
+  notification: { when: "blurred" },
+  sound: { name: "permission", when: "always" },
+}
+
+describe("internal notifications TUI plugin", () => {
+  test("notifies for question and permission requests with blurred notifications and always-on sounds", async () => {
+    const harness = await setup()
+
+    harness.emit({ id: "event-1", type: "question.asked", properties: question("question-1") })
+    harness.emit({ id: "event-2", type: "permission.asked", properties: permission("permission-1") })
+
+    expect(harness.notifications).toEqual([questionNotification, permissionNotification])
+  })
+
+  test("dedupes pending questions and permissions until they are resolved", async () => {
+    const harness = await setup()
+
+    harness.emit({ id: "event-1", type: "question.asked", properties: question("question-1") })
+    harness.emit({ id: "event-2", type: "question.asked", properties: question("question-1") })
+    harness.emit({
+      id: "event-3",
+      type: "question.replied",
+      properties: { sessionID: "session", requestID: "question-1", answers: [] },
+    })
+    harness.emit({ id: "event-4", type: "question.asked", properties: question("question-1") })
+
+    harness.emit({ id: "event-5", type: "permission.asked", properties: permission("permission-1") })
+    harness.emit({ id: "event-6", type: "permission.asked", properties: permission("permission-1") })
+    harness.emit({
+      id: "event-7",
+      type: "permission.replied",
+      properties: { sessionID: "session", requestID: "permission-1", reply: "once" },
+    })
+    harness.emit({ id: "event-8", type: "permission.asked", properties: permission("permission-1") })
+
+    expect(harness.notifications).toEqual([
+      questionNotification,
+      questionNotification,
+      permissionNotification,
+      permissionNotification,
+    ])
+  })
+
+  test("notifies when an active session becomes idle and suppresses no-op idle", async () => {
+    const harness = await setup()
+
+    harness.emit({
+      id: "event-1",
+      type: "session.status",
+      properties: { sessionID: "session", status: { type: "idle" } },
+    })
+    harness.emit({
+      id: "event-2",
+      type: "session.status",
+      properties: { sessionID: "session", status: { type: "busy" } },
+    })
+    harness.emit({
+      id: "event-3",
+      type: "session.status",
+      properties: { sessionID: "session", status: { type: "idle" } },
+    })
+
+    expect(harness.notifications).toEqual([
+      {
+        title: "Demo session",
+        message: "Session done",
+        notification: { when: "blurred" },
+        sound: { name: "done", when: "always" },
+      },
+    ])
+  })
+
+  test("uses sound-only notifications and subagent_done sound for subagent sessions", async () => {
+    const harness = await setup()
+
+    harness.emit({ id: "event-1", type: "question.asked", properties: question("question-1", "subagent") })
+    harness.emit({
+      id: "event-2",
+      type: "session.status",
+      properties: { sessionID: "subagent", status: { type: "busy" } },
+    })
+    harness.emit({
+      id: "event-3",
+      type: "session.status",
+      properties: { sessionID: "subagent", status: { type: "idle" } },
+    })
+
+    expect(harness.notifications).toEqual([
+      {
+        title: "Subagent session",
+        message: "Question needs input",
+        notification: false,
+        sound: { name: "question", when: "always" },
+      },
+      {
+        title: "Subagent session",
+        message: "Session done",
+        notification: false,
+        sound: { name: "subagent_done", when: "always" },
+      },
+    ])
+  })
+
+  test("notifies session errors once and suppresses the following idle done notification", async () => {
+    const harness = await setup()
+
+    harness.emit({
+      id: "event-1",
+      type: "session.status",
+      properties: { sessionID: "session", status: { type: "busy" } },
+    })
+    harness.emit({
+      id: "event-2",
+      type: "session.error",
+      properties: { sessionID: "session", error: { name: "UnknownError", data: { message: "boom" } } },
+    })
+    harness.emit({
+      id: "event-3",
+      type: "session.status",
+      properties: { sessionID: "session", status: { type: "idle" } },
+    })
+
+    expect(harness.notifications).toEqual([
+      {
+        title: "Demo session",
+        message: "Session error",
+        notification: { when: "blurred" },
+        sound: { name: "error", when: "always" },
+      },
+    ])
+  })
+
+  test("special-cases aborts and model response timeouts", async () => {
+    const harness = await setup()
+
+    harness.emit({
+      id: "event-1",
+      type: "session.status",
+      properties: { sessionID: "abort", status: { type: "busy" } },
+    })
+    harness.emit({
+      id: "event-2",
+      type: "session.error",
+      properties: { sessionID: "abort", error: { name: "MessageAbortedError", data: { message: "Aborted" } } },
+    })
+    harness.emit({
+      id: "event-3",
+      type: "session.status",
+      properties: { sessionID: "timeout", status: { type: "busy" } },
+    })
+    harness.emit({
+      id: "event-4",
+      type: "session.error",
+      properties: { sessionID: "timeout", error: { name: "UnknownError", data: { message: "SSE read timed out" } } },
+    })
+
+    expect(harness.notifications).toEqual([
+      {
+        title: "Abort session",
+        message: "Session aborted",
+        notification: { when: "blurred" },
+        sound: { name: "error", when: "always" },
+      },
+      {
+        title: "Timeout session",
+        message: "Model stopped responding",
+        notification: { when: "blurred" },
+        sound: { name: "error", when: "always" },
+      },
+    ])
+  })
+})

packages/tui/test/cli/cmd/tui/provider-options.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test"
+import { normalizeCustomProviderID, providerOptions } from "../../../../src/component/dialog-provider"
+
+describe("providerOptions", () => {
+  test("includes a synthetic Other option for custom providers", () => {
+    expect(providerOptions([{ id: "openai", name: "OpenAI" }]).at(-1)).toMatchObject({
+      title: "Other",
+      description: "Custom provider",
+      category: "Providers",
+    })
+  })
+
+  test("does not use Other as the generic provider category", () => {
+    expect(providerOptions([{ id: "mistral", name: "Mistral" }])[0]?.category).toBe("Providers")
+  })
+
+  test("keeps popular providers first and sorts the rest alphabetically", () => {
+    expect(
+      providerOptions([
+        { id: "openai", name: "OpenAI" },
+        { id: "custom-z", name: "Zebra Provider" },
+        { id: "anthropic", name: "Anthropic" },
+        { id: "mistral", name: "Mistral" },
+        { id: "aws", name: "AWS Bedrock" },
+      ]).map((option) => option.value),
+    ).toEqual(["openai", "anthropic", "aws", "mistral", "custom-z", "__opencode_custom_provider__"])
+  })
+
+  test("does not collide with a configured provider named other", () => {
+    const values = providerOptions([{ id: "other", name: "Other Provider" }]).map((option) => option.value)
+    expect(new Set(values).size).toBe(values.length)
+  })
+
+  test("normalizes and validates custom provider ids", () => {
+    expect(normalizeCustomProviderID("  custom-provider  ")).toBe("custom-provider")
+    expect(normalizeCustomProviderID("custom_provider")).toBe("custom_provider")
+    expect(normalizeCustomProviderID("@ai-sdk/custom-provider")).toBe("custom-provider")
+    expect(normalizeCustomProviderID("-custom-provider")).toBeUndefined()
+    expect(normalizeCustomProviderID("Custom Provider")).toBeUndefined()
+  })
+})

packages/tui/test/cli/cmd/tui/sync-fixture.tsx

@@ -0,0 +1,64 @@
+/** @jsxImportSource @opentui/solid */
+import { testRender } from "@opentui/solid"
+import { onMount } from "solid-js"
+import { ArgsProvider } from "../../../../src/context/args"
+import { KVProvider, useKV } from "../../../../src/context/kv"
+import { ProjectProvider, useProject } from "../../../../src/context/project"
+import { SDKProvider } from "../../../../src/context/sdk"
+import { SyncProvider, useSync } from "../../../../src/context/sync"
+import { createEventSource, createFetch, type FetchHandler, directory } from "../../../fixture/tui-sdk"
+import { TestTuiContexts } from "../../../fixture/tui-environment"
+export { createEventSource, createFetch, directory, eventSource, json, worktree } from "../../../fixture/tui-sdk"
+
+export async function wait(fn: () => boolean, timeout = 2000) {
+  const start = Date.now()
+  while (!fn()) {
+    if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
+    await Bun.sleep(10)
+  }
+}
+
+type Ctx = { kv: ReturnType<typeof useKV>; project: ReturnType<typeof useProject>; sync: ReturnType<typeof useSync> }
+
+export async function mount(override?: FetchHandler, state?: string) {
+  const calls = createFetch(override)
+  const events = createEventSource()
+  let sync!: ReturnType<typeof useSync>
+  let project!: ReturnType<typeof useProject>
+  let kv!: ReturnType<typeof useKV>
+  let done!: () => void
+  const ready = new Promise<void>((resolve) => {
+    done = resolve
+  })
+
+  function Probe() {
+    const ctx: Ctx = { kv: useKV(), project: useProject(), sync: useSync() }
+    onMount(() => {
+      sync = ctx.sync
+      project = ctx.project
+      kv = ctx.kv
+      done()
+    })
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts paths={state ? { state } : undefined}>
+      <ArgsProvider>
+        <KVProvider>
+          <SDKProvider url="http://test" directory={directory} fetch={calls.fetch} events={events.source}>
+            <ProjectProvider>
+              <SyncProvider>
+                <Probe />
+              </SyncProvider>
+            </ProjectProvider>
+          </SDKProvider>
+        </KVProvider>
+      </ArgsProvider>
+    </TestTuiContexts>
+  ))
+
+  await ready
+  await wait(() => sync.status === "complete")
+  return { app, emit: events.emit, kv, project, sync, session: calls.session }
+}

packages/tui/test/cli/cmd/tui/sync-live-hydration.test.tsx

@@ -0,0 +1,262 @@
+/** @jsxImportSource @opentui/solid */
+import { expect, test } from "bun:test"
+import type { GlobalEvent } from "@opencode-ai/sdk/v2"
+import { tmpdir } from "../../../fixture/fixture"
+import { json, mount, wait } from "./sync-fixture"
+
+const sessionID = "ses_hydration_race"
+const messageID = "msg_hydration_race"
+const partID = "prt_hydration_race"
+const session = {
+  id: sessionID,
+  title: "race",
+  time: { created: 0, updated: 0 },
+  version: "1.15.13",
+  directory: "/tmp/opencode/packages/opencode",
+}
+const assistant = {
+  id: messageID,
+  sessionID,
+  role: "assistant" as const,
+  agent: "build",
+  modelID: "model",
+  providerID: "test",
+  mode: "build",
+  parentID: "msg_user",
+  path: { cwd: session.directory, root: session.directory },
+  cost: 0,
+  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+  time: { created: 1, completed: 2 },
+}
+
+function global(payload: GlobalEvent["payload"]): GlobalEvent {
+  return { directory: "/tmp/other", project: "proj_test", payload }
+}
+
+test("stale session hydration does not overwrite live message parts", async () => {
+  await using tmp = await tmpdir()
+  await Bun.write(`${tmp.path}/kv.json`, "{}")
+
+  let resolveMessages!: (response: Response) => void
+  const messages = new Promise<Response>((resolve) => {
+    resolveMessages = resolve
+  })
+  let requested = false
+  const { app, emit, sync } = await mount((url) => {
+    if (url.pathname === `/session/${sessionID}`) return json(session)
+    if (url.pathname === `/session/${sessionID}/message`) {
+      requested = true
+      return messages
+    }
+    if (url.pathname === `/session/${sessionID}/todo` || url.pathname === `/session/${sessionID}/diff`) return json([])
+    return undefined
+  }, tmp.path)
+
+  try {
+    const hydrate = sync.session.sync(sessionID)
+    await wait(() => requested)
+    emit(global({ id: "evt_message", type: "message.updated", properties: { sessionID, info: assistant } }))
+    emit(
+      global({
+        id: "evt_part",
+        type: "message.part.updated",
+        properties: {
+          sessionID,
+          time: 2,
+          part: { id: partID, sessionID, messageID, type: "text", text: "visible live content" },
+        },
+      }),
+    )
+    await wait(() => sync.data.part[messageID]?.[0]?.type === "text")
+
+    resolveMessages(
+      json([
+        {
+          info: assistant,
+          parts: [{ id: partID, sessionID, messageID, type: "text", text: "" }],
+        },
+      ]),
+    )
+    await hydrate
+
+    expect(sync.data.part[messageID][0]).toMatchObject({ text: "visible live content" })
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("orphan live deltas do not suppress hydrated parts", async () => {
+  await using tmp = await tmpdir()
+  await Bun.write(`${tmp.path}/kv.json`, "{}")
+
+  let resolveMessages!: (response: Response) => void
+  const messages = new Promise<Response>((resolve) => {
+    resolveMessages = resolve
+  })
+  let requested = false
+  const { app, emit, sync } = await mount((url) => {
+    if (url.pathname === `/session/${sessionID}`) return json(session)
+    if (url.pathname === `/session/${sessionID}/message`) {
+      requested = true
+      return messages
+    }
+    if (url.pathname === `/session/${sessionID}/todo` || url.pathname === `/session/${sessionID}/diff`) return json([])
+    return undefined
+  }, tmp.path)
+
+  try {
+    const hydrate = sync.session.sync(sessionID)
+    await wait(() => requested)
+    emit(
+      global({
+        id: "evt_delta",
+        type: "message.part.delta",
+        properties: { sessionID, messageID, partID, field: "text", delta: "ignored until part exists" },
+      }),
+    )
+    resolveMessages(
+      json([{ info: assistant, parts: [{ id: partID, sessionID, messageID, type: "text", text: "hydrated" }] }]),
+    )
+    await hydrate
+
+    expect(sync.data.part[messageID][0]).toMatchObject({ text: "hydrated" })
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("hydration does not clear text streamed before it starts", async () => {
+  await using tmp = await tmpdir()
+  await Bun.write(`${tmp.path}/kv.json`, "{}")
+
+  let resolveMessages!: (response: Response) => void
+  const messages = new Promise<Response>((resolve) => {
+    resolveMessages = resolve
+  })
+  let requested = false
+  const { app, emit, sync } = await mount((url) => {
+    if (url.pathname === `/session/${sessionID}`) return json(session)
+    if (url.pathname === `/session/${sessionID}/message`) {
+      requested = true
+      return messages
+    }
+    if (url.pathname === `/session/${sessionID}/todo` || url.pathname === `/session/${sessionID}/diff`) return json([])
+    return undefined
+  }, tmp.path)
+
+  try {
+    emit(global({ id: "evt_message", type: "message.updated", properties: { sessionID, info: assistant } }))
+    emit(
+      global({
+        id: "evt_part",
+        type: "message.part.updated",
+        properties: {
+          sessionID,
+          time: 1,
+          part: { id: partID, sessionID, messageID, type: "text", text: "" },
+        },
+      }),
+    )
+    emit(
+      global({
+        id: "evt_delta",
+        type: "message.part.delta",
+        properties: { sessionID, messageID, partID, field: "text", delta: "visible streamed content" },
+      }),
+    )
+    await wait(() => sync.data.part[messageID]?.[0]?.type === "text" && sync.data.part[messageID][0].text !== "")
+    const hydrate = sync.session.sync(sessionID)
+    await wait(() => requested)
+    resolveMessages(json([{ info: assistant, parts: [{ id: partID, sessionID, messageID, type: "text", text: "" }] }]))
+    await hydrate
+
+    expect(sync.data.part[messageID][0]).toMatchObject({ text: "visible streamed content" })
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("live messages merged during hydration retain the 100 message window", async () => {
+  await using tmp = await tmpdir()
+  await Bun.write(`${tmp.path}/kv.json`, "{}")
+
+  let resolveMessages!: (response: Response) => void
+  const messages = new Promise<Response>((resolve) => {
+    resolveMessages = resolve
+  })
+  let requested = false
+  const { app, emit, sync } = await mount((url) => {
+    if (url.pathname === `/session/${sessionID}`) return json(session)
+    if (url.pathname === `/session/${sessionID}/message`) {
+      requested = true
+      return messages
+    }
+    if (url.pathname === `/session/${sessionID}/todo` || url.pathname === `/session/${sessionID}/diff`) return json([])
+    return undefined
+  }, tmp.path)
+
+  try {
+    const hydrate = sync.session.sync(sessionID)
+    await wait(() => requested)
+    const live = { ...assistant, id: "msg_z_live" }
+    emit(global({ id: "evt_live", type: "message.updated", properties: { sessionID, info: live } }))
+    await wait(() => sync.data.message[sessionID]?.some((message) => message.id === live.id) ?? false)
+    resolveMessages(
+      json(
+        Array.from({ length: 100 }, (_, index) => {
+          const id = `msg_${String(index).padStart(3, "0")}`
+          return {
+            info: { ...assistant, id },
+            parts: [{ id: `prt_${id}`, sessionID, messageID: id, type: "text", text: id }],
+          }
+        }),
+      ),
+    )
+    await hydrate
+
+    expect(sync.data.message[sessionID]).toHaveLength(100)
+    expect(sync.data.message[sessionID].at(-1)?.id).toBe(live.id)
+    expect(sync.data.message[sessionID].some((message) => message.id === "msg_000")).toBe(false)
+    expect(sync.data.part.msg_000).toBeUndefined()
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("a message removed during hydration does not regain stale parts", async () => {
+  await using tmp = await tmpdir()
+  await Bun.write(`${tmp.path}/kv.json`, "{}")
+
+  let resolveMessages!: (response: Response) => void
+  const messages = new Promise<Response>((resolve) => {
+    resolveMessages = resolve
+  })
+  let requested = false
+  const { app, emit, sync } = await mount((url) => {
+    if (url.pathname === `/session/${sessionID}`) return json(session)
+    if (url.pathname === `/session/${sessionID}/message`) {
+      requested = true
+      return messages
+    }
+    if (url.pathname === `/session/${sessionID}/todo` || url.pathname === `/session/${sessionID}/diff`) return json([])
+    return undefined
+  }, tmp.path)
+
+  try {
+    emit(global({ id: "evt_message", type: "message.updated", properties: { sessionID, info: assistant } }))
+    await wait(() => sync.data.message[sessionID]?.length === 1)
+    const hydrate = sync.session.sync(sessionID)
+    await wait(() => requested)
+    emit(global({ id: "evt_removed", type: "message.removed", properties: { sessionID, messageID } }))
+    await wait(() => sync.data.message[sessionID]?.length === 0)
+    resolveMessages(
+      json([{ info: assistant, parts: [{ id: partID, sessionID, messageID, type: "text", text: "stale" }] }]),
+    )
+    await hydrate
+
+    expect(sync.data.message[sessionID]).toEqual([])
+    expect(sync.data.part[messageID]).toBeUndefined()
+  } finally {
+    app.renderer.destroy()
+  }
+})

packages/tui/test/cli/cmd/tui/sync-undefined-messages.test.tsx

@@ -0,0 +1,43 @@
+/** @jsxImportSource @opentui/solid */
+/**
+ * Reproducer for #26560 — TUI crashes with
+ *   `TypeError: undefined is not an object (evaluating 'f.data.map')`
+ * when entering a session whose messages endpoint returns a non-2xx.
+ * The failure path is `sync.tsx#sync.session.sync` reading
+ * `messages.data!` while the SDK leaves `data` undefined on error.
+ */
+import { describe, expect, test } from "bun:test"
+import { tmpdir } from "../../../fixture/fixture"
+import { directory, json, mount } from "./sync-fixture"
+
+const sessionID = "ses_undef"
+
+describe("tui sync (#26560)", () => {
+  test("entering a session whose messages endpoint errors does not crash sync", async () => {
+    await using tmp = await tmpdir()
+    await Bun.write(`${tmp.path}/kv.json`, "{}")
+
+    const sessionPayload = {
+      id: sessionID,
+      title: "broken",
+      time: { created: 0, updated: 0 },
+      version: "1.14.42",
+      directory,
+      project_id: "proj_test",
+    }
+    const { app, sync } = await mount((url) => {
+      if (url.pathname === `/session/${sessionID}`) return json(sessionPayload)
+      if (url.pathname === `/session/${sessionID}/messages`) return json({}, { status: 500 })
+      if (url.pathname === `/session/${sessionID}/todo`) return json([])
+      if (url.pathname === `/session/${sessionID}/diff`) return json([])
+      if (url.pathname === "/session") return json([sessionPayload])
+      return undefined
+    }, tmp.path)
+
+    try {
+      await expect(sync.session.sync(sessionID)).resolves.toBeUndefined()
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+})

packages/tui/test/cli/cmd/tui/sync.test.tsx

@@ -0,0 +1,63 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, test } from "bun:test"
+import { tmpdir } from "../../../fixture/fixture"
+import { mount, wait } from "./sync-fixture"
+import type { GlobalEvent } from "@opencode-ai/sdk/v2"
+
+function branchEvent(branch: string, workspace?: string): GlobalEvent {
+  return {
+    directory: "/tmp/other",
+    project: "proj_test",
+    workspace,
+    payload: {
+      id: `evt_vcs_${branch}`,
+      type: "vcs.branch.updated",
+      properties: { branch },
+    },
+  }
+}
+
+describe("tui sync", () => {
+  test("refresh scopes sessions by default and lists project sessions when disabled", async () => {
+    await using tmp = await tmpdir()
+    await Bun.write(`${tmp.path}/kv.json`, "{}")
+    const { app, kv, sync, session } = await mount(undefined, tmp.path)
+
+    try {
+      expect(kv.get("session_directory_filter_enabled", true)).toBe(true)
+      expect(session.at(-1)?.searchParams.get("scope")).toBeNull()
+      expect(session.at(-1)?.searchParams.get("path")).toBe("packages/tui")
+
+      kv.set("session_directory_filter_enabled", false)
+      await sync.session.refresh()
+
+      expect(session.at(-1)?.searchParams.get("scope")).toBe("project")
+      expect(session.at(-1)?.searchParams.get("path")).toBeNull()
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+
+  test("vcs branch updates only apply for the active workspace", async () => {
+    await using tmp = await tmpdir()
+    await Bun.write(`${tmp.path}/kv.json`, "{}")
+    const { app, emit, project, sync } = await mount(undefined, tmp.path)
+
+    try {
+      expect(sync.data.vcs?.branch).toBe("main")
+
+      project.workspace.set("ws_a")
+      emit(branchEvent("other", "ws_b"))
+      await Bun.sleep(30)
+
+      expect(sync.data.vcs?.branch).toBe("main")
+
+      emit(branchEvent("feature", "ws_a"))
+      await wait(() => sync.data.vcs?.branch === "feature")
+
+      expect(sync.data.vcs?.branch).toBe("feature")
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+})

packages/tui/test/cli/tui/__snapshots__/inline-tool-wrap-snapshot.test.tsx.snap

@@ -0,0 +1,72 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`TUI inline tool wrapping snapshots consecutive grep, glob, and read rows at a narrow width 1`] = `
+"   ✱ Grep "OPENCODE.*DB|database|sqlite|drizzle|dev.*db|data.
+     *dir|xdg|APPDATA" in packages/opencode/src (151 matches)
+   ✱ Glob "**/*db*" in packages/opencode (6 matches)
+   → Read packages/opencode/src/storage/db.ts [offset=1, limit=130]
+   → Read packages/opencode/src/index.ts [offset=1, limit=100]
+   ✱ Grep "export const OPENCODE_DB|OPENCODE_DB|OPENCODE_DEV|Global\\.
+     Path\\.data|data =" in packages/opencode/src (115 matches)"
+`;
+
+exports[`TUI inline tool wrapping snapshots expanded tool errors under the tool text 1`] = `
+"   ✱ Grep "OPENCODE.*DB|database|sqlite|drizzle|dev.*db|data.
+     *dir|xdg|APPDATA" in packages/opencode/src (151 matches)
+   ✱ Glob "**/*db*" in packages/opencode (6 matches)
+   → Read packages/opencode/src/storage/db.ts [offset=1, limit=130]
+   → Read packages/opencode/src/index.ts [offset=1, limit=100]
+     No LSP server available for this file type.
+   ✱ Grep "export const OPENCODE_DB|OPENCODE_DB|OPENCODE_DEV|Global\\.
+     Path\\.data|data =" in packages/opencode/src (115 matches)"
+`;
+
+exports[`TUI inline tool wrapping keeps separation after a shell output block 1`] = `
+"
+
+  # List files
+
+  $ ls
+
+  file.ts
+
+   ✱ Grep "OPENCODE.*DB|database|sqlite|drizzle|dev.*db|data.
+     *dir|xdg|APPDATA" in packages/opencode/src (151 matches)
+   ✱ Glob "**/*db*" in packages/opencode (6 matches)
+   → Read packages/opencode/src/storage/db.ts [offset=1, limit=130]
+   → Read packages/opencode/src/index.ts [offset=1, limit=100]
+   ✱ Grep "export const OPENCODE_DB|OPENCODE_DB|OPENCODE_DEV|Global\\.
+     Path\\.data|data =" in packages/opencode/src (115 matches)"
+`;
+
+exports[`TUI inline tool wrapping keeps separation after a padded user message 1`] = `
+"
+  Check whether the next tool remains separated.
+
+
+   ✱ Grep "OPENCODE.*DB|database|sqlite|drizzle|dev.*db|data.
+     *dir|xdg|APPDATA" in packages/opencode/src (151 matches)
+   ✱ Glob "**/*db*" in packages/opencode (6 matches)
+   → Read packages/opencode/src/storage/db.ts [offset=1, limit=130]
+   → Read packages/opencode/src/index.ts [offset=1, limit=100]
+   ✱ Grep "export const OPENCODE_DB|OPENCODE_DB|OPENCODE_DEV|Global\\.
+     Path\\.data|data =" in packages/opencode/src (115 matches)"
+`;
+
+exports[`TUI inline tool wrapping separates a contiguous subagent group from inline tools 1`] = `
+"   ✱ Grep "Task" (2 matches)
+
+   ⠙ Explore Task — Inspect active task spacing
+   ✓ General Task — Confirm completed task spacing
+     ↳ 1 toolcall · 501ms
+
+   → Read src/cli/cmd/tui/routes/session/index.tsx"
+`;
+
+exports[`TUI inline tool wrapping separates a subagent group after an expanded read 1`] = `
+"   → Read src/cli/cmd/tui/routes/session/index.tsx
+   ↳ Loaded src/cli/cmd/tui/routes/session/tools.tsx
+
+   ✓ Explore Task — Inspect active task spacing
+     ↳ 1 toolcall · 501ms"
+`;

packages/tui/test/cli/tui/data.test.tsx

@@ -0,0 +1,488 @@
+/** @jsxImportSource @opentui/solid */
+import { expect, test } from "bun:test"
+import { testRender } from "@opentui/solid"
+import type { Event, GlobalEvent } from "@opencode-ai/sdk/v2"
+import { onMount } from "solid-js"
+import { ProjectProvider } from "../../../src/context/project"
+import { SDKProvider } from "../../../src/context/sdk"
+import { DataProvider, useData } from "../../../src/context/data"
+import { createEventSource, createFetch, directory, json } from "../../fixture/tui-sdk"
+import { TestTuiContexts } from "../../fixture/tui-environment"
+
+async function wait(fn: () => boolean, timeout = 2000) {
+  const start = Date.now()
+  while (!fn()) {
+    if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
+    await Bun.sleep(10)
+  }
+}
+
+function global(payload: Event): GlobalEvent {
+  return { directory, project: "proj_test", payload }
+}
+
+function emitEvent(events: ReturnType<typeof createEventSource>, payload: Event) {
+  events.emit(global(payload))
+}
+
+test("refreshes resources into reactive getters", async () => {
+  const location = {
+    directory,
+    project: { id: "proj_test", directory },
+  }
+  const calls = createFetch((url) => {
+    if (url.pathname === "/api/session/ses_test")
+      return json({
+        data: {
+          id: "ses_test",
+          projectID: "proj_test",
+          cost: 0,
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          time: { created: 0, updated: 0 },
+          title: "Test session",
+          location: { directory },
+        },
+      })
+    if (url.pathname === "/api/agent")
+      return json({
+        location,
+        data: [{ id: "build", request: { headers: {}, body: {} }, mode: "primary", hidden: false, permissions: [] }],
+      })
+    return undefined
+  })
+  const events = createEventSource()
+  let data!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    data = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    expect(data.location.default()).toEqual({ directory })
+    expect(data.session.get("ses_test")).toBeUndefined()
+    expect(data.location.agent.list(location)).toBeUndefined()
+
+    await data.session.refresh("ses_test")
+    await data.location.agent.refresh()
+
+    expect(data.session.get("ses_test")?.title).toBe("Test session")
+    expect(data.location.default()).toEqual({ directory, workspaceID: undefined })
+    expect(data.location.agent.list(location)?.map((agent) => agent.id)).toEqual(["build"])
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("refreshes connectors after connector updates", async () => {
+  const events = createEventSource()
+  let requests = 0
+  const calls = createFetch((url) => {
+    if (url.pathname !== "/api/connector") return
+    requests++
+    return json({
+      location: { directory, project: { id: "proj_test", directory } },
+      data:
+        requests === 1
+          ? []
+          : [
+              {
+                id: "openai",
+                name: "OpenAI",
+                methods: [{ id: "api-key", type: "key", label: "API Key" }],
+              },
+            ],
+    })
+  })
+  let data!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    data = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    await wait(() => data.location.connector.list() !== undefined)
+    expect(data.location.connector.list()).toEqual([])
+
+    emitEvent(events, { id: "evt_connector", type: "connector.updated", properties: {} })
+    await wait(() => data.location.connector.list()?.length === 1)
+    expect(data.location.connector.list()?.[0]).toMatchObject({ id: "openai", name: "OpenAI" })
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("refreshes references after updates", async () => {
+  const events = createEventSource()
+  let requests = 0
+  const calls = createFetch((url) => {
+    if (url.pathname !== "/api/reference") return
+    requests++
+    return json({
+      location: { directory, project: { id: "proj_test", directory } },
+      data: requests === 1 ? [] : [{ name: "docs", path: "/docs", source: { type: "local", path: "/docs" } }],
+    })
+  })
+  let data!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    data = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    await wait(() => requests === 1)
+    emitEvent(events, { id: "evt_reference_1", type: "reference.updated", properties: {} })
+    await wait(() => data.location.reference.list()?.length === 1)
+    expect(data.location.reference.list()?.[0]?.name).toBe("docs")
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("settles pending tools when a live failure arrives", async () => {
+  const events = createEventSource()
+  const calls = createFetch()
+  let sync!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    sync = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    emitEvent(events, {
+      id: "evt_agent_1",
+      type: "session.next.agent.switched",
+      properties: { sessionID: "session-1", messageID: "msg_agent_1", timestamp: 0, agent: "build" },
+    })
+    emitEvent(events, {
+      id: "evt_model_1",
+      type: "session.next.model.switched",
+      properties: {
+        sessionID: "session-1",
+        messageID: "msg_model_1",
+        timestamp: 0,
+        model: { id: "model-1", providerID: "provider-1" },
+      },
+    })
+    emitEvent(events, {
+      id: "evt_step_started_1",
+      type: "session.next.step.started",
+      properties: {
+        sessionID: "session-1",
+        assistantMessageID: "msg_explicit_assistant_9",
+        timestamp: 1,
+        agent: "build",
+        model: { id: "model-1", providerID: "provider-1" },
+      },
+    })
+    emitEvent(events, {
+      id: "evt_input_1",
+      type: "session.next.tool.input.started",
+      properties: {
+        sessionID: "session-1",
+        assistantMessageID: "msg_explicit_assistant_9",
+        timestamp: 2,
+        callID: "call-1",
+        name: "bash",
+      },
+    })
+    emitEvent(events, {
+      id: "evt_called_1",
+      type: "session.next.tool.called",
+      properties: {
+        sessionID: "session-1",
+        timestamp: 2,
+        assistantMessageID: "msg_explicit_assistant_9",
+        callID: "call-1",
+        tool: "bash",
+        input: {},
+        provider: { executed: false, metadata: { fake: { call: true } } },
+      },
+    })
+    emitEvent(events, {
+      id: "evt_failed_1",
+      type: "session.next.tool.failed",
+      properties: {
+        sessionID: "session-1",
+        timestamp: 3,
+        assistantMessageID: "msg_explicit_assistant_9",
+        callID: "call-1",
+        error: { type: "unknown", message: "aborted" },
+        provider: { executed: false, metadata: { fake: { result: true } } },
+      },
+    })
+
+    await wait(() => {
+      const assistant = sync.session.message.list("session-1")?.[0]
+      return (
+        assistant?.type === "assistant" &&
+        assistant.content[0]?.type === "tool" &&
+        assistant.content[0].state.status === "error"
+      )
+    })
+
+    const assistant = sync.session.message.list("session-1")?.[0]
+    expect(assistant?.type).toBe("assistant")
+    if (assistant?.type !== "assistant") return
+    expect(assistant.id).toBe("msg_explicit_assistant_9")
+    const tool = assistant.content[0]
+    expect(tool?.type).toBe("tool")
+    if (tool?.type !== "tool") return
+    expect(tool.state.status).toBe("error")
+    if (tool.state.status !== "error") return
+    expect(tool.state.error).toEqual({ type: "unknown", message: "aborted" })
+    expect(tool.state.input).toEqual({})
+    expect(tool.state.structured).toEqual({})
+    expect(tool.state.content).toEqual([])
+    expect(tool.provider).toEqual({
+      executed: false,
+      metadata: { fake: { call: true } },
+      resultMetadata: { fake: { result: true } },
+    })
+    expect((sync.session.message.list("session-1") ?? []).map((message) => message.type)).toEqual([
+      "assistant",
+      "model-switched",
+      "agent-switched",
+    ])
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("renders admitted prompts only after promotion", async () => {
+  const events = createEventSource()
+  const calls = createFetch()
+  let sync!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    sync = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    emitEvent(events, {
+      id: "evt_admitted_1",
+      type: "session.next.prompt.admitted",
+      properties: {
+        sessionID: "session-1",
+        messageID: "msg_user_1",
+        timestamp: 0,
+        prompt: { text: "hello" },
+        delivery: "steer",
+      },
+    })
+    expect(sync.session.message.list("session-1") ?? []).toEqual([])
+
+    emitEvent(events, {
+      id: "evt_promoted_1",
+      type: "session.next.prompt.promoted",
+      properties: {
+        sessionID: "session-1",
+        messageID: "msg_user_1",
+        timestamp: 1,
+        prompt: { text: "hello" },
+        timeCreated: 0,
+      },
+    })
+
+    await wait(() => sync.session.message.list("session-1")?.length === 1)
+    const message = sync.session.message.list("session-1")?.[0]
+    expect(message?.type).toBe("user")
+    if (message?.type !== "user") return
+    expect(message).toMatchObject({ id: "msg_user_1", text: "hello" })
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("renders a promoted prompt when admission was missed", async () => {
+  const events = createEventSource()
+  const calls = createFetch()
+  let sync!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    sync = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    emitEvent(events, {
+      id: "evt_promoted_1",
+      type: "session.next.prompt.promoted",
+      properties: {
+        sessionID: "session-1",
+        messageID: "msg_user_1",
+        timestamp: 1,
+        prompt: { text: "hello" },
+        timeCreated: 0,
+      },
+    })
+
+    await wait(() => sync.session.message.list("session-1")?.length === 1)
+    expect(sync.session.message.list("session-1")?.[0]?.id).toBe("msg_user_1")
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("projects live context updates with their message ID", async () => {
+  const events = createEventSource()
+  const calls = createFetch()
+  let sync!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    sync = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    emitEvent(events, {
+      id: "evt_context_1",
+      type: "session.next.context.updated",
+      properties: {
+        sessionID: "session-1",
+        messageID: "msg_context_1",
+        timestamp: 1,
+        text: "Updated context",
+      },
+    })
+
+    await wait(() => sync.session.message.list("session-1")?.length === 1)
+    expect(sync.session.message.list("session-1")?.[0]).toMatchObject({
+      id: "msg_context_1",
+      type: "system",
+      text: "Updated context",
+    })
+  } finally {
+    app.renderer.destroy()
+  }
+})

packages/tui/test/cli/tui/dialog-prompt.test.tsx

@@ -0,0 +1,147 @@
+/** @jsxImportSource @opentui/solid */
+import { TextareaRenderable } from "@opentui/core"
+import { createDefaultOpenTuiKeymap } from "@opentui/keymap/opentui"
+import { testRender, useRenderer } from "@opentui/solid"
+import { expect, test } from "bun:test"
+import { mkdir } from "node:fs/promises"
+import path from "node:path"
+import { onCleanup } from "solid-js"
+import { tmpdir } from "../../fixture/fixture"
+import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
+import type { TuiKeybind } from "../../../src/config/keybind"
+import { TestTuiContexts } from "../../fixture/tui-environment"
+
+async function wait(fn: () => boolean, timeout = 2000) {
+  const start = Date.now()
+  while (!fn()) {
+    if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
+    await Bun.sleep(10)
+  }
+}
+
+async function mountPrompt(input: {
+  root: string
+  keybinds: Partial<TuiKeybind.Keybinds>
+  onConfirm: (value: string) => void
+}) {
+  const state = path.join(input.root, "state")
+  await mkdir(state, { recursive: true })
+  await Bun.write(path.join(state, "kv.json"), "{}")
+
+  const [
+    { DialogProvider },
+    { DialogPrompt },
+    { KVProvider },
+    { ThemeProvider },
+    { TuiConfigProvider },
+    { ToastProvider },
+    { OpencodeKeymapProvider, registerOpencodeKeymap },
+  ] = await Promise.all([
+    import("../../../src/ui/dialog"),
+    import("../../../src/ui/dialog-prompt"),
+    import("../../../src/context/kv"),
+    import("../../../src/context/theme"),
+    import("../../../src/config"),
+    import("../../../src/ui/toast"),
+    import("../../../src/keymap"),
+  ])
+
+  function Harness() {
+    const renderer = useRenderer()
+    const keymap = createDefaultOpenTuiKeymap(renderer)
+    const resolvedConfig = createTuiResolvedConfig({
+      keybinds: input.keybinds,
+      leader_timeout: 1000,
+    })
+    const off = registerOpencodeKeymap(keymap, renderer, resolvedConfig)
+    onCleanup(off)
+
+    return (
+      <TestTuiContexts
+        directory={input.root}
+        paths={{
+          home: input.root,
+          state,
+          worktree: input.root,
+        }}
+      >
+        <OpencodeKeymapProvider keymap={keymap}>
+          <TuiConfigProvider config={resolvedConfig}>
+            <KVProvider>
+              <ThemeProvider mode="dark">
+                <ToastProvider>
+                  <DialogProvider>
+                    <DialogPrompt title="Rename Session" value="draft" onConfirm={input.onConfirm} />
+                  </DialogProvider>
+                </ToastProvider>
+              </ThemeProvider>
+            </KVProvider>
+          </TuiConfigProvider>
+        </OpencodeKeymapProvider>
+      </TestTuiContexts>
+    )
+  }
+
+  const app = await testRender(() => <Harness />, { kittyKeyboard: true })
+  return {
+    app,
+    async cleanup() {
+      app.renderer.destroy()
+    },
+  }
+}
+
+test("dialog prompt submit wins when return is also input newline", async () => {
+  await using tmp = await tmpdir()
+  const confirmed: string[] = []
+  const prompt = await mountPrompt({
+    root: tmp.path,
+    keybinds: {
+      input_submit: "super+return",
+      input_newline: "return,shift+return,alt+return,ctrl+j",
+    },
+    onConfirm: (value) => confirmed.push(value),
+  })
+
+  try {
+    await wait(() => prompt.app.renderer.currentFocusedEditor instanceof TextareaRenderable)
+    const textarea = prompt.app.renderer.currentFocusedEditor
+    if (!(textarea instanceof TextareaRenderable)) throw new Error("expected focused dialog textarea")
+
+    prompt.app.mockInput.pressEnter()
+
+    expect(confirmed).toEqual(["draft"])
+    expect(textarea.plainText).toBe("draft")
+  } finally {
+    await prompt.cleanup()
+  }
+})
+
+test("dialog prompt submit can be rebound separately from input submit", async () => {
+  await using tmp = await tmpdir()
+  const confirmed: string[] = []
+  const prompt = await mountPrompt({
+    root: tmp.path,
+    keybinds: {
+      input_submit: "return",
+      "dialog.prompt.submit": "ctrl+y",
+    },
+    onConfirm: (value) => confirmed.push(value),
+  })
+
+  try {
+    await wait(() => prompt.app.renderer.currentFocusedEditor instanceof TextareaRenderable)
+    const textarea = prompt.app.renderer.currentFocusedEditor
+    if (!(textarea instanceof TextareaRenderable)) throw new Error("expected focused dialog textarea")
+
+    prompt.app.mockInput.pressEnter()
+    expect(confirmed).toEqual([])
+    expect(textarea.plainText).toBe("draft")
+
+    prompt.app.mockInput.pressKey("y", { ctrl: true })
+
+    expect(confirmed).toEqual(["draft"])
+  } finally {
+    await prompt.cleanup()
+  }
+})

packages/tui/test/cli/tui/diff-viewer-file-tree.test.tsx

@@ -0,0 +1,200 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, test } from "bun:test"
+import { RGBA } from "@opentui/core"
+import { testRender } from "@opentui/solid"
+import type { JSX } from "solid-js"
+import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
+import { KVProvider } from "../../../src/context/kv"
+import { ThemeProvider } from "../../../src/context/theme"
+import { TuiConfigProvider } from "../../../src/config"
+import { DiffViewerFileTree } from "../../../src/feature-plugins/system/diff-viewer-file-tree"
+import { TestTuiContexts } from "../../fixture/tui-environment"
+import {
+  allExpandedFileTreeDirectories,
+  buildFileTree,
+} from "../../../src/feature-plugins/system/diff-viewer-file-tree-utils"
+
+const theme = {
+  background: RGBA.fromHex("#000000"),
+  backgroundPanel: RGBA.fromHex("#111111"),
+  backgroundElement: RGBA.fromHex("#333333"),
+  primary: RGBA.fromHex("#00ffff"),
+  secondary: RGBA.fromHex("#0088ff"),
+  selectedListItemText: RGBA.fromHex("#ffffff"),
+  text: RGBA.fromHex("#ffffff"),
+  textMuted: RGBA.fromHex("#888888"),
+  error: RGBA.fromHex("#ff0000"),
+}
+
+describe("DiffViewerFileTree", () => {
+  test.skip("renders sorted hierarchical file rows", async () => {
+    const app = await testRender(
+      () =>
+        withTheme(() => (
+          <DiffViewerFileTree
+            width={32}
+            files={[
+              { file: "z-file.ts" },
+              { file: "b/file.ts" },
+              { file: "a/zeta.ts" },
+              { file: "b/alpha.ts" },
+              { file: "a/alpha.ts" },
+            ]}
+            loading={false}
+            error={undefined}
+            theme={theme}
+            focused={true}
+          />
+        )),
+      { width: 40, height: 20 },
+    )
+
+    try {
+      await renderOnceSettled(app)
+      const lines = visibleLines(app.captureCharFrame())
+
+      expect(lines).toEqual([
+        "▾ a",
+        "│  ├─ alpha.ts               ?",
+        "│  └─ zeta.ts                ?",
+        "├─ ▾ b",
+        "│  ├─ alpha.ts               ?",
+        "│  └─ file.ts                ?",
+      ])
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+
+  test("keeps loading and error quiet while rendering an empty settled state", async () => {
+    const loading = await renderFrame(() => (
+      <DiffViewerFileTree width={32} files={[]} loading={true} error={undefined} theme={theme} />
+    ))
+    const failed = await renderFrame(() => (
+      <DiffViewerFileTree width={32} files={[]} loading={false} error={new Error("nope")} theme={theme} />
+    ))
+    const empty = await renderFrame(() => (
+      <DiffViewerFileTree width={32} files={[]} loading={false} error={undefined} theme={theme} />
+    ))
+
+    expect(loading).not.toContain("Loading diff...")
+    expect(loading).not.toContain("No files")
+    expect(failed).not.toContain("Failed to load diff")
+    expect(failed).not.toContain("No files")
+    expect(empty).toContain("No files")
+  })
+
+  test("does not render text markers for highlighted rows", async () => {
+    const files = [{ file: "src/config/tui.ts" }, { file: "README.md" }]
+    const src = buildFileTree(files).nodes.find((node) => node.kind === "directory" && node.name === "src")!
+
+    const focused = visibleLines(
+      await renderFrame(() => (
+        <DiffViewerFileTree
+          width={32}
+          files={files}
+          loading={false}
+          error={undefined}
+          theme={theme}
+          focused
+          highlightedNode={src.id}
+        />
+      )),
+    )
+    const unfocused = visibleLines(
+      await renderFrame(() => (
+        <DiffViewerFileTree width={32} files={files} loading={false} error={undefined} theme={theme} />
+      )),
+    )
+
+    expect(focused).toContain("▾ src/config")
+    expect(unfocused).toContain("▾ src/config")
+    expect(focused.some((line) => line.includes("*"))).toBe(false)
+    expect(unfocused.some((line) => line.includes("*"))).toBe(false)
+  })
+
+  test("renders collapsed and expanded directory rows", async () => {
+    const files = [{ file: "src/config/tui.ts" }, { file: "README.md" }]
+    const tree = buildFileTree(files)
+    const src = tree.nodes.find((node) => node.kind === "directory" && node.name === "src")!
+    const collapsed = allExpandedFileTreeDirectories(tree)
+    collapsed.delete(src.id)
+
+    expect(
+      visibleLines(
+        await renderFrame(() => (
+          <DiffViewerFileTree
+            width={32}
+            files={files}
+            loading={false}
+            error={undefined}
+            theme={theme}
+            expandedNodes={collapsed}
+          />
+        )),
+      ),
+    ).toEqual(["▸ src/config"])
+
+    expect(
+      visibleLines(
+        await renderFrame(() => (
+          <DiffViewerFileTree
+            files={files}
+            width={32}
+            loading={false}
+            error={undefined}
+            theme={theme}
+            expandedNodes={allExpandedFileTreeDirectories(tree)}
+          />
+        )),
+      ),
+    ).toEqual(["▾ src/config", "│  └─ tui.ts                 ?"])
+  })
+})
+
+async function renderFrame(component: () => JSX.Element) {
+  const app = await testRender(() => withTheme(component), { width: 40, height: 10 })
+  try {
+    await renderOnceSettled(app)
+    return await captureSettledFrame(app)
+  } finally {
+    app.renderer.destroy()
+  }
+}
+
+async function renderOnceSettled(app: Awaited<ReturnType<typeof testRender>>) {
+  await app.renderOnce()
+  await new Promise((resolve) => setTimeout(resolve, 25))
+  await app.renderOnce()
+}
+
+async function captureSettledFrame(app: Awaited<ReturnType<typeof testRender>>) {
+  for (let attempt = 0; attempt < 5; attempt++) {
+    const frame = app.captureCharFrame()
+    if (frame.trim().length > 0) return frame
+    await new Promise((resolve) => setTimeout(resolve, 25))
+    await app.renderOnce()
+  }
+  return app.captureCharFrame()
+}
+
+function withTheme(component: () => JSX.Element) {
+  return (
+    <TestTuiContexts>
+      <TuiConfigProvider config={createTuiResolvedConfig()}>
+        <KVProvider>
+          <ThemeProvider mode="dark">{component()}</ThemeProvider>
+        </KVProvider>
+      </TuiConfigProvider>
+    </TestTuiContexts>
+  )
+}
+
+function visibleLines(frame: string) {
+  return frame
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .map((line) => line.replace(/^ ?│ ?/, "").replace(/[ │]*$/, ""))
+    .map((line) => (line.startsWith(" ") ? line.slice(1) : line))
+    .filter((line) => line.length > 0 && !/^┌|^└|^─+$/.test(line))
+}

packages/tui/test/cli/tui/diff-viewer.test.tsx

@@ -0,0 +1,225 @@
+/** @jsxImportSource @opentui/solid */
+import { expect, test } from "bun:test"
+import { createDefaultOpenTuiKeymap } from "@opentui/keymap/opentui"
+import type { Renderable, ScrollBoxRenderable } from "@opentui/core"
+import { testRender, useRenderer } from "@opentui/solid"
+import type { TuiPluginApi, TuiPluginMeta, TuiRouteCurrent, TuiRouteDefinition } from "@opencode-ai/plugin/tui"
+import type { Session } from "@opencode-ai/sdk/v2"
+import { KVProvider } from "../../../src/context/kv"
+import { ThemeProvider } from "../../../src/context/theme"
+import { TuiConfigProvider } from "../../../src/config"
+import { TuiKeybind } from "../../../src/config/keybind"
+import { OpencodeKeymapProvider } from "../../../src/keymap"
+import diffViewerPlugin from "../../../src/feature-plugins/system/diff-viewer"
+import { createTuiPluginApi } from "../../fixture/tui-plugin"
+import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
+import { TestTuiContexts } from "../../fixture/tui-environment"
+
+test("closing the diff viewer returns to the route it opened from", async () => {
+  const viewer = await renderDiffViewer([])
+  try {
+    expect(viewer.current()).toEqual({
+      name: "diff",
+      params: { mode: "git", sessionID: "session-1", returnRoute: startRoute },
+    })
+    expect(viewer.vcsDiffInput()).toEqual({ directory: "/repo/session", mode: "git", context: 12 })
+
+    expect(viewer.commands.has("diff.close")).toBe(true)
+    viewer.commands.get("diff.close")!.run?.({} as never)
+    expect(viewer.current()).toEqual(startRoute)
+  } finally {
+    viewer.app.renderer.destroy()
+  }
+})
+
+test("brackets navigate diff hunks", async () => {
+  const viewer = await renderDiffViewer(
+    [
+      {
+        file: "src/file.ts",
+        additions: 3,
+        deletions: 3,
+        status: "modified",
+        patch: `--- a/src/file.ts
++++ b/src/file.ts
+@@ -1,3 +1,3 @@
+ const first = true
+-const oldFirst = true
++const newFirst = true
+ const afterFirst = true
+@@ -20,3 +20,3 @@
+ const second = true
+-const oldSecond = true
++const newSecond = true
+ const afterSecond = true
+@@ -40,3 +40,3 @@
+ const third = true
+-const oldThird = true
++const newThird = true
+ const afterThird = true`,
+      },
+    ],
+    12,
+  )
+  try {
+    await viewer.app.waitForFrame((frame) => frame.includes("const first"))
+    await viewer.app.waitFor(() => Boolean(findRenderable(viewer.app.renderer.root, "diff-viewer-patches")))
+    await viewer.app.flush()
+    const scroll = findRenderable(viewer.app.renderer.root, "diff-viewer-patches") as ScrollBoxRenderable
+    const initial = scroll.scrollTop
+
+    expect(TuiKeybind.defaultValue("diff_next_hunk")).toBe("]")
+    expect(TuiKeybind.defaultValue("diff_previous_hunk")).toBe("[")
+
+    viewer.commands.get("diff.next_hunk")!.run?.({} as never)
+    await viewer.app.renderOnce()
+    const first = scroll.scrollTop
+    expect(first).toBeGreaterThan(initial)
+
+    viewer.commands.get("diff.next_hunk")!.run?.({} as never)
+    await viewer.app.renderOnce()
+    const second = scroll.scrollTop
+    expect(second).toBeGreaterThan(first)
+
+    viewer.commands.get("diff.previous_hunk")!.run?.({} as never)
+    await viewer.app.renderOnce()
+    expect(scroll.scrollTop).toBe(first)
+
+    viewer.commands.get("diff.next_hunk")!.run?.({} as never)
+    await viewer.app.renderOnce()
+    expect(scroll.scrollTop).toBe(second)
+
+    scroll.scrollTo(initial)
+    viewer.commands.get("diff.next_hunk")!.run?.({} as never)
+    await viewer.app.renderOnce()
+    expect(scroll.scrollTop).toBe(first)
+  } finally {
+    viewer.app.renderer.destroy()
+  }
+})
+
+async function renderDiffViewer(vcsDiff: unknown[], height = 20) {
+  const commands = new Map<
+    string,
+    NonNullable<Parameters<TuiPluginApi["keymap"]["registerLayer"]>[0]["commands"]>[number]
+  >()
+  let current = startRoute
+  let renderDiff: TuiRouteDefinition["render"] | undefined
+  let vcsDiffInput: unknown
+  const config = createTuiResolvedConfig()
+  function Harness() {
+    const renderer = useRenderer()
+    const keymap = createDefaultOpenTuiKeymap(renderer)
+    const registerLayer = keymap.registerLayer.bind(keymap)
+    keymap.registerLayer = (layer) => {
+      layer.commands?.forEach((command) => commands.set(command.name, command))
+      return registerLayer(layer)
+    }
+    const base = createTuiPluginApi({
+      keymap,
+      client: {
+        vcs: {
+          diff: async (input: unknown) => {
+            vcsDiffInput = input
+            return { data: vcsDiff }
+          },
+        },
+        session: { diff: async () => ({ data: [] }) },
+      } as unknown as TuiPluginApi["client"],
+      state: {
+        session: {
+          get: () => session,
+        },
+      },
+    })
+    const api = {
+      ...base,
+      route: {
+        register(routes) {
+          renderDiff = routes.find((route) => route.name === "diff")?.render
+          return () => {}
+        },
+        navigate(name, params) {
+          current = params ? { name, params } : { name }
+        },
+        get current() {
+          return current
+        },
+      },
+    } satisfies TuiPluginApi
+
+    void diffViewerPlugin.tui(api, undefined, pluginMeta)
+    commands.get("diff.open")?.run?.({} as never)
+
+    return (
+      <TestTuiContexts>
+        <OpencodeKeymapProvider keymap={keymap}>
+          <TuiConfigProvider config={config}>
+            <KVProvider>
+              <ThemeProvider mode="dark">
+                {renderDiff?.({ params: "params" in current ? current.params : undefined })}
+              </ThemeProvider>
+            </KVProvider>
+          </TuiConfigProvider>
+        </OpencodeKeymapProvider>
+      </TestTuiContexts>
+    )
+  }
+
+  const app = await testRender(() => <Harness />, { width: 80, height })
+  await waitForCommand(app, commands, "diff.close")
+  return {
+    app,
+    commands,
+    current: () => current,
+    vcsDiffInput: () => vcsDiffInput,
+  }
+}
+
+const startRoute: TuiRouteCurrent = { name: "session", params: { sessionID: "session-1" } }
+
+function findRenderable(root: Renderable, id: string): Renderable | undefined {
+  if (root.id === id) return root
+  return root
+    .getChildren()
+    .map((child) => findRenderable(child, id))
+    .find(Boolean)
+}
+
+const session = {
+  id: "session-1",
+  slug: "session-1",
+  projectID: "project-1",
+  directory: "/repo/session",
+  title: "Session",
+  version: "1",
+  time: {
+    created: 0,
+    updated: 0,
+  },
+} satisfies Session
+
+async function waitForCommand(
+  app: Awaited<ReturnType<typeof testRender>>,
+  commands: Map<string, unknown>,
+  command: string,
+) {
+  for (let attempt = 0; attempt < 10; attempt++) {
+    await app.renderOnce()
+    if (commands.has(command)) return
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+}
+
+const pluginMeta = {
+  id: "diff-viewer",
+  source: "internal",
+  spec: "diff-viewer",
+  target: "diff-viewer",
+  first_time: 0,
+  last_time: 0,
+  time_changed: 0,
+  load_count: 1,
+  fingerprint: "test",
+  state: "same",
+} satisfies TuiPluginMeta

packages/tui/test/cli/tui/inline-tool-wrap-snapshot.test.tsx

@@ -0,0 +1,304 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { createSignal, For, Show } from "solid-js"
+import type { ScrollBoxRenderable } from "@opentui/core"
+import { testRender, type JSX } from "@opentui/solid"
+import {
+  formatCompletedSubagentDetail,
+  formatSubagentRetry,
+  formatSubagentTitle,
+  formatSubagentToolcalls,
+  InlineToolRow,
+  parseApplyPatchFiles,
+  parseDiagnostics,
+  parseQuestionAnswers,
+  parseQuestions,
+  parseTodos,
+  toolDisplay,
+} from "../../../src/routes/session"
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined
+
+afterEach(() => {
+  testSetup?.renderer.destroy()
+  testSetup = undefined
+})
+
+type ToolFixture = { icon: string; label: string; error?: string }
+
+const tools: readonly ToolFixture[] = [
+  {
+    icon: "✱",
+    label:
+      'Grep "OPENCODE.*DB|database|sqlite|drizzle|dev.*db|data.*dir|xdg|APPDATA" in packages/opencode/src (151 matches)',
+  },
+  {
+    icon: "✱",
+    label: 'Glob "**/*db*" in packages/opencode (6 matches)',
+  },
+  {
+    icon: "→",
+    label: "Read packages/opencode/src/storage/db.ts [offset=1, limit=130]",
+  },
+  {
+    icon: "→",
+    label: "Read packages/opencode/src/index.ts [offset=1, limit=100]",
+    error: "No LSP server available for this file type.",
+  },
+  {
+    icon: "✱",
+    label:
+      'Grep "export const OPENCODE_DB|OPENCODE_DB|OPENCODE_DEV|Global\\.Path\\.data|data =" in packages/opencode/src (115 matches)',
+  },
+] as const
+
+function ShellOutput() {
+  return (
+    <box id="tool-block-shell" marginTop={1} paddingTop={1} paddingBottom={1} paddingLeft={2} gap={1}>
+      <text paddingLeft={3}># List files</text>
+      <box gap={1}>
+        <text>$ ls</text>
+        <text>file.ts</text>
+      </box>
+    </box>
+  )
+}
+
+function UserMessage() {
+  return (
+    <box id="message-user">
+      <box paddingTop={1} paddingBottom={1} paddingLeft={2}>
+        <text>Check whether the next tool remains separated.</text>
+      </box>
+    </box>
+  )
+}
+
+function Fixture(props: { errorExpanded?: boolean; before?: "shell" | "user" }) {
+  return (
+    <box flexDirection="column" width={72}>
+      <box flexDirection="column">
+        {props.before === "shell" && <ShellOutput />}
+        {props.before === "user" && <UserMessage />}
+        <For each={tools}>
+          {(item) => (
+            <InlineToolRow
+              icon={item.icon}
+              complete={true}
+              pending=""
+              failed={Boolean(item.error)}
+              error={item.error}
+              errorExpanded={props.errorExpanded}
+              separateAfter={(id) => id === "message-user"}
+            >
+              {item.label}
+            </InlineToolRow>
+          )}
+        </For>
+      </box>
+    </box>
+  )
+}
+
+function SubagentGroupFixture() {
+  return (
+    <box flexDirection="column" width={72}>
+      <InlineToolRow id="tool-inline-before" icon="✱" complete={true} pending="">
+        Grep "Task" (2 matches)
+      </InlineToolRow>
+      <InlineToolRow id="tool-inline-subagent-one" icon="⠙" complete={true} pending="" subagent={true}>
+        Explore Task — Inspect active task spacing
+      </InlineToolRow>
+      <InlineToolRow id="tool-inline-subagent-two" icon="✓" complete={true} pending="" subagent={true}>
+        {"General Task — Confirm completed task spacing\n↳ 1 toolcall · 501ms"}
+      </InlineToolRow>
+      <InlineToolRow id="tool-inline-after" icon="→" complete={true} pending="">
+        Read src/cli/cmd/tui/routes/session/index.tsx
+      </InlineToolRow>
+    </box>
+  )
+}
+
+function LoadedReadBeforeSubagentFixture() {
+  return (
+    <box flexDirection="column" width={72}>
+      <InlineToolRow id="tool-inline-read" icon="→" complete={true} pending="">
+        Read src/cli/cmd/tui/routes/session/index.tsx
+      </InlineToolRow>
+      <box id="tool-inline-loaded-read-child" paddingLeft={3}>
+        <text paddingLeft={3}>↳ Loaded src/cli/cmd/tui/routes/session/tools.tsx</text>
+      </box>
+      <InlineToolRow id="tool-inline-subagent-after-read" icon="✓" complete={true} pending="" subagent={true}>
+        {"Explore Task — Inspect active task spacing\n↳ 1 toolcall · 501ms"}
+      </InlineToolRow>
+    </box>
+  )
+}
+
+function StickyScrollFixture(props: { separated: boolean; scroll: (scroll: ScrollBoxRenderable) => void }) {
+  return (
+    <scrollbox ref={props.scroll} stickyScroll={true} stickyStart="bottom" height={3} width={72}>
+      <box height={1}>
+        <text>First row</text>
+      </box>
+      <box height={1}>
+        <text>Second row</text>
+      </box>
+      <Show when={props.separated}>
+        <box id="text-before-tool">
+          <text>Assistant text</text>
+        </box>
+      </Show>
+      <InlineToolRow icon="→" complete={true} pending="">
+        Read src/cli/cmd/tui/routes/session/index.tsx
+      </InlineToolRow>
+    </scrollbox>
+  )
+}
+
+function FailedPendingToolFixture() {
+  return (
+    <InlineToolRow icon="%" complete={false} pending="Preparing patch..." failed={true} failure="Patch failed">
+      Patch
+    </InlineToolRow>
+  )
+}
+
+function FailedCompleteToolFixture() {
+  return (
+    <InlineToolRow icon="→" complete={true} pending="Reading file..." failed={true} failure="Read failed">
+      Read src/index.ts
+    </InlineToolRow>
+  )
+}
+
+async function renderFrame(component: () => JSX.Element, options: { width: number; height: number }) {
+  testSetup = await testRender(component, options)
+  await testSetup.renderOnce()
+
+  return testSetup
+    .captureCharFrame()
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .join("\n")
+    .trimEnd()
+}
+
+describe("TUI inline tool wrapping", () => {
+  test("falls back for unknown tool names", () => {
+    expect(toolDisplay("bash")).toBe("bash")
+    expect(toolDisplay("plugin_tool")).toBe("generic")
+  })
+
+  test("replaces pending copy when a tool fails before completion", async () => {
+    const frame = await renderFrame(() => <FailedPendingToolFixture />, { width: 72, height: 3 })
+    expect(frame).toContain("Patch failed")
+    expect(frame).not.toContain("Preparing patch")
+  })
+
+  test("preserves useful completed copy when a tool fails", async () => {
+    const frame = await renderFrame(() => <FailedCompleteToolFixture />, { width: 72, height: 3 })
+    expect(frame).toContain("Read src/index.ts")
+    expect(frame).not.toContain("Read failed")
+  })
+
+  test("filters malformed nested tool wire data", () => {
+    expect(
+      parseApplyPatchFiles([
+        null,
+        { type: "add" },
+        { type: "add", relativePath: "a.ts", filePath: "a.ts", patch: "diff", deletions: 0 },
+      ]),
+    ).toEqual([
+      { type: "add", relativePath: "a.ts", filePath: "a.ts", patch: "diff", deletions: 0, movePath: undefined },
+    ])
+    expect(parseTodos([null, { status: "pending" }, { status: "pending", content: "Safe" }])).toEqual([
+      { status: "pending", content: "Safe" },
+    ])
+    expect(parseQuestions([{}, { question: 1 }, { question: "Continue?" }])).toEqual([{ question: "Continue?" }])
+    expect(parseQuestionAnswers([null, ["yes", 1], "no"])).toEqual([[], ["yes"], []])
+    expect(parseQuestionAnswers({})).toBeUndefined()
+  })
+
+  test("ignores diagnostics with malformed nested ranges", () => {
+    expect(
+      parseDiagnostics(
+        {
+          "a.ts": [
+            { severity: 1, message: "missing range" },
+            { severity: 1, message: "bad line", range: { start: { line: "0", character: 1 } } },
+            { severity: 1, message: "valid", range: { start: { line: 2, character: 3 } } },
+          ],
+        },
+        "a.ts",
+      ),
+    ).toEqual([{ message: "valid", range: { start: { line: 2, character: 3 } } }])
+  })
+
+  test("formats completed subagent toolcall details", () => {
+    expect(formatCompletedSubagentDetail(0, "501ms")).toBe("501ms")
+    expect(formatCompletedSubagentDetail(1, "501ms")).toBe("1 toolcall · 501ms")
+    expect(formatCompletedSubagentDetail(2, "501ms")).toBe("2 toolcalls · 501ms")
+    expect(formatSubagentToolcalls(0)).toBe("0 toolcalls")
+  })
+
+  test("keeps background state attached to the subagent identity", () => {
+    expect(formatSubagentTitle("Explore", "Inspect renderer", false)).toBe("Explore Task — Inspect renderer")
+    expect(formatSubagentTitle("Explore", "Inspect renderer", true)).toBe(
+      "Explore Task (background) — Inspect renderer",
+    )
+  })
+
+  test("keeps retry status ahead of wrapping messages", () => {
+    expect(formatSubagentRetry(2, "Rate limited by provider")).toBe("Retrying (attempt 2) · Rate limited by provider")
+  })
+
+  test("snapshots consecutive grep, glob, and read rows at a narrow width", async () => {
+    expect(await renderFrame(() => <Fixture />, { width: 72, height: 12 })).toMatchSnapshot()
+  })
+
+  test("snapshots expanded tool errors under the tool text", async () => {
+    expect(await renderFrame(() => <Fixture errorExpanded />, { width: 72, height: 12 })).toMatchSnapshot()
+  })
+
+  test("keeps separation after a shell output block", async () => {
+    expect(await renderFrame(() => <Fixture before="shell" />, { width: 72, height: 16 })).toMatchSnapshot()
+  })
+
+  test("keeps separation after a padded user message", async () => {
+    expect(await renderFrame(() => <Fixture before="user" />, { width: 72, height: 14 })).toMatchSnapshot()
+  })
+
+  test("separates a contiguous subagent group from inline tools", async () => {
+    expect(await renderFrame(() => <SubagentGroupFixture />, { width: 72, height: 10 })).toMatchSnapshot()
+  })
+
+  test("separates a subagent group after an expanded read", async () => {
+    expect(await renderFrame(() => <LoadedReadBeforeSubagentFixture />, { width: 72, height: 8 })).toMatchSnapshot()
+  })
+
+  test("updates sticky-bottom geometry when a text separator mounts and unmounts", async () => {
+    const [separated, setSeparated] = createSignal(false)
+    let scroll: ScrollBoxRenderable | undefined
+    testSetup = await testRender(
+      () => <StickyScrollFixture separated={separated()} scroll={(value) => (scroll = value)} />,
+      {
+        width: 72,
+        height: 3,
+      },
+    )
+
+    await testSetup.renderOnce()
+    expect(scroll?.scrollHeight).toBe(3)
+    expect(scroll?.scrollTop).toBe(Math.max(0, scroll!.scrollHeight - scroll!.viewport.height))
+
+    setSeparated(true)
+    await testSetup.renderOnce()
+    expect(scroll?.scrollHeight).toBe(5)
+    expect(scroll?.scrollTop).toBe(Math.max(0, scroll!.scrollHeight - scroll!.viewport.height))
+
+    setSeparated(false)
+    await testSetup.renderOnce()
+    expect(scroll?.scrollHeight).toBe(3)
+    expect(scroll?.scrollTop).toBe(Math.max(0, scroll!.scrollHeight - scroll!.viewport.height))
+  })
+})

packages/tui/test/cli/tui/prompt-submit-race.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test"
+
+// Regression test for the prompt submit race in
+// packages/tui/src/component/prompt/index.tsx (`submit`).
+//
+// Before the fix, two concurrent `submit()` calls (e.g. a double-pressed
+// Enter, or the input's native onSubmit racing another dispatch) each
+// passed the `if (!store.prompt.input) return false` guard, each
+// `await sdk.client.session.create(...)`, and each only captured
+// `inputText = store.prompt.input` AFTER that await. The first invocation
+// finished, sent the prompt, and cleared the store; the second invocation,
+// now past its await, read the cleared store and sent an empty prompt to a
+// second freshly-created session - leaving an orphaned session with the
+// user's actual text and a phantom session visible to the user containing
+// only an assistant reply.
+//
+// `submitMirror` below has the exact shape of the production `submit()`
+// after the fix: an in-flight `submitting` guard wraps the original body.
+// Two concurrent invocations must result in exactly one submission carrying
+// the user's text, with no empty-text submission.
+
+type Store = { input: string }
+
+type SubmitResult = { sessionID: string; text: string }
+
+type Harness = {
+  store: Store
+  submissions: SubmitResult[]
+  createSession(): Promise<string>
+  sendPrompt(sessionID: string, text: string): Promise<void>
+}
+
+function createHarness(opts: { sessionCreateDelayMs: number }): Harness {
+  let sessionCounter = 0
+  const submissions: SubmitResult[] = []
+
+  return {
+    store: { input: "" },
+    submissions,
+    async createSession() {
+      sessionCounter += 1
+      const id = `ses_${sessionCounter}`
+      await Bun.sleep(opts.sessionCreateDelayMs)
+      return id
+    },
+    async sendPrompt(sessionID, text) {
+      submissions.push({ sessionID, text })
+    },
+  }
+}
+
+function createSubmit() {
+  let submitting = false
+  return async function submit(h: Harness) {
+    if (submitting) return false
+    submitting = true
+    try {
+      if (!h.store.input) return false
+      const sessionID = await h.createSession()
+      const inputText = h.store.input
+      await h.sendPrompt(sessionID, inputText)
+      h.store.input = ""
+      return true
+    } finally {
+      submitting = false
+    }
+  }
+}
+
+describe("Prompt.submit race", () => {
+  test("concurrent submits must not lose the user's text", async () => {
+    const submit = createSubmit()
+    const h = createHarness({ sessionCreateDelayMs: 5 })
+    h.store.input = "Hello there."
+
+    // Two invocations back-to-back, mimicking a double-Enter.
+    await Promise.all([submit(h), submit(h)])
+
+    // Every submission that did make it through must carry the actual user
+    // text, and no submission may have an empty text payload.
+    expect(h.submissions.every((s) => s.text === "Hello there.")).toBe(true)
+    expect(h.submissions.some((s) => s.text === "")).toBe(false)
+  })
+
+  test("a sequential second submit after clear is a no-op, not a phantom session", async () => {
+    const submit = createSubmit()
+    const h = createHarness({ sessionCreateDelayMs: 1 })
+    h.store.input = "Hello there."
+
+    await submit(h)
+    // After the first submission completes, the store is cleared; a second
+    // Enter on an empty input must not create a phantom session.
+    await submit(h)
+
+    expect(h.submissions).toHaveLength(1)
+    expect(h.submissions[0].text).toBe("Hello there.")
+  })
+})

packages/tui/test/cli/tui/thinking.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test"
+import { reasoningSummary } from "../../../src/context/thinking"
+
+describe("reasoningSummary", () => {
+  test("extracts a leading summary title and leaves markdown body", () => {
+    expect(reasoningSummary("**Continuing Quality Review**\n\nDetails.\n\n**Next section**\n\nMore.")).toEqual({
+      title: "Continuing Quality Review",
+      body: "Details.\n\n**Next section**\n\nMore.",
+    })
+  })
+
+  test("extracts a completed title before its streamed body arrives", () => {
+    expect(reasoningSummary("**Continuing Quality Review**")).toEqual({
+      title: "Continuing Quality Review",
+      body: "",
+    })
+  })
+
+  test("preserves markdown-significant indentation in the extracted body", () => {
+    expect(reasoningSummary("**Continuing Quality Review**\n\n    const value = true\n")).toEqual({
+      title: "Continuing Quality Review",
+      body: "    const value = true",
+    })
+  })
+
+  test("does not consume ordinary leading bold content", () => {
+    expect(reasoningSummary("**Important:** keep this in the body.")).toEqual({
+      title: null,
+      body: "**Important:** keep this in the body.",
+    })
+  })
+
+  test("leaves content without a leading title in its body", () => {
+    expect(reasoningSummary("Details only.")).toEqual({ title: null, body: "Details only." })
+  })
+})

packages/tui/test/cli/tui/use-event.test.tsx

@@ -0,0 +1,148 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, test } from "bun:test"
+import { testRender } from "@opentui/solid"
+import type { Event, GlobalEvent } from "@opencode-ai/sdk/v2"
+import { onMount } from "solid-js"
+import { ProjectProvider, useProject } from "../../../src/context/project"
+import { SDKProvider } from "../../../src/context/sdk"
+import { useEvent } from "../../../src/context/event"
+import { createEventSource, createFetch, directory } from "../../fixture/tui-sdk"
+import { TestTuiContexts } from "../../fixture/tui-environment"
+
+const projectID = "proj_test"
+
+async function wait(fn: () => boolean, timeout = 2000) {
+  const start = Date.now()
+  while (!fn()) {
+    if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
+    await Bun.sleep(10)
+  }
+}
+
+function event(payload: Event, input: { directory: string; project?: string; workspace?: string }): GlobalEvent {
+  return {
+    directory: input.directory,
+    project: input.project,
+    workspace: input.workspace,
+    payload,
+  }
+}
+
+function vcs(branch: string): Event {
+  return {
+    id: `evt_vcs_${branch}`,
+    type: "vcs.branch.updated",
+    properties: {
+      branch,
+    },
+  }
+}
+
+function update(version: string): Event {
+  return {
+    id: `evt_update_${version}`,
+    type: "installation.update-available",
+    properties: {
+      version,
+    },
+  }
+}
+
+async function mount() {
+  const events = createEventSource()
+  const calls = createFetch()
+  const seen: Event[] = []
+  const workspaces: Array<string | undefined> = []
+  let project!: ReturnType<typeof useProject>
+  let done!: () => void
+  const ready = new Promise<void>((resolve) => {
+    done = resolve
+  })
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <Probe
+            onReady={async (ctx) => {
+              project = ctx.project
+              await project.sync()
+              done()
+            }}
+            seen={seen}
+            workspaces={workspaces}
+          />
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  await ready
+  return { app, emit: events.emit, project, seen, workspaces }
+}
+
+function Probe(props: {
+  seen: Event[]
+  workspaces: Array<string | undefined>
+  onReady: (ctx: { project: ReturnType<typeof useProject> }) => void
+}) {
+  const project = useProject()
+  const event = useEvent()
+
+  onMount(() => {
+    event.subscribe((evt, { workspace }) => {
+      props.seen.push(evt)
+      props.workspaces.push(workspace)
+    })
+    props.onReady({ project })
+  })
+
+  return <box />
+}
+
+describe("useEvent", () => {
+  test("delivers events for the current project", async () => {
+    const { app, emit, seen, workspaces } = await mount()
+
+    try {
+      emit(event(vcs("main"), { directory: "/tmp/other", project: projectID, workspace: "ws_a" }))
+
+      await wait(() => seen.length === 1)
+
+      expect(seen).toEqual([vcs("main")])
+      expect(workspaces).toEqual(["ws_a"])
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+
+  test("delivers current project events regardless of active workspace", async () => {
+    const { app, emit, project, seen } = await mount()
+
+    try {
+      project.workspace.set("ws_a")
+      emit(event(vcs("ws"), { directory: "/tmp/other", project: projectID, workspace: "ws_b" }))
+
+      await wait(() => seen.length === 1)
+
+      expect(seen).toEqual([vcs("ws")])
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+
+  test("delivers truly global events even when a workspace is active", async () => {
+    const { app, emit, project, seen } = await mount()
+
+    try {
+      project.workspace.set("ws_a")
+      emit(event(update("1.2.3"), { directory: "global" }))
+
+      await wait(() => seen.length === 1)
+
+      expect(seen).toEqual([update("1.2.3")])
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+})