test(opencode): expect empty response retry

fix(opencode): retry empty unknown responses
2026-08-05 01:18:50 +00:00 · 2026-08-04 23:13:23 +00:00 · 2026-08-04 22:52:01 +00:00
71 changed files with 453 additions and 2256 deletions
@@ -56,32 +56,6 @@ Benchmarks do not assert machine-dependent performance budgets. Streaming proces

 Committed smoke and regression tests continue to own correctness coverage for pagination, tab paint, context resize, collapse state, and composer spacing.

-## Desktop profiler
-
-The desktop profiler launches the existing production build directly, creates isolated desktop state, chooses an available CDP port, and writes reports under the OS temporary directory by default.
-
-```sh
-bun run profile:desktop --help
-```
-
-Create a private partial snapshot from the default local database and run Home once:
-
-```sh
-bun run profile:desktop --partial-snapshot-out /tmp/opencode-perf.db \
-  --window-end 2026-08-04T06:14:26.878Z \
-  --scenarios home,calibration --skip-build
-```
-
-Repeat against the immutable partial snapshot:
-
-```sh
-bun run profile:desktop --mode partial-snapshot --db /tmp/opencode-perf.db \
-  --window-end 2026-08-04T06:14:26.878Z \
-  --scenarios home,calibration --runs 3 --skip-build
-```
-
-Partial snapshots contain private application data and must not be committed or shared. The profiler copies each partial snapshot to a per-run working database and remaps selected project paths to temporary workspaces, leaving the source snapshot unchanged. `PROFILE_SUMMARY` is the compact comparison output; `PROFILE_REPORT` points to the complete JSON report with the database hash, invocation parameters, raw runs, and attribution data.
-
 ## Chrome traces

 Set `OPENCODE_PERFORMANCE_TRACE_DIR` to emit a standard Chrome DevTools trace for every benchmark page automatically:
@@ -1,137 +0,0 @@
-import { Database } from "bun:sqlite"
-import { mkdir, rm } from "node:fs/promises"
-import path from "node:path"
-import { progress } from "./progress"
-import type { Options, Target } from "./types"
-
-export async function createPartialSnapshot(source: string, destination: string, options: Options, targets: Target[]) {
-  await mkdir(path.dirname(destination), { recursive: true })
-  await rm(destination, { force: true })
-  const input = new Database(source, { readonly: true })
-  const schema = input
-    .query(
-      `SELECT type, name, sql FROM sqlite_schema
-       WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%'
-       ORDER BY CASE type WHEN 'table' THEN 0 WHEN 'index' THEN 1 ELSE 2 END, name`,
-    )
-    .all() as { type: string; name: string; sql: string }[]
-  input.close()
-
-  const output = new Database(destination, { create: true })
-  output.run("PRAGMA foreign_keys = OFF")
-  schema.filter((item) => item.type === "table").forEach((item) => output.run(item.sql))
-  output.run("ATTACH DATABASE ? AS source", source)
-  const selected = [...new Set(targets.map((target) => target.id))]
-  const placeholders = selected.map(() => "?").join(",")
-
-  for (const table of schema.filter((item) => item.type === "table").map((item) => item.name)) {
-    progress("copying partial snapshot table", { table })
-    if (table === "event") continue
-    if (table === "message") {
-      output.run(
-        `INSERT INTO main.message SELECT * FROM source.message
-         WHERE (time_created >= ? AND time_created < ? AND session_id IN (
-           SELECT id FROM source.session WHERE parent_id IS NULL
-         )) OR session_id IN (${placeholders})`,
-        options.windowStart,
-        options.windowEnd,
-        ...selected,
-      )
-      continue
-    }
-    if (table === "part") {
-      output.run("INSERT INTO main.part SELECT * FROM source.part WHERE message_id IN (SELECT id FROM main.message)")
-      continue
-    }
-    if (["session_context_epoch", "session_input", "session_message", "session_share", "todo"].includes(table)) {
-      output.run(
-        `INSERT INTO main."${table}" SELECT * FROM source."${table}" WHERE session_id IN (${placeholders})`,
-        ...selected,
-      )
-      continue
-    }
-    output.run(`INSERT INTO main."${table}" SELECT * FROM source."${table}"`)
-  }
-  output.run("DETACH DATABASE source")
-  schema.filter((item) => item.type !== "table").forEach((item) => output.run(item.sql))
-  output.close()
-}
-
-export async function fingerprint(file: string) {
-  const input = Bun.file(file)
-  const hasher = new Bun.CryptoHasher("sha256")
-  for await (const chunk of input.stream()) hasher.update(chunk)
-  return { bytes: input.size, sha256: hasher.digest("hex") }
-}
-
-export function loadCorpus(options: Options) {
-  const database = new Database(options.database, { readonly: true })
-  database.run("PRAGMA query_only = ON")
-  const sessions = database
-    .query(
-      `SELECT id, project_id AS projectID, directory, title
-       FROM session AS candidate
-       WHERE parent_id IS NULL
-         AND EXISTS (
-           SELECT 1 FROM message
-           WHERE session_id = candidate.id AND time_created >= ? AND time_created < ?
-         )`,
-    )
-    .all(options.windowStart, options.windowEnd) as { id: string; projectID: string; directory: string; title: string }[]
-  const messageRows = database.query(
-    `SELECT id, data FROM message
-     WHERE session_id = ? AND time_created >= ? AND time_created < ?
-     ORDER BY time_created, id`,
-  )
-  const partRows = database.query(`SELECT data FROM part WHERE message_id = ? ORDER BY id`)
-  const ranked = sessions
-    .map((session) => {
-      const messages = messageRows.all(session.id, options.windowStart, options.windowEnd) as {
-        id: string
-        data: string
-      }[]
-      const parts = messages.flatMap((message) => partRows.all(message.id) as { data: string }[])
-      return {
-        ...session,
-        bytes:
-          messages.reduce((sum, message) => sum + Buffer.byteLength(message.data), 0) +
-          parts.reduce((sum, part) => sum + Buffer.byteLength(part.data), 0),
-        messages: messages.length,
-        parts: parts.length,
-        userTurns: messages.filter((message) => JSON.parse(message.data).role === "user").length,
-      }
-    })
-    .filter((session) => session.messages > 0)
-    .sort((a, b) => a.bytes - b.bytes || a.id.localeCompare(b.id))
-  if (ranked.length === 0) throw new Error("No sessions found in the profile window")
-  const select = (label: Target["label"], percentile: number) => ({
-    label,
-    ...ranked[Math.max(0, Math.ceil(ranked.length * percentile) - 1)]!,
-  })
-  const targets = [select("p50", 0.5), select("p95", 0.95), select("max", 1)] satisfies Target[]
-  const typingText = loadTypingText(database, partRows, messageRows, targets[2]!, options)
-  const projectIDs = [...new Set(ranked.map((session) => session.projectID))]
-  database.close()
-  return { targets, typingText, projectIDs }
-}
-
-function loadTypingText(
-  database: Database,
-  partRows: ReturnType<Database["query"]>,
-  messageRows: ReturnType<Database["query"]>,
-  target: Target,
-  options: Options,
-) {
-  const messages = messageRows.all(target.id, options.windowStart, options.windowEnd) as { id: string; data: string }[]
-  const text = messages
-    .filter((message) => JSON.parse(message.data).role === "user")
-    .flatMap((message) =>
-      (partRows.all(message.id) as { data: string }[]).flatMap((part) => {
-        const data = JSON.parse(part.data)
-        return data.type === "text" && typeof data.text === "string" ? [data.text] : []
-      }),
-    )
-    .sort((a, b) => b.length - a.length)[0]
-  if (!text) throw new Error("No real user prompt found for composer profiling")
-  return text
-}
@@ -1,116 +0,0 @@
-import { Database } from "bun:sqlite"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-import type { Options } from "./types"
-
-export async function prepareDesktopState(
-  options: Options,
-  databasePath: string,
-  userData: string,
-  run: number,
-  projectIDs: string[],
-) {
-  const database = new Database(databasePath)
-  const projects = database.query("SELECT id, worktree, sandboxes FROM project ORDER BY id").all() as {
-    id: string
-    worktree: string
-    sandboxes: string
-  }[]
-  const selected = new Set(projectIDs)
-  const profileProjects = projects.filter((project) => selected.has(project.id))
-  const worktrees =
-    options.mode === "partial-snapshot"
-      ? await remapDirectories(database, profileProjects, path.join(options.output, "workspaces", String(run)))
-      : profileProjects.map((project) => project.worktree)
-  database.close()
-
-  await Bun.write(
-    path.join(userData, "opencode.settings"),
-    JSON.stringify({ firstLaunchOnboardingComplete: true, oldLayoutEligible: true, tauriMigrated: true }),
-  )
-  await Bun.write(
-    path.join(userData, "opencode.global.dat"),
-    JSON.stringify({
-      server: JSON.stringify({
-        list: [],
-        projects: { local: worktrees.map((worktree) => ({ worktree, expanded: true })) },
-        lastProject: worktrees[0] ? { local: worktrees[0] } : {},
-        recentlyClosed: {},
-      }),
-    }),
-  )
-}
-
-async function remapDirectories(
-  database: Database,
-  projects: { id: string; worktree: string; sandboxes: string }[],
-  root: string,
-) {
-  await mkdir(root, { recursive: true })
-  const mappings = new Map<string, string>()
-  const worktrees = await Promise.all(
-    projects.map(async (project, index) => {
-      const worktree = path.join(root, `project-${String(index + 1).padStart(3, "0")}`)
-      await mkdir(worktree, { recursive: true })
-      mappings.set(project.worktree, worktree)
-      const sandboxes = JSON.parse(project.sandboxes) as string[]
-      const nextSandboxes = await Promise.all(
-        sandboxes.map(async (sandbox, sandboxIndex) => {
-          const next = path.join(worktree, `sandbox-${sandboxIndex + 1}`)
-          await mkdir(next, { recursive: true })
-          mappings.set(sandbox, next)
-          return next
-        }),
-      )
-      database.run("UPDATE project SET worktree = ?, sandboxes = ? WHERE id = ?", worktree, JSON.stringify(nextSandboxes), project.id)
-      return worktree
-    }),
-  )
-  const byProject = new Map(projects.map((project, index) => [project.id, worktrees[index]!]))
-  const sessions = database.query("SELECT id, project_id, directory FROM session").all() as {
-    id: string
-    project_id: string
-    directory: string
-  }[]
-  const directories = database.query("SELECT * FROM project_directory").all() as {
-    project_id: string
-    directory: string
-    type: string | null
-    strategy: string | null
-    time_created: number
-  }[]
-  const selected = new Set(projects.map((project) => project.id))
-  const nextDirectories = await Promise.all(
-    directories.filter((item) => selected.has(item.project_id)).map(async (item, index) => {
-      const directory =
-        mappings.get(item.directory) ?? path.join(byProject.get(item.project_id) ?? root, `directory-${index + 1}`)
-      await mkdir(directory, { recursive: true })
-      return { ...item, directory }
-    }),
-  )
-  database.transaction(() => {
-    sessions.filter((session) => selected.has(session.project_id)).forEach((session) =>
-      database.run(
-        "UPDATE session SET directory = ? WHERE id = ?",
-        mappings.get(session.directory) ?? byProject.get(session.project_id) ?? worktrees[0]!,
-        session.id,
-      ),
-    )
-    database.run(
-      `DELETE FROM project_directory WHERE project_id IN (${projects.map(() => "?").join(",")})`,
-      ...projects.map((project) => project.id),
-    )
-    nextDirectories.forEach((item) =>
-      database.run(
-        `INSERT INTO project_directory (project_id, directory, type, strategy, time_created)
-         VALUES (?, ?, ?, ?, ?)`,
-        item.project_id,
-        item.directory,
-        item.type,
-        item.strategy,
-        item.time_created,
-      ),
-    )
-  })()
-  return worktrees
-}
@@ -1,54 +0,0 @@
-import { Database } from "bun:sqlite"
-import { afterAll, expect, test } from "bun:test"
-import { mkdir, rm } from "node:fs/promises"
-import path from "node:path"
-import { createPartialSnapshot, fingerprint } from "./corpus"
-import { parseOptions } from "./options"
-
-const directory = path.join(import.meta.dir, `.tmp-${process.pid}`)
-const source = path.join(directory, "source.db")
-const partialSnapshot = path.join(directory, "partial-snapshot.db")
-await mkdir(directory, { recursive: true })
-const database = new Database(source, { create: true })
-database.run("CREATE TABLE sample (value TEXT NOT NULL)")
-database.run("INSERT INTO sample VALUES ('repeatable')")
-database.close()
-
-afterAll(() => rm(directory, { recursive: true, force: true }))
-
-test("parses a portable fixed-window partial snapshot invocation", () => {
-  const options = parseOptions([
-    "--mode",
-    "partial-snapshot",
-    "--db",
-    source,
-    "--window-end",
-    "2026-08-04T06:14:26.878Z",
-    "--window-hours",
-    "24",
-    "--scenarios",
-    "home,calibration",
-    "--runs",
-    "3",
-    "--skip-build",
-  ])!
-
-  expect(options.database).toBe(source)
-  expect(options.windowEnd).toBe(1_785_824_066_878)
-  expect(options.windowStart).toBe(1_785_737_666_878)
-  expect(options.scenarios).toEqual(["home", "calibration"])
-  expect(options.runs).toBe(3)
-  expect(options.build).toBe(false)
-})
-
-test("creates a consistent private partial database snapshot", async () => {
-  const options = parseOptions(["--db", source, "--window-end", "2026-08-04T06:14:26.878Z"])!
-  await createPartialSnapshot(source, partialSnapshot, options, [])
-  const copy = new Database(partialSnapshot, { readonly: true })
-  expect(copy.query("SELECT value FROM sample").get()).toEqual({ value: "repeatable" })
-  copy.close()
-  expect(await fingerprint(partialSnapshot)).toEqual({
-    bytes: expect.any(Number),
-    sha256: expect.stringMatching(/^[a-f0-9]{64}$/),
-  })
-})
@@ -1,88 +0,0 @@
-import { Global } from "@opencode-ai/core/global"
-import { existsSync } from "node:fs"
-import { tmpdir } from "node:os"
-import path from "node:path"
-import { scenarios, type Options, type Scenario } from "./types"
-
-const help = `Desktop renderer profiler
-
-Usage:
-  bun run profile:desktop [options]
-
-Options:
-  --mode local|partial-snapshot
-                                Local corpus or fixed partial snapshot (default: local)
-  --db <path>                  SQLite database (default: opencode data directory)
-  --partial-snapshot-out <path>
-                                Copy the benchmark corpus to a private partial snapshot
-  --output <directory>         Report directory (default: OS temp directory)
-  --window-end <ISO|epoch>     End of corpus window (default: now; required for partial snapshot)
-  --window-hours <hours>       Corpus window size (default: 24)
-  --scenarios <names>          Comma list: ${scenarios.join(",")} (default: all)
-  --runs <count>               Restart Electron and repeat (default: 1)
-  --skip-build                 Use the existing desktop production build
-  --diagnostics                Capture Chrome traces
-  --cpu                        Capture sampled CPU summaries
-  --response-urls              Attribute Response.text durations by URL
-  --help                       Show this message
-
-Partial snapshots contain private application data. Do not commit or share them.
-`
-
-export function parseOptions(args: string[], now = Date.now()): Options | undefined {
-  if (args.includes("--help")) {
-    console.log(help)
-    return
-  }
-
-  const value = (name: string) => {
-    const index = args.indexOf(name)
-    if (index === -1) return
-    const result = args[index + 1]
-    if (!result || result.startsWith("--")) throw new Error(`${name} requires a value`)
-    return result
-  }
-  const mode = value("--mode") ?? "local"
-  if (mode !== "local" && mode !== "partial-snapshot") throw new Error(`Unsupported mode: ${mode}`)
-  const endValue = value("--window-end")
-  if (mode === "partial-snapshot" && !endValue)
-    throw new Error("--window-end is required in partial-snapshot mode")
-  const windowEnd = endValue ? parseTime(endValue) : now
-  const windowHours = number(value("--window-hours") ?? "24", "--window-hours")
-  const selected = (value("--scenarios")?.split(",") ?? [...scenarios]).map((item) => item.trim())
-  if (selected.some((item) => !scenarios.includes(item as Scenario)))
-    throw new Error(`--scenarios must contain only: ${scenarios.join(", ")}`)
-  const database = path.resolve(value("--db") ?? path.join(Global.Path.data, "opencode.db"))
-  if (!existsSync(database)) throw new Error(`Database does not exist: ${database}`)
-
-  return {
-    mode,
-    database,
-    output: path.resolve(
-      value("--output") ?? path.join(tmpdir(), "opencode-performance", new Date(windowEnd).toISOString().replace(/[:.]/g, "-")),
-    ),
-    windowStart: windowEnd - windowHours * 60 * 60 * 1_000,
-    windowEnd,
-    scenarios: selected as Scenario[],
-    runs: number(value("--runs") ?? "1", "--runs"),
-    build: !args.includes("--skip-build"),
-    diagnostics: args.includes("--diagnostics"),
-    cpu: args.includes("--cpu"),
-    responseURLs: args.includes("--response-urls"),
-    partialSnapshotOut: value("--partial-snapshot-out")
-      ? path.resolve(value("--partial-snapshot-out")!)
-      : undefined,
-  }
-}
-
-function parseTime(value: string) {
-  const result = /^\d+$/.test(value) ? Number(value) : Date.parse(value)
-  if (!Number.isFinite(result)) throw new Error(`Invalid --window-end: ${value}`)
-  return result
-}
-
-function number(value: string, option: string) {
-  const result = Number(value)
-  if (!Number.isFinite(result) || result <= 0) throw new Error(`${option} must be greater than zero`)
-  return result
-}
@@ -1,192 +0,0 @@
-import type { Page } from "@playwright/test"
-import type { Options, ProbeResult } from "./types"
-
-export async function installProbe(page: Page, options: Options) {
-  await page.addInitScript((attributeResponses) => {
-    const state = {
-      longTasks: [] as number[],
-      animationFrames: [] as ProbeResult["animationFrames"],
-      frameGaps: [] as number[],
-      responseText: [] as ProbeResult["responseText"],
-    }
-    ;(window as Window & { __opencodeRendererProfile?: typeof state }).__opencodeRendererProfile = state
-    if (PerformanceObserver.supportedEntryTypes.includes("longtask")) {
-      new PerformanceObserver((list) =>
-        state.longTasks.push(...list.getEntries().map((entry) => entry.duration)),
-      ).observe({ type: "longtask" })
-    }
-    if (PerformanceObserver.supportedEntryTypes.includes("long-animation-frame")) {
-      new PerformanceObserver((list) =>
-        state.animationFrames.push(
-          ...list.getEntries().map((entry) => {
-            const frame = entry as PerformanceEntry & {
-              blockingDuration: number
-              scripts?: {
-                duration: number
-                forcedStyleAndLayoutDuration?: number
-                sourceFunctionName?: string
-                sourceURL?: string
-                sourceCharPosition?: number
-                invoker?: string
-                invokerType?: string
-              }[]
-            }
-            return {
-              duration: frame.duration,
-              blockingDuration: frame.blockingDuration,
-              forcedStyleAndLayoutDuration:
-                frame.scripts?.reduce((sum, script) => sum + (script.forcedStyleAndLayoutDuration ?? 0), 0) ?? 0,
-              scripts:
-                frame.scripts?.map((script) => ({
-                  function: script.sourceFunctionName || "(anonymous)",
-                  source: script.sourceURL?.split("/").at(-1) || "(document)",
-                  position: script.sourceCharPosition ?? -1,
-                  invoker: script.invoker ?? "(unknown)",
-                  invokerType: script.invokerType ?? "(unknown)",
-                  duration: script.duration,
-                  forcedStyleAndLayoutDuration: script.forcedStyleAndLayoutDuration ?? 0,
-                })) ?? [],
-            }
-          }),
-        ),
-      ).observe({ type: "long-animation-frame" })
-    }
-    let previous = performance.now()
-    const frame = (now: number) => {
-      const gap = now - previous
-      if (gap > 20) state.frameGaps.push(gap)
-      previous = now
-      requestAnimationFrame(frame)
-    }
-    requestAnimationFrame(frame)
-    if (!attributeResponses) return
-    const responseText = Response.prototype.text
-    Response.prototype.text = function () {
-      const started = performance.now()
-      const url = this.url
-      return responseText.call(this).then((text) => {
-        state.responseText.push({ url, duration: performance.now() - started })
-        return text
-      })
-    }
-  }, options.responseURLs)
-}
-
-export async function resetProbe(page: Page) {
-  await page.evaluate(() => {
-    const state = (window as Window & { __opencodeRendererProfile?: ProbeResult }).__opencodeRendererProfile
-    if (!state) return
-    state.longTasks.length = 0
-    state.animationFrames.length = 0
-    state.frameGaps.length = 0
-    state.responseText.length = 0
-  })
-}
-
-export async function collectProbe(page: Page) {
-  return page.evaluate(
-    () => (window as Window & { __opencodeRendererProfile?: ProbeResult }).__opencodeRendererProfile!,
-  )
-}
-
-export function summarizeProbe(probe: ProbeResult) {
-  const scripts = new Map<
-    string,
-    {
-      function: string
-      source: string
-      position: number
-      invoker: string
-      invokerType: string
-      durationMs: number
-      forcedStyleAndLayoutMs: number
-    }
-  >()
-  probe.animationFrames
-    .flatMap((frame) => frame.scripts)
-    .forEach((script) => {
-      const key = `${script.source}:${script.position}:${script.invoker}`
-      const current = scripts.get(key) ?? {
-        function: script.function,
-        source: script.source,
-        position: script.position,
-        invoker: script.invoker,
-        invokerType: script.invokerType,
-        durationMs: 0,
-        forcedStyleAndLayoutMs: 0,
-      }
-      current.durationMs += script.duration
-      current.forcedStyleAndLayoutMs += script.forcedStyleAndLayoutDuration
-      scripts.set(key, current)
-    })
-  return {
-    longTasks: {
-      count: probe.longTasks.length,
-      totalMs: sum(probe.longTasks),
-      maxMs: Math.max(0, ...probe.longTasks),
-    },
-    longAnimationFrames: {
-      count: probe.animationFrames.length,
-      totalBlockingMs: sum(probe.animationFrames.map((frame) => frame.blockingDuration)),
-      maxDurationMs: Math.max(0, ...probe.animationFrames.map((frame) => frame.duration)),
-      forcedStyleAndLayoutMs: sum(probe.animationFrames.map((frame) => frame.forcedStyleAndLayoutDuration)),
-      scripts: [...scripts.values()].sort((a, b) => b.durationMs - a.durationMs).slice(0, 15),
-    },
-    frameGaps: {
-      count: probe.frameGaps.length,
-      maxMs: Math.max(0, ...probe.frameGaps),
-    },
-    responseText: probe.responseText
-      .map((item) => ({ path: responsePath(item.url), durationMs: item.duration }))
-      .sort((a, b) => b.durationMs - a.durationMs),
-  }
-}
-
-export async function startCPUProfile(page: Page, enabled: boolean) {
-  if (!enabled) return { stop: async () => [] }
-  const session = await page.context().newCDPSession(page)
-  await session.send("Profiler.enable")
-  await session.send("Profiler.setSamplingInterval", { interval: 1_000 })
-  await session.send("Profiler.start")
-  return {
-    async stop() {
-      const result = await session.send("Profiler.stop")
-      await session.detach()
-      const self = new Map<number, number>()
-      result.profile.samples?.forEach((id, index) => {
-        self.set(id, (self.get(id) ?? 0) + (result.profile.timeDeltas?.[index] ?? 0) / 1_000)
-      })
-      return result.profile.nodes
-        .map((node) => ({
-          function: node.callFrame.functionName || "(anonymous)",
-          source: sourceName(node.callFrame.url),
-          line: node.callFrame.lineNumber + 1,
-          selfMs: self.get(node.id) ?? 0,
-        }))
-        .filter((node) => node.selfMs >= 1)
-        .sort((a, b) => b.selfMs - a.selfMs)
-        .slice(0, 40)
-    },
-  }
-}
-
-function responsePath(value: string) {
-  try {
-    return new URL(value).pathname
-  } catch {
-    return value
-  }
-}
-
-function sourceName(value: string) {
-  if (!value) return "(native)"
-  try {
-    return new URL(value).pathname.split("/").at(-1) || "(document)"
-  } catch {
-    return value.split(/[\\/]/).at(-1) || value
-  }
-}
-
-function sum(values: number[]) {
-  return values.reduce((total, value) => total + value, 0)
-}
@@ -1,7 +0,0 @@
-const started = performance.now()
-
-export function progress(message: string, details?: Record<string, unknown>) {
-  const elapsed = ((performance.now() - started) / 1_000).toFixed(1)
-  const suffix = details ? ` ${JSON.stringify(details)}` : ""
-  console.error(`[desktop-profile +${elapsed}s] ${message}${suffix}`)
-}
@@ -1,156 +0,0 @@
-import { chromium, type Page } from "@playwright/test"
-import { copyFile, mkdir, rm } from "node:fs/promises"
-import path from "node:path"
-import { prepareDesktopState } from "./desktop-state"
-import { progress } from "./progress"
-import type { Options } from "./types"
-
-export async function withDesktop<T>(
-  options: Options,
-  desktop: string,
-  run: number,
-  projectIDs: string[],
-  use: (page: Page) => Promise<T>,
-) {
-  const port = availablePort()
-  const endpoint = `http://127.0.0.1:${port}`
-  const userData = path.join(options.output, `user-data-${run}`)
-  const database =
-    options.mode === "partial-snapshot" ? path.join(options.output, `working-database-${run}.db`) : options.database
-  await rm(userData, { recursive: true, force: true })
-  await mkdir(userData, { recursive: true })
-  if (database !== options.database) await copyFile(options.database, database)
-  await prepareDesktopState(options, database, userData, run, projectIDs)
-  const electron = path.join(
-    desktop,
-    "node_modules",
-    "electron",
-    "dist",
-    (await Bun.file(path.join(desktop, "node_modules", "electron", "path.txt")).text()).trim(),
-  )
-  progress("launching Electron", { run, port })
-  const child = Bun.spawn([electron, "."], {
-    cwd: desktop,
-    env: {
-      ...process.env,
-      OPENCODE_DB: database,
-      OPENCODE_CHANNEL: "dev",
-      OPENCODE_PROFILE_LOAF: "1",
-      OPENCODE_PROFILE_CDP_PORT: String(port),
-      OPENCODE_PROFILE_USER_DATA: userData,
-      OPENCODE_PERFORMANCE_TRACE_DIR: options.diagnostics ? path.join(options.output, "traces", String(run)) : "",
-      OPENCODE_PERFORMANCE_RUN_ID: `desktop-${run}`,
-    },
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  const stdout = drain(child.stdout, "stdout")
-  const stderr = drain(child.stderr, "stderr")
-  let browser: Awaited<ReturnType<typeof chromium.connectOverCDP>> | undefined
-
-  try {
-    progress("waiting for CDP", { run })
-    await waitForCDP(endpoint, child, stdout, stderr)
-    progress("connecting Playwright", { run })
-    browser = await chromium.connectOverCDP(endpoint)
-    progress("waiting for renderer", { run })
-    const page = await waitForRenderer(browser)
-    progress("waiting for desktop API", { run })
-    await page.waitForFunction(() => typeof window.api === "object", undefined, { timeout: 60_000 })
-    progress("desktop ready", { run })
-    return await use(page)
-  } finally {
-    progress("stopping Electron", { run })
-    await browser?.close().catch(() => {})
-    await killTree(child.pid)
-    await Promise.allSettled([stdout, stderr])
-    if (database !== options.database) {
-      await Bun.sleep(500)
-      await rm(database, { force: true }).catch(() => undefined)
-    }
-  }
-}
-
-export async function run(command: string[], cwd: string, database: string) {
-  const child = Bun.spawn(command, {
-    cwd,
-    env: { ...process.env, OPENCODE_DB: database, OPENCODE_CHANNEL: "dev" },
-    stdout: "inherit",
-    stderr: "inherit",
-  })
-  const code = await child.exited
-  if (code !== 0) throw new Error(`${command.join(" ")} exited with ${code}`)
-}
-
-function availablePort() {
-  const server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() })
-  const port = server.port
-  server.stop(true)
-  return port
-}
-
-async function waitForCDP(
-  endpoint: string,
-  child: ReturnType<typeof Bun.spawn>,
-  stdout: Promise<string>,
-  stderr: Promise<string>,
-) {
-  const timeout = Date.now() + 5 * 60_000
-  let heartbeat = Date.now() + 10_000
-  while (Date.now() < timeout) {
-    const ready = await fetch(`${endpoint}/json/version`)
-      .then((response) => response.ok)
-      .catch(() => false)
-    if (ready) return
-    if (child.exitCode !== null)
-      throw new Error(`Desktop exited before CDP was ready (${child.exitCode})\n${await stdout}\n${await stderr}`)
-    if (Date.now() >= heartbeat) {
-      progress("still waiting for CDP")
-      heartbeat = Date.now() + 10_000
-    }
-    await Bun.sleep(250)
-  }
-  throw new Error("Timed out waiting for desktop CDP")
-}
-
-async function waitForRenderer(browser: Awaited<ReturnType<typeof chromium.connectOverCDP>>) {
-  const timeout = Date.now() + 60_000
-  let heartbeat = Date.now() + 10_000
-  while (Date.now() < timeout) {
-    const page = browser
-      .contexts()
-      .flatMap((context) => context.pages())
-      .find((candidate) => candidate.url().startsWith("oc://renderer"))
-    if (page) return page
-    if (Date.now() >= heartbeat) {
-      progress("still waiting for renderer")
-      heartbeat = Date.now() + 10_000
-    }
-    await Bun.sleep(100)
-  }
-  throw new Error("Desktop renderer target was not found")
-}
-
-async function drain(stream: ReadableStream<Uint8Array>, label: string) {
-  const decoder = new TextDecoder()
-  let output = ""
-  let pending = ""
-  for await (const chunk of stream) {
-    const text = decoder.decode(chunk, { stream: true })
-    output = (output + text).slice(-50_000)
-    const lines = (pending + text).split(/\r?\n/)
-    pending = lines.pop() ?? ""
-    lines.filter(Boolean).forEach((line) => progress(`Electron ${label}`, { line: line.slice(0, 500) }))
-  }
-  if (pending) progress(`Electron ${label}`, { line: pending.slice(0, 500) })
-  return output + decoder.decode()
-}
-
-async function killTree(pid: number) {
-  if (process.platform !== "win32") {
-    process.kill(pid, "SIGTERM")
-    return
-  }
-  const child = Bun.spawn(["taskkill", "/pid", String(pid), "/T", "/F"], { stdout: "ignore", stderr: "ignore" })
-  await child.exited
-}
@@ -1,75 +0,0 @@
-import type { Page } from "@playwright/test"
-import { progress } from "./progress"
-
-export async function setDesktopRoute(page: Page, route: string) {
-  await page.evaluate(async (value) => {
-    const api = window.api as typeof window.api & { getWindowID?: () => Promise<string> }
-    const id = (await api.getWindowID?.()) ?? "browser"
-    localStorage.setItem(`opencode.desktop.window.${id}.last-active-url`, value)
-  }, route)
-}
-
-export async function waitForQuietDOM(page: Page) {
-  progress("waiting for DOM to settle")
-  await page.evaluate(
-    () =>
-      new Promise<void>((resolve) => {
-        let settled = false
-        let timer = setTimeout(done, 750)
-        const deadline = setTimeout(done, 30_000)
-        const observer = new MutationObserver(() => {
-          clearTimeout(timer)
-          timer = setTimeout(done, 750)
-        })
-        observer.observe(document.body, { childList: true, subtree: true, characterData: true })
-        function done() {
-          if (settled) return
-          settled = true
-          clearTimeout(deadline)
-          observer.disconnect()
-          requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
-        }
-      }),
-  )
-  progress("DOM settled")
-}
-
-export async function waitForSelector(page: Page, selector: string, label: string) {
-  progress("waiting for UI", { label })
-  try {
-    await page.waitForSelector(selector, { timeout: 30_000 })
-  } catch (error) {
-    progress("UI wait failed", {
-      label,
-      url: page.url(),
-      body: (await page.locator("body").innerText().catch(() => "")).replace(/\s+/g, " ").slice(0, 500),
-    })
-    throw error
-  }
-  progress("UI ready", { label })
-}
-
-export async function domCounts(page: Page, review = false) {
-  return page.evaluate((review) => ({
-    elements: document.getElementsByTagName("*").length,
-    ...(review
-      ? {
-          diffViewers: document.querySelectorAll('[data-component="file"][data-mode="diff"]').length,
-          diffLines: document.querySelectorAll("[data-line]").length,
-        }
-      : {
-          timelineRows: document.querySelectorAll("[data-timeline-row]").length,
-          messageRows: document.querySelectorAll("[data-message-id]").length,
-          markdownRoots: document.querySelectorAll('[data-component="markdown"]').length,
-          diffViewers: document.querySelectorAll('[data-component="file"][data-mode="diff"]').length,
-        }),
-  }), review)
-}
-
-export function sum(values: number[]) {
-  return values.reduce((total, value) => total + value, 0)
-}
-
-export function percentile(values: number[], quantile: number) {
-  return values.toSorted((a, b) => a - b)[Math.max(0, Math.ceil(values.length * quantile) - 1)] ?? 0
-}
@@ -1,178 +0,0 @@
-import type { Page } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import { startChromeTrace } from "../chrome-trace"
-import { collectProbe, resetProbe, startCPUProfile, summarizeProbe } from "./probe"
-import { progress } from "./progress"
-import { domCounts, percentile, setDesktopRoute, sum, waitForQuietDOM, waitForSelector } from "./scenario-utils"
-import type { Options, Target } from "./types"
-
-export async function runScenarios(page: Page, options: Options, targets: Target[], typingText: string) {
-  const results: unknown[] = []
-  if (options.scenarios.includes("home")) results.push(await profileHome(page, options))
-  if (options.scenarios.includes("calibration")) results.push(await profileCalibration(page))
-  if (options.scenarios.includes("session")) {
-    for (const target of targets) results.push(await profileSession(page, options, target))
-  }
-  if (options.scenarios.some((scenario) => ["composer", "history", "review"].includes(scenario))) {
-    await openSession(page, targets[2]!)
-  }
-  if (options.scenarios.includes("composer")) results.push(await profileComposer(page, options, typingText))
-  if (options.scenarios.includes("history")) results.push(await profileHistory(page, options, targets[2]!))
-  if (options.scenarios.includes("review")) {
-    const review = await profileReview(page, options)
-    if (review) results.push(review)
-  }
-  return results
-}
-
-async function profileHome(page: Page, options: Options) {
-  const measured = await measure(page, options, "home", async () => {
-    await setDesktopRoute(page, "/")
-    await page.reload({ waitUntil: "domcontentloaded", timeout: 60_000 })
-    await waitForSelector(page, '[data-component="home-session-row"]', "Home session rows")
-    await waitForQuietDOM(page)
-  })
-  return { ...measured, dom: await domCounts(page) }
-}
-
-async function profileCalibration(page: Page) {
-  await resetProbe(page)
-  await page.evaluate(
-    () =>
-      new Promise<void>((resolve) => {
-        setTimeout(function opencodeProfileCalibration() {
-          const end = performance.now() + 80
-          while (performance.now() < end) {
-            // Deliberate benchmark-only main-thread block.
-          }
-          requestAnimationFrame(() => setTimeout(resolve, 100))
-        })
-      }),
-  )
-  return { name: "attribution-calibration", ...summarizeProbe(await collectProbe(page)) }
-}
-
-async function profileSession(page: Page, options: Options, target: Target) {
-  await prepareHome(page)
-  const measured = await measure(page, options, `session-${target.label}`, async () => {
-    await navigateSession(page, target)
-    await waitForSelector(page, '[data-component="prompt-input"]', "session composer")
-    await waitForQuietDOM(page)
-  })
-  return { ...measured, context: targetContext(target), dom: await domCounts(page) }
-}
-
-async function profileComposer(page: Page, options: Options, typingText: string) {
-  const editor = page.locator('[data-component="prompt-input"][contenteditable="true"]').first()
-  await editor.click()
-  await page.keyboard.press("Control+A")
-  await page.keyboard.press("Backspace")
-  const printable = [...typingText].filter((character) => !["\r", "\n", "\t"].includes(character))
-  const measuredText = printable.slice(-120).join("")
-  const prefix = printable.slice(0, -measuredText.length).join("")
-  if (prefix) await page.keyboard.insertText(prefix)
-  await waitForQuietDOM(page)
-  const durations: number[] = []
-  const measured = await measure(page, options, "composer-typing", async () => {
-    for (const character of measuredText) {
-      const started = performance.now()
-      await page.keyboard.type(character)
-      durations.push(performance.now() - started)
-    }
-    await waitForQuietDOM(page)
-  })
-  await page.keyboard.press("Control+A")
-  await page.keyboard.press("Backspace")
-  return {
-    ...measured,
-    context: { promptCharacters: printable.length, measuredCharacters: measuredText.length },
-    typing: {
-      totalMs: sum(durations),
-      meanMs: sum(durations) / durations.length,
-      p50Ms: percentile(durations, 0.5),
-      p95Ms: percentile(durations, 0.95),
-      maxMs: Math.max(...durations),
-    },
-  }
-}
-
-async function profileHistory(page: Page, options: Options, target: Target) {
-  await waitForSelector(page, '[data-component="prompt-input"]', "history session composer")
-  await waitForQuietDOM(page)
-  let requests = 0
-  const onResponse = (response: { url(): string }) => {
-    if (/\/session\/[^/]+\/message(?:\?|$)/.test(response.url())) requests++
-  }
-  page.on("response", onResponse)
-  const measured = await measure(page, options, "session-max-history-boundary", async () => {
-    const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") }).first()
-    await scroller.evaluate((element) => {
-      element.scrollTop = 0
-      element.dispatchEvent(new WheelEvent("wheel", { deltaY: -10_000, bubbles: true }))
-      element.dispatchEvent(new Event("scroll", { bubbles: true }))
-    })
-    const timeout = Date.now() + 60_000
-    while (requests === 0 && Date.now() < timeout) await page.waitForTimeout(50)
-    if (requests === 0) throw new Error("History boundary did not request a page")
-    await waitForQuietDOM(page)
-  })
-  page.off("response", onResponse)
-  return { ...measured, context: targetContext(target), messageRequests: requests }
-}
-
-async function profileReview(page: Page, options: Options) {
-  const button = page.getByRole("button", { name: "Toggle review" })
-  if (!(await button.isVisible().catch(() => false))) return
-  const panel = page.locator("#review-panel")
-  if (await panel.isVisible().catch(() => false)) {
-    await button.click()
-    await panel.waitFor({ state: "hidden", timeout: 60_000 })
-    await waitForQuietDOM(page)
-  }
-  const measured = await measure(page, options, "review-open", async () => {
-    await button.click()
-    await panel.waitFor({ state: "visible", timeout: 60_000 })
-    await waitForQuietDOM(page)
-  })
-  return { ...measured, dom: await domCounts(page, true) }
-}
-
-async function measure(page: Page, options: Options, name: string, action: () => Promise<void>) {
-  progress("scenario started", { name })
-  await resetProbe(page)
-  const stopTrace = options.diagnostics ? await startChromeTrace(page, name) : undefined
-  const cpu = await startCPUProfile(page, options.cpu)
-  const started = performance.now()
-  await action()
-  const result = {
-    name,
-    elapsedMs: performance.now() - started,
-    ...summarizeProbe(await collectProbe(page)),
-    cpu: await cpu.stop(),
-    trace: await stopTrace?.(),
-  }
-  progress("scenario completed", { name, elapsedMs: Math.round(result.elapsedMs), longTasks: result.longTasks.count })
-  return result
-}
-
-async function openSession(page: Page, target: Target) {
-  await navigateSession(page, target)
-  await waitForSelector(page, '[data-component="prompt-input"]', "session composer")
-  await waitForQuietDOM(page)
-}
-
-async function prepareHome(page: Page) {
-  await setDesktopRoute(page, "/")
-  await page.reload({ waitUntil: "domcontentloaded", timeout: 60_000 })
-  await waitForSelector(page, '[data-component="home-session-row"]', "Home session rows")
-  await waitForQuietDOM(page)
-}
-
-async function navigateSession(page: Page, target: Target) {
-  await setDesktopRoute(page, `/server/${base64Encode("sidecar")}/session/${target.id}`)
-  await page.reload({ waitUntil: "domcontentloaded", timeout: 60_000 })
-}
-
-function targetContext(target: Target) {
-  return { serializedBytes: target.bytes, messages: target.messages, parts: target.parts, userTurns: target.userTurns }
-}
@@ -1,50 +0,0 @@
-export const scenarios = ["home", "calibration", "session", "composer", "history", "review"] as const
-
-export type Scenario = (typeof scenarios)[number]
-
-export type Options = {
-  mode: "local" | "partial-snapshot"
-  database: string
-  output: string
-  windowStart: number
-  windowEnd: number
-  scenarios: Scenario[]
-  runs: number
-  build: boolean
-  diagnostics: boolean
-  cpu: boolean
-  responseURLs: boolean
-  partialSnapshotOut?: string
-}
-
-export type Target = {
-  label: "p50" | "p95" | "max"
-  id: string
-  projectID: string
-  directory: string
-  title: string
-  bytes: number
-  messages: number
-  parts: number
-  userTurns: number
-}
-
-export type ProbeResult = {
-  longTasks: number[]
-  animationFrames: {
-    duration: number
-    blockingDuration: number
-    forcedStyleAndLayoutDuration: number
-    scripts: {
-      function: string
-      source: string
-      position: number
-      invoker: string
-      invokerType: string
-      duration: number
-      forcedStyleAndLayoutDuration: number
-    }[]
-  }[]
-  frameGaps: number[]
-  responseText: { url: string; duration: number }[]
-}
@@ -1,107 +0,0 @@
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-import { createPartialSnapshot, fingerprint, loadCorpus } from "./desktop-profile/corpus"
-import { parseOptions } from "./desktop-profile/options"
-import { installProbe } from "./desktop-profile/probe"
-import { progress } from "./desktop-profile/progress"
-import { withDesktop, run } from "./desktop-profile/runtime"
-import { runScenarios } from "./desktop-profile/scenarios"
-
-const root = path.resolve(import.meta.dir, "../../../..")
-const desktop = path.join(root, "packages/desktop")
-const options = parseOptions(process.argv.slice(2))
-if (!options) process.exit(0)
-
-await mkdir(options.output, { recursive: true })
-progress("loading corpus", { mode: options.mode })
-let corpus = loadCorpus(options)
-if (options.partialSnapshotOut) {
-  progress("creating partial snapshot")
-  await createPartialSnapshot(options.database, options.partialSnapshotOut, options, corpus.targets)
-  options.database = options.partialSnapshotOut
-  options.mode = "partial-snapshot"
-  corpus = loadCorpus(options)
-}
-if (options.build) {
-  progress("building desktop production bundle")
-  await run(["bun", "run", "build"], desktop, options.database)
-}
-
-progress("corpus ready", { targets: corpus.targets.map((target) => target.label), runs: options.runs })
-const runs = []
-for (let index = 1; index <= options.runs; index++) {
-  runs.push(
-    await withDesktop(options, desktop, index, corpus.projectIDs, async (page) => {
-      await installProbe(page, options)
-      await page.evaluate(() => {
-        const settings = JSON.parse(localStorage.getItem("settings.v3") ?? "{}")
-        localStorage.setItem(
-          "settings.v3",
-          JSON.stringify({ ...settings, general: { ...settings.general, newLayoutDesigns: true } }),
-        )
-      })
-      return runScenarios(page, options, corpus.targets, corpus.typingText)
-    }),
-  )
-}
-
-const report = {
-  schemaVersion: 2,
-  source: options.mode === "partial-snapshot" ? "partial-database-snapshot" : "local-opencode-db",
-  command: process.argv.slice(2),
-  diagnostics: options.diagnostics,
-  profileCPU: options.cpu,
-  database: await fingerprint(options.database),
-  window: {
-    start: new Date(options.windowStart).toISOString(),
-    end: new Date(options.windowEnd).toISOString(),
-  },
-  revision: (await Bun.$`git rev-parse HEAD`.cwd(root).text()).trim(),
-  targets: corpus.targets.map(({ id: _, projectID: __, directory: ___, title: ____, ...target }) => target),
-  summary: summarize(runs),
-  runs: runs.map((results, index) => ({ index: index + 1, results })),
-}
-const file = path.join(options.output, "renderer-profile.json")
-await Bun.write(file, JSON.stringify(report, null, 2))
-console.log(`PROFILE_REPORT ${file}`)
-console.log(`PROFILE_SUMMARY ${JSON.stringify(report.summary)}`)
-console.log(JSON.stringify(report, null, 2))
-
-function summarize(runs: unknown[][]) {
-  type Result = {
-    name: string
-    elapsedMs?: number
-    longTasks: { count: number; totalMs: number; maxMs: number }
-    longAnimationFrames: { totalBlockingMs: number }
-    typing?: { p50Ms: number; p95Ms: number; maxMs: number }
-  }
-  return Object.fromEntries(
-    [...Map.groupBy(runs.flat() as Result[], (result) => result.name)].map(([name, samples]) => [
-      name,
-      {
-        samples: samples.length,
-        elapsedMedianMs: median(samples.flatMap((sample) => sample.elapsedMs ?? [])),
-        longTasks: {
-          maxCount: Math.max(...samples.map((sample) => sample.longTasks.count)),
-          maxTotalMs: Math.max(...samples.map((sample) => sample.longTasks.totalMs)),
-          maxTaskMs: Math.max(...samples.map((sample) => sample.longTasks.maxMs)),
-        },
-        maxBlockingMs: Math.max(...samples.map((sample) => sample.longAnimationFrames.totalBlockingMs)),
-        ...(samples[0]?.typing
-          ? {
-              typingMedianMs: {
-                p50: median(samples.flatMap((sample) => sample.typing?.p50Ms ?? [])),
-                p95: median(samples.flatMap((sample) => sample.typing?.p95Ms ?? [])),
-                max: median(samples.flatMap((sample) => sample.typing?.maxMs ?? [])),
-              },
-            }
-          : {}),
-      },
-    ]),
-  )
-}
-
-function median(values: number[]) {
-  if (values.length === 0) return
-  return values.toSorted((a, b) => a - b)[Math.floor(values.length / 2)]
-}
@@ -1 +0,0 @@
-import "./profile-desktop"
@@ -18,7 +18,7 @@ import { installSseTransport } from "../utils/sse-transport"
 import { expectSessionTitle } from "../utils/waits"

 const initialPageSize = 20
-const historyPageSize = 50
+const historyPageSize = 200
 const assistants = Array.from({ length: initialPageSize + 1 }, (_, index) =>
  assistantMessage([textPart(`prt_history_root_${index}`, `Assistant response ${index}`)], {
    id: `msg_${String(index + 1001).padStart(4, "0")}_history_root_assistant`,
@@ -28,8 +28,7 @@
    "test:e2e:ui": "playwright test --ui",
    "test:e2e:report": "playwright show-report e2e/playwright-report",
    "test:stability": "bun test ./e2e/performance/unit/visual-stability.test.ts && playwright test --config e2e/performance/timeline-stability/playwright.config.ts",
-    "test:bench": "bun test ./e2e/performance/unit && playwright test --config e2e/performance/playwright.config.ts",
-    "profile:desktop": "bun run e2e/performance/profile-desktop.ts"
+    "test:bench": "bun test ./e2e/performance/unit && playwright test --config e2e/performance/playwright.config.ts"
  },
  "license": "MIT",
  "devDependencies": {
@@ -3,6 +3,7 @@ import * as Sentry from "@sentry/solid"
 import { I18nProvider } from "@opencode-ai/ui/context"
 import { DialogProvider } from "@opencode-ai/ui/context/dialog"
 import { FileComponentProvider } from "@opencode-ai/ui/context/file"
+import { File } from "@opencode-ai/session-ui/file"
 import { Font } from "@opencode-ai/ui/font"
 import { Splash } from "@opencode-ai/ui/logo"
 import { ThemeProvider } from "@opencode-ai/ui/theme/context"
@@ -57,24 +58,18 @@ import { TabsProvider, useTabs, type DraftTab } from "@/context/tabs"
 import { SDKProvider, useSDK } from "@/context/sdk"
 import { WslServersProvider } from "@/wsl/context"
 import DirectoryLayout, { DirectoryDataProvider } from "@/pages/directory-layout"
+import LegacyLayout from "@/pages/layout"
+import NewLayout from "@/pages/layout-new"
 import { ErrorPage } from "./pages/error"
 import { useCheckServerHealth } from "./utils/server-health"
 import { legacySessionHref, legacySessionServer, requireServerKey, sessionHref } from "./utils/session-route"
 import { createSessionLineage } from "@/pages/session/session-lineage"

+import { SessionPage, SessionRouteErrorBoundary, TargetSessionRouteContent } from "@/pages/session"
+import { NewHome } from "@/pages/home"
+import { LegacyHome } from "@/pages/home/legacy-home"
+
 const NewSession = lazy(() => import("@/pages/new-session"))
-const NewLayout = lazy(() => import("@/pages/layout-new"))
-const NewHome = lazy(() => import("@/pages/home").then((module) => ({ default: module.NewHome })))
-const LegacyLayout = lazy(() => import("@/pages/layout"))
-const LegacyHome = lazy(() => import("@/pages/home/legacy-home").then((module) => ({ default: module.LegacyHome })))
-const File = lazy(() => import("@opencode-ai/session-ui/file").then((module) => ({ default: module.File })))
-const SessionPage = lazy(() => import("@/pages/session").then((module) => ({ default: module.SessionPage })))
-const SessionRouteErrorBoundary = lazy(() =>
-  import("@/pages/session").then((module) => ({ default: module.SessionRouteErrorBoundary })),
-)
-const TargetSessionRouteContent = lazy(() =>
-  import("@/pages/session").then((module) => ({ default: module.TargetSessionRouteContent })),
-)

 const SessionRoute = () => {
  const settings = useSettings()
@@ -88,7 +88,7 @@ export const DialogSelectModelUnpaidV2: Component<{ model?: ModelState }> = (pro
                  class="w-full"
                  placement="right-start"
                  gutter={6}
-                  delay="intent"
+                  openDelay={0}
                  contentStyle={{ "font-family": "var(--v2-font-family-sans)" }}
                  value={
                    <ModelTooltip
@@ -460,7 +460,7 @@ function ModelSelectorPopoverV2View(props: {
                              class="w-full"
                              placement="right-start"
                              gutter={6}
-                              delay="intent"
+                              openDelay={0}
                              value={
                                <ModelTooltip
                                  model={item}
@@ -47,7 +47,7 @@ export const PromptContextItems: Component<ContextItemsProps> = (props) => {
                  </span>
                }
                placement="top"
-                {...(!props.newLayoutDesigns ? { openDelay: 800 } : {})}
+                openDelay={800}
              >
                <div
                  classList={{
@@ -53,7 +53,12 @@ export const PromptImageAttachments: Component<PromptImageAttachmentsProps> = (p
            <For each={props.comments ?? []}>
              {(item) => (
                <div class="relative group shrink-0">
-                  <TooltipV2 value={item.comment} placement="top" contentClass="max-w-[300px] break-words">
+                  <TooltipV2
+                    value={item.comment}
+                    placement="top"
+                    openDelay={800}
+                    contentClass="max-w-[300px] break-words"
+                  >
                    <CommentCardV2
                      comment={item.comment ?? ""}
                      path={item.path}
@@ -7,7 +7,6 @@ import { TextField } from "@opencode-ai/ui/text-field"
 import { type Component, For, Show } from "solid-js"
 import { useLanguage } from "@/context/language"
 import { useModels } from "@/context/models"
-import { useServerSync } from "@/context/server-sync"
 import { popularProviders } from "@/hooks/use-providers"
 import { SettingsList } from "./settings-list"
 import { SettingsServerPicker, SettingsServerScope } from "./settings-server-picker"
@@ -44,7 +43,6 @@ export const SettingsModels: Component = () => {
 const SettingsModelsContent: Component = () => {
  const language = useLanguage()
  const models = useModels()
-  useServerSync()().loadProviders()

  const list = useFilteredList<ModelItem>({
    items: (_filter) => models.list(),
@@ -9,7 +9,6 @@ import { createStore } from "solid-js/store"
 import { useLanguage } from "@/context/language"
 import { useModels } from "@/context/models"
 import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "@/context/server-sync"
 import { popularProviders } from "@/hooks/use-providers"
 import { Persist, persisted } from "@/utils/persist"
 import { SettingsListV2 } from "./parts/list"
@@ -24,7 +23,6 @@ export const SettingsModelsV2: Component = () => {
  const language = useLanguage()
  const models = useModels()
  const serverSdk = useServerSDK()
-  useServerSync()().loadProviders()
  const [store, setStore] = persisted(
    Persist.serverGlobal(serverSdk().scope, "settings-v2.models.providers"),
    createStore({ collapsed: {} as Record<string, boolean> }),
@@ -353,22 +353,6 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                  keybind: "mod+shift+t",
                  onSelect: () => tabsStoreActions.reopenClosedTab(),
                },
-                {
-                  id: `tab.prev`,
-                  category: "tab",
-                  title: "",
-                  keybind: `mod+option+ArrowLeft,ctrl+shift+tab`,
-                  hidden: true,
-                  onSelect: tabs.previous,
-                },
-                {
-                  id: `tab.next`,
-                  category: "tab",
-                  title: "",
-                  keybind: `mod+option+ArrowRight,ctrl+tab`,
-                  hidden: true,
-                  onSelect: tabs.next,
-                },
              ].filter((v) => v !== undefined)
            })

@@ -152,6 +152,12 @@ export async function bootstrapGlobal(input: {
  queryClient: QueryClient
 }) {
  const slow = [
+    () => input.queryClient.fetchQuery(loadGlobalConfigQuery(input.scope, input.serverSDK, input.protocol)),
+    () =>
+      input.queryClient.fetchQuery(
+        loadProvidersQuery(input.scope, null, input.serverAPI, input.serverSDK, input.protocol),
+      ),
+    () => input.queryClient.fetchQuery(loadPathQuery(input.scope, null, input.serverSDK, input.protocol)),
    () =>
      input.queryClient
        .fetchQuery(loadProjectsQuery(input.scope, input.serverAPI.project))
@@ -518,6 +524,17 @@ export async function bootstrapDirectory(input: {
          input.queryClient.fetchQuery(
            loadMcpResourcesQuery(input.scope, input.directory, input.api.mcp, input.sdk, input.protocol),
          )),
+      () =>
+        input.queryClient
+          .fetchQuery(loadProvidersQuery(input.scope, input.directory, input.api, input.sdk, input.protocol))
+          .catch((err) => {
+            const project = getFilename(input.directory)
+            showToast({
+              variant: "error",
+              title: input.translate("toast.project.reloadFailed.title", { project }),
+              description: formatServerError(err, input.translate),
+            })
+          }),
    ].filter(Boolean) as (() => Promise<any>)[]

    await waitForPaint()
@@ -263,13 +263,10 @@ describe("createChildStoreManager", () => {
      manager.child("/project")
      expect(queries[0]?.().enabled).toBe(true)
      expect(queries[3]?.().enabled).toBe(true)
-      expect(queries[4]?.().enabled).toBe(false)
+      expect(queries[4]?.().enabled).toBe(true)
      expect(queries[5]?.().enabled).toBe(true)
      expect(bootstraps).toEqual(["/project"])

-      manager.enableProviders("/project")
-      expect(queries[4]?.().enabled).toBe(true)
-
      manager.child("/project", { bootstrap: false })
      expect(queries[0]?.().enabled).toBe(true)
    } finally {
@@ -47,7 +47,6 @@ export function createChildStoreManager(input: {
  const mcpToggles = new Map<string, (enabled: boolean) => void>()
  const activeDirectories = new Set<string>()
  const activationToggles = new Map<string, (enabled: boolean) => void>()
-  const providerToggles = new Map<string, (enabled: boolean) => void>()

  const markKey = (key: DirectoryKey) => {
    if (!key) return
@@ -123,7 +122,6 @@ export function createChildStoreManager(input: {
    mcpToggles.delete(key)
    activeDirectories.delete(key)
    activationToggles.delete(key)
-    providerToggles.delete(key)
    const dispose = disposers.get(key)
    if (dispose) {
      dispose()
@@ -189,7 +187,6 @@ export function createChildStoreManager(input: {
          const initialIcon = icon[0].value
          const [mcpEnabled, setMcpEnabled] = createSignal(false)
          const [instanceQueriesEnabled, setInstanceQueriesEnabled] = createSignal(false)
-          const [providerEnabled, setProviderEnabled] = createSignal(false)

          const pathQuery = useQuery(() => ({ ...input.queryOptions.path(key), enabled: instanceQueriesEnabled() }))
          const mcpQuery = useQuery(() => ({ ...input.queryOptions.mcp(key), enabled: mcpEnabled() }))
@@ -197,7 +194,7 @@ export function createChildStoreManager(input: {
          const lspQuery = useQuery(() => ({ ...input.queryOptions.lsp(key), enabled: instanceQueriesEnabled() }))
          const providerQuery = useQuery(() => ({
            ...input.queryOptions.providers(key),
-            enabled: providerEnabled(),
+            enabled: instanceQueriesEnabled(),
          }))
          const referenceQuery = useQuery(() => ({
            ...input.queryOptions.references(key),
@@ -209,7 +206,7 @@ export function createChildStoreManager(input: {
            projectMeta: initialMeta,
            icon: initialIcon,
            get provider_ready() {
-              return providerEnabled() && !providerQuery.isLoading
+              return instanceQueriesEnabled() && !providerQuery.isLoading
            },
            get provider() {
              const EMPTY = { all: new Map(), connected: [], default: {} }
@@ -266,7 +263,6 @@ export function createChildStoreManager(input: {
          disposers.set(key, dispose)
          mcpToggles.set(key, setMcpEnabled)
          activationToggles.set(key, setInstanceQueriesEnabled)
-          providerToggles.set(key, setProviderEnabled)

          const onPersistedInit = (init: Promise<string> | string | null, run: () => void) => {
            if (!(init instanceof Promise)) return
@@ -333,12 +329,6 @@ export function createChildStoreManager(input: {
    if (childStore[0].status !== "loading") input.onMcp(directory, childStore[1])
  }

-  function enableProviders(directory: string) {
-    const key = directoryKey(directory)
-    ensureChild(directory)
-    providerToggles.get(key)?.(true)
-  }
-
  // Passive Home/project metadata reads must not initialize the directory.
  // A real directory access enables these queries once for the store lifetime.
  // TODO(v2): After Home switches to v2.project.list and root-filtered,
@@ -397,7 +387,6 @@ export function createChildStoreManager(input: {
    mcp: (directory: string) => mcpDirectories.has(directoryKey(directory)),
    active: (directory: string) => activeDirectories.has(directoryKey(directory)),
    disableMcp,
-    enableProviders,
    disposeDirectory,
    runEviction,
    vcsCache,
@@ -22,7 +22,6 @@ export const homeSessionIndexKey = (server: string) => ["home", "session-index",
 export const homeSessionEventsKey = (server: string) => ["home", "session-events", server] as const

 type HomeSessionPage = { data?: V2SessionListResponse }
-type ProjectedHomeSessionPage = { data?: { data: Session[]; cursor: { next?: string } } }

 export async function loadHomeSessionIndex(
  list: (
@@ -32,30 +31,7 @@ export async function loadHomeSessionIndex(
  eventSequence = 0,
  signal?: AbortSignal,
 ) {
-  return loadHomeSessionPages(list, parseHomeSessionIndex, eventSequence, signal)
-}
-
-export async function loadProjectedHomeSessionIndex(
-  list: (
-    input: { limit: number; order: "desc"; cursor?: string },
-    options: { signal?: AbortSignal },
-  ) => Promise<ProjectedHomeSessionPage>,
-  eventSequence = 0,
-  signal?: AbortSignal,
-) {
-  return loadHomeSessionPages(list, (sessions) => sessions, eventSequence, signal)
-}
-
-async function loadHomeSessionPages<T>(
-  list: (
-    input: { limit: number; order: "desc"; cursor?: string },
-    options: { signal?: AbortSignal },
-  ) => Promise<{ data?: { data: T[]; cursor: { next?: string } } }>,
-  project: (sessions: T[]) => Session[],
-  eventSequence: number,
-  signal?: AbortSignal,
-) {
-  const data: T[] = []
+  const data: SessionV2Info[] = []
  let cursor: string | undefined

  for (;;) {
@@ -70,7 +46,7 @@ async function loadHomeSessionPages<T>(
    const page = response.data!
    data.push(...page.data)
    if (page.data.length < HOME_V2_SESSION_PAGE_LIMIT || !page.cursor.next)
-      return { sessions: project(data), eventSequence }
+      return { sessions: parseHomeSessionIndex(data), eventSequence }
    cursor = page.cursor.next
  }
 }
@@ -13,8 +13,6 @@ import { useGlobal } from "./global"
 import { ServerScope } from "@/utils/server-scope"
 import { detectServerProtocol, type ServerProtocol } from "@/utils/server-protocol"
 import { createCompatibleApi, type CompatibleApi } from "@/utils/server-compat"
-import { decodeVcsDiff } from "@/utils/vcs-diff-decoder"
-import { decodeSessionList } from "./session-message-decoder"

 const isAbortError = (error: unknown) =>
  error !== null && typeof error === "object" && "name" in error && error.name === "AbortError"
@@ -348,7 +346,7 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
      throwOnError: true,
      directory,
    })
-  const api = createCompatibleApi({ protocol, current: currentApi, legacy, decodeVcsDiff, decodeSessionList })
+  const api = createCompatibleApi({ protocol, current: currentApi, legacy })

  return {
    server,
@@ -434,8 +432,6 @@ function createDirSdkContext(directory: string, serverSDK: ServerSDKBase) {
      current: serverSDK.currentApi,
      legacy: (next) => serverSDK.createClient({ directory: next ?? directory, throwOnError: true }),
      directory,
-      decodeVcsDiff,
-      decodeSessionList,
    }),
    event: emitter,
    get url() {
@@ -22,7 +22,6 @@ import { normalizeSessionMessages } from "@/utils/session-message"
 import { dropSessionCaches, pickSessionCacheEvictions, SESSION_CACHE_LIMIT } from "./global-sync/session-cache"
 import { createV2SessionReducer, type V2SessionReduction } from "./server-session-v2-reducer"
 import type { ServerApi } from "@/utils/server"
-import type { DecodedLegacyMessagePage } from "./session-message-decode"

 type MessageApi = ServerApi["message"]

@@ -30,16 +29,10 @@ const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 const cmpMessage = (a: Message, b: Message) => a.time.created - b.time.created || cmp(a.id, b.id)
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 const initialMessagePageSize = 20
-const historyMessagePageSize = 50
+const historyMessagePageSize = 200
 const sessionInfoLimit = 2_048
 const emptyIDs: ReadonlySet<string> = new Set()

-function yieldToMain() {
-  const scheduler = (globalThis as { scheduler?: { yield: () => Promise<void> } }).scheduler
-  if (scheduler) return scheduler.yield()
-  return new Promise<void>((resolve) => setTimeout(resolve, 0))
-}
-
 function needsOlderTurnRoot(source: readonly SessionMessageInfo[]) {
  const boundary = source.find(
    (message) =>
@@ -190,11 +183,7 @@ function reconcileFetched<T extends { id: string }>(
  return [...result.values()].sort((a, b) => cmp(a.id, b.id))
 }

-type ServerSessionOptions = {
-  retry?: typeof retry
-  protocol?: Promise<"v1" | "v2">
-  decodeMessages?: (buffer: ArrayBuffer) => Promise<DecodedLegacyMessagePage>
-}
+type ServerSessionOptions = { retry?: typeof retry; protocol?: Promise<"v1" | "v2"> }

 export function createServerSession(
  client: OpencodeClient,
@@ -563,7 +552,6 @@ export function createServerSession(
        if (!response.data.length) break
      }
      const response = pages.at(-1)!
-      await yieldToMain()
      const source = pages.flatMap((page) => page.data).toReversed()
      const normalized = normalizeSessionMessages(sessionID, source)
      return {
@@ -578,21 +566,10 @@ export function createServerSession(
        complete: response.data.length === 0,
      }
    }
-    const response = await (options?.retry ?? retry)(async () => {
+    const response = await (options?.retry ?? retry)(() => {
      onAttempt?.()
-      if (!options?.decodeMessages) return client.session.messages({ sessionID, limit, before })
-      const response = await client.session.messages({ sessionID, limit, before }, { parseAs: "arrayBuffer" })
-      if (!(response.data instanceof ArrayBuffer)) throw new Error("Session messages response is not an ArrayBuffer")
-      return { response, decoded: await options.decodeMessages(response.data) }
+      return client.session.messages({ sessionID, limit, before })
    })
-    await yieldToMain()
-    if ("decoded" in response)
-      return {
-        ...response.decoded,
-        sourceMode: before ? ("older" as const) : ("latest" as const),
-        cursor: response.response.response.headers.get("x-next-cursor") ?? undefined,
-        complete: !response.response.response.headers.get("x-next-cursor"),
-      }
    const items = (response.data ?? []).filter((item) => !!item?.info?.id)
    return {
      session: items.map((item) => cleanMessage(item.info)).sort((a, b) => cmp(a.id, b.id)),
@@ -8,7 +8,7 @@ import type {
 } from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@/utils/toast"
 import { getFilename } from "@opencode-ai/core/util/path"
-import { type Accessor, batch, createMemo, createSignal, getOwner, onCleanup, onMount, untrack } from "solid-js"
+import { type Accessor, batch, createMemo, getOwner, onCleanup, onMount, untrack } from "solid-js"
 import { createStore, produce, reconcile } from "solid-js/store"
 import { useLanguage } from "@/context/language"
 import type { InitError } from "../pages/error"
@@ -59,7 +59,6 @@ import type {
 } from "@opencode-ai/client/promise"
 import { toggleMcp } from "./global-sync/mcp"
 import { createServerSession, type ServerSession } from "./server-session"
-import { decodeSessionMessages } from "./session-message-decoder"

 type GlobalStore = {
  ready: boolean
@@ -227,7 +226,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {

  const session = createServerSession(serverSDK.client, serverSDK.api.session, serverSDK.api.message, {
    protocol: serverSDK.protocol,
-    decodeMessages: decodeSessionMessages,
  })
  const queryOptionsApi = makeQueryOptionsApi(
    serverSDK.scope,
@@ -237,40 +235,31 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
    serverSDK.protocol,
  )

-  const [providersEnabled, setProvidersEnabled] = createSignal(false)
-  const [backgroundEnabled, setBackgroundEnabled] = createSignal(false)
  const [configQuery, providerQuery, pathQuery] = useQueries(() => ({
-    queries: [
-      { ...queryOptionsApi.globalConfig(), enabled: backgroundEnabled() },
-      { ...queryOptionsApi.providers(null), enabled: providersEnabled() },
-      { ...queryOptionsApi.path(null), enabled: backgroundEnabled() },
-    ],
+    queries: [queryOptionsApi.globalConfig(), queryOptionsApi.providers(null), queryOptionsApi.path(null)],
  }))
  const activeSessionsQuery = useQuery(() =>
-    ({
-      ...loadActiveSessionsQuery(serverSDK.scope, {
-        active: async () => {
-          if ((await serverSDK.protocol) === "v1") {
-            const statuses = (await serverSDK.client.session.status()).data ?? {}
-            seedActiveSessionStatuses(session, statuses)
-            for (const sessionID of Object.keys(statuses)) {
-              void session.resolve(sessionID).catch(() => undefined)
-            }
-            return Object.fromEntries(
-              Object.entries(statuses).flatMap(([sessionID, status]) =>
-                status.type === "idle" ? [] : [[sessionID, { type: "running" as const }]],
-              ),
-            )
-          }
-          const active = await serverSDK.api.session.active()
-          seedActiveSessionStatuses(session, active)
-          for (const sessionID of Object.keys(active)) {
+    loadActiveSessionsQuery(serverSDK.scope, {
+      active: async () => {
+        if ((await serverSDK.protocol) === "v1") {
+          const statuses = (await serverSDK.client.session.status()).data ?? {}
+          seedActiveSessionStatuses(session, statuses)
+          for (const sessionID of Object.keys(statuses)) {
            void session.resolve(sessionID).catch(() => undefined)
          }
-          return active
-        },
-      }),
-      enabled: backgroundEnabled(),
+          return Object.fromEntries(
+            Object.entries(statuses).flatMap(([sessionID, status]) =>
+              status.type === "idle" ? [] : [[sessionID, { type: "running" as const }]],
+            ),
+          )
+        }
+        const active = await serverSDK.api.session.active()
+        seedActiveSessionStatuses(session, active)
+        for (const sessionID of Object.keys(active)) {
+          void session.resolve(sessionID).catch(() => undefined)
+        }
+        return active
+      },
    }),
  )

@@ -310,36 +299,10 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
  let bootingRoot = false
  let eventFrame: number | undefined
  let eventTimer: ReturnType<typeof setTimeout> | undefined
-  let providerFrame: number | undefined
-  let providerIdle: number | undefined
-  let providerTimer: ReturnType<typeof setTimeout> | undefined
-
-  onMount(() => {
-    providerFrame = requestAnimationFrame(() => {
-      providerFrame = requestAnimationFrame(() => {
-        providerFrame = undefined
-        providerTimer = setTimeout(() => {
-          providerTimer = undefined
-          if ("requestIdleCallback" in window) {
-            providerIdle = requestIdleCallback(() => {
-              setProvidersEnabled(true)
-              setBackgroundEnabled(true)
-            }, { timeout: 5_000 })
-            return
-          }
-          setProvidersEnabled(true)
-          setBackgroundEnabled(true)
-        }, 10_000)
-      })
-    })
-  })

  onCleanup(() => {
    if (eventFrame !== undefined) cancelAnimationFrame(eventFrame)
    if (eventTimer !== undefined) clearTimeout(eventTimer)
-    if (providerFrame !== undefined) cancelAnimationFrame(providerFrame)
-    if (providerIdle !== undefined) cancelIdleCallback(providerIdle)
-    if (providerTimer !== undefined) clearTimeout(providerTimer)
  })

  const setProjects = (next: Project[] | ((draft: Project[]) => Project[])) => {
@@ -719,9 +682,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
    child: children.child,
    peek: children.peek,
    disableMcp: children.disableMcp,
-    enableProviders: children.enableProviders,
    queryOptions: queryOptionsApi,
-    loadProviders: () => setProvidersEnabled(true),
    refreshProviders,
    // bootstrap,
    updateConfig: updateConfigMutation.mutateAsync,
@@ -1,64 +0,0 @@
-import { expect, test } from "bun:test"
-import type { Message, Part, Session, SessionV2Info } from "@opencode-ai/sdk/v2/client"
-import { decodeHomeSessionPage, decodeLegacyMessagePage, decodeLegacySessionList } from "./session-message-decode"
-
-test("decodes and projects a legacy message page", () => {
-  const info = {
-    id: "message",
-    sessionID: "session",
-    role: "user",
-    time: { created: 1 },
-    agent: "build",
-    model: { providerID: "provider", modelID: "model" },
-  } as Message
-  const part = {
-    id: "part",
-    sessionID: "session",
-    messageID: info.id,
-    type: "text",
-    text: "hello",
-  } as Part
-  const result = decodeLegacyMessagePage(new TextEncoder().encode(JSON.stringify([{ info, parts: [part] }])).buffer)
-
-  expect(result.session).toEqual([info])
-  expect(result.part).toEqual([{ id: info.id, part: [part] }])
-  expect(result.source).toEqual([{ id: info.id, type: "user", text: "hello", time: info.time }])
-})
-
-test("decodes and projects a legacy session list", () => {
-  const session = {
-    id: "session",
-    projectID: "project",
-    directory: "/repo",
-    title: "Session",
-    version: "1",
-    time: { created: 1, updated: 1 },
-  } as Session
-  const result = decodeLegacySessionList(new TextEncoder().encode(JSON.stringify([session])).buffer)
-
-  expect(result).toEqual([
-    expect.objectContaining({ id: session.id, title: session.title, location: { directory: "/repo" } }),
-  ])
-})
-
-test("bounds Home sessions by directory before returning from the decoder", () => {
-  const session = (id: string, directory: string, updated: number) =>
-    ({
-      id,
-      projectID: "project",
-      location: { directory },
-      subpath: "",
-      title: id,
-      time: { created: updated, updated },
-    }) as SessionV2Info
-  const page = {
-    data: [session("old", "/repo", 1), session("new", "/repo", 2), session("other", "/other", 3)],
-    cursor: {},
-  }
-  const result = decodeHomeSessionPage(new TextEncoder().encode(JSON.stringify(page)).buffer, {
-    directories: ["/repo"],
-    limit: 1,
-  })
-
-  expect(result.data.map((item) => item.id)).toEqual(["new"])
-})
@@ -1,94 +0,0 @@
-import type { SessionInfo, SessionMessageInfo } from "@opencode-ai/client/promise"
-import type { Message, Part, Session, V2SessionListResponse } from "@opencode-ai/sdk/v2/client"
-import { message as cleanMessage } from "@/utils/diffs"
-import { pathKey } from "@/utils/path-key"
-import { parseHomeSessionIndex } from "./global-sync/home-session-index"
-import { takeRecentSessions } from "./global-sync/session-trim"
-
-export type DecodedLegacyMessagePage = {
-  session: Message[]
-  part: { id: string; part: Part[] }[]
-  source: SessionMessageInfo[]
-}
-
-export function decodeLegacyMessagePage(buffer: ArrayBuffer): DecodedLegacyMessagePage {
-  const text = new TextDecoder().decode(buffer)
-  const items = (text ? (JSON.parse(text) as { info?: Message; parts?: Part[] }[]) : []).filter(
-    (item): item is { info: Message; parts: Part[] } => !!item.info?.id && Array.isArray(item.parts),
-  )
-  return {
-    session: items.map((item) => cleanMessage(item.info)).sort((a, b) => compare(a.id, b.id)),
-    part: items.map((item) => ({
-      id: item.info.id,
-      part: item.parts.filter((part) => !!part?.id).sort((a, b) => compare(a.id, b.id)),
-    })),
-    source: items
-      .slice()
-      .sort((a, b) => compare(a.info.id, b.info.id))
-      .map((item) =>
-        item.info.role === "user"
-          ? {
-              id: item.info.id,
-              type: "user" as const,
-              text: item.parts.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n"),
-              time: item.info.time,
-            }
-          : {
-              id: item.info.id,
-              type: "assistant" as const,
-              agent: item.info.agent ?? item.info.mode,
-              model: { id: item.info.modelID, providerID: item.info.providerID, variant: item.info.variant },
-              content: [],
-              time: item.info.time,
-            },
-      ),
-  }
-}
-
-export function decodeLegacySessionList(buffer: ArrayBuffer) {
-  const text = new TextDecoder().decode(buffer)
-  return (text ? (JSON.parse(text) as Session[]) : []).map(legacySessionInfo)
-}
-
-export function decodeHomeSessionPage(buffer: ArrayBuffer, options?: { directories: string[]; limit: number }) {
-  const text = new TextDecoder().decode(buffer)
-  const page = (text ? JSON.parse(text) : { data: [], cursor: {} }) as V2SessionListResponse
-  const sessions = parseHomeSessionIndex(page.data)
-  if (!options) return { data: sessions, cursor: page.cursor }
-  const directories = new Set(options.directories.map(pathKey))
-  return {
-    data: [...Map.groupBy(sessions, (session) => pathKey(session.directory))]
-      .filter(([directory]) => directories.has(directory))
-      .flatMap(([, items]) => takeRecentSessions(items, options.limit, Number.NEGATIVE_INFINITY)),
-    cursor: page.cursor,
-  }
-}
-
-export function legacySessionInfo(session: Session): SessionInfo {
-  return {
-    id: session.id,
-    parentID: session.parentID,
-    projectID: session.projectID,
-    agent: session.agent,
-    model: session.model && {
-      id: session.model.id,
-      providerID: session.model.providerID,
-      variant: session.model.variant,
-    },
-    cost: session.cost ?? 0,
-    tokens: session.tokens ?? { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    time: session.time,
-    title: session.title,
-    location: { directory: session.directory, workspaceID: session.workspaceID },
-    subpath: session.path,
-    revert: session.revert && {
-      messageID: session.revert.messageID,
-      partID: session.revert.partID,
-      snapshot: session.revert.snapshot,
-    },
-  }
-}
-
-function compare(a: string, b: string) {
-  return a < b ? -1 : a > b ? 1 : 0
-}
@@ -1,56 +0,0 @@
-import type { DecodedLegacyMessagePage } from "./session-message-decode"
-import type { SessionInfo } from "@opencode-ai/client/promise"
-import type { Session } from "@opencode-ai/sdk/v2/client"
-
-type Response = { id: number; data?: unknown; error?: string }
-
-let worker: Worker | undefined
-let nextID = 0
-const pending = new Map<number, { resolve: (value: unknown) => void; reject: (error: Error) => void }>()
-
-export function decodeSessionMessages(buffer: ArrayBuffer) {
-  return decode<DecodedLegacyMessagePage>("messages", buffer)
-}
-
-export function decodeSessionList(buffer: ArrayBuffer) {
-  return decode<SessionInfo[]>("sessions", buffer)
-}
-
-export function decodeHomeSessionPage(buffer: ArrayBuffer, options: { directories: string[]; limit: number }) {
-  return decode<{ data: Session[]; cursor: { next?: string } }>("homeSessions", buffer, options)
-}
-
-function decode<T>(
-  type: "messages" | "sessions" | "homeSessions",
-  buffer: ArrayBuffer,
-  options?: { directories: string[]; limit: number },
-) {
-  const id = ++nextID
-  return new Promise<T>((resolve, reject) => {
-    pending.set(id, { resolve: (value) => resolve(value as T), reject })
-    getWorker().postMessage({ id, type, buffer, options }, [buffer])
-  })
-}
-
-function getWorker() {
-  if (worker) return worker
-  worker = new Worker(new URL("./session-message-decoder.worker.ts", import.meta.url), { type: "module" })
-  worker.onmessage = (event: MessageEvent<Response>) => {
-    const request = pending.get(event.data.id)
-    if (!request) return
-    pending.delete(event.data.id)
-    if (event.data.error) {
-      request.reject(new Error(event.data.error))
-      return
-    }
-    request.resolve(event.data.data)
-  }
-  worker.onerror = (event) => {
-    const error = new Error(event.message)
-    pending.forEach((request) => request.reject(error))
-    pending.clear()
-    worker?.terminate()
-    worker = undefined
-  }
-  return worker
-}
@@ -1,25 +0,0 @@
-import { decodeHomeSessionPage, decodeLegacyMessagePage, decodeLegacySessionList } from "./session-message-decode"
-
-type DecoderRequest = {
-  id: number
-  type: "messages" | "sessions" | "homeSessions"
-  buffer: ArrayBuffer
-  options?: { directories: string[]; limit: number }
-}
-
-self.onmessage = (event: MessageEvent<DecoderRequest>) => {
-  try {
-    self.postMessage({
-      id: event.data.id,
-      data: (() => {
-        if (event.data.type === "messages") return decodeLegacyMessagePage(event.data.buffer)
-        if (event.data.type === "sessions") return decodeLegacySessionList(event.data.buffer)
-        return decodeHomeSessionPage(event.data.buffer, event.data.options)
-      })(),
-    })
-  } catch (error) {
-    self.postMessage({ id: event.data.id, error: error instanceof Error ? error.message : String(error) })
-  }
-}
-
-export {}
@@ -1,43 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { nextTab, previousTab, rememberTab, type TabHistory } from "./tab-history"
-
-function history(): TabHistory {
-  return { stack: [], index: -1 }
-}
-
-describe("tab history", () => {
-  test("moves backward and forward through selected tabs", () => {
-    const selected = ["a", "b", "c"].reduce(rememberTab, history())
-    const available = new Set(selected.stack)
-
-    const previous = previousTab(selected, available)
-    expect(previous?.key).toBe("b")
-
-    const first = previousTab(previous!.state, available)
-    expect(first?.key).toBe("a")
-
-    const next = nextTab(first!.state, available)
-    expect(next?.key).toBe("b")
-  })
-
-  test("replaces forward history after a new selection", () => {
-    const selected = ["a", "b", "c"].reduce(rememberTab, history())
-    const previous = previousTab(selected, new Set(selected.stack))
-    const next = rememberTab(previous!.state, "d")
-
-    expect(next).toEqual({ stack: ["a", "b", "d"], index: 2 })
-    expect(nextTab(next, new Set(next.stack))).toBeUndefined()
-  })
-
-  test("skips tabs that are no longer open", () => {
-    const selected = ["a", "b", "c"].reduce(rememberTab, history())
-
-    expect(previousTab(selected, new Set(["a", "c"]))?.key).toBe("a")
-  })
-
-  test("skips a repeated current tab after closing the previous selection", () => {
-    const selected = ["a", "b", "c", "b"].reduce(rememberTab, history())
-
-    expect(previousTab(selected, new Set(["a", "b"]))?.key).toBe("a")
-  })
-})
@@ -1,28 +0,0 @@
-const MAX_TAB_HISTORY = 100
-
-export type TabHistory = {
-  stack: string[]
-  index: number
-}
-
-export function rememberTab(state: TabHistory, key: string): TabHistory {
-  if (state.stack[state.index] === key) return state
-  const stack = state.stack.slice(0, state.index + 1).concat(key).slice(-MAX_TAB_HISTORY)
-  return { stack, index: stack.length - 1 }
-}
-
-export function previousTab(state: TabHistory, available: Set<string>) {
-  return move(state, -1, available)
-}
-
-export function nextTab(state: TabHistory, available: Set<string>) {
-  return move(state, 1, available)
-}
-
-function move(state: TabHistory, offset: -1 | 1, available: Set<string>) {
-  const current = state.stack[state.index]
-  for (let index = state.index + offset; index >= 0 && index < state.stack.length; index += offset) {
-    const key = state.stack[index]
-    if (key && key !== current && available.has(key)) return { state: { ...state, index }, key }
-  }
-}
@@ -13,7 +13,6 @@ import { createTabMemory } from "./tab-memory"
 import { nextTabAfterClose, pushClosedTab, removeClosedTabs, takeClosedTab, type ClosedTab } from "./closed-tabs"
 import { createDraftPromptSession, type PromptModel } from "./prompt-state"
 import { migrateTabs } from "./tab-migration"
-import { nextTab, previousTab, rememberTab, type TabHistory } from "./tab-history"

 export type SessionTab = {
  type: "session"
@@ -75,7 +74,6 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
    const memory = createTabMemory(getOwner())

    const closing = new Set<string>()
-    let history: TabHistory = { stack: [], index: -1 }
    let recentWrite = 0
    let recentValue: string | undefined

@@ -150,21 +148,10 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({

    const navigateTab = (tab: Tab) => {
      const href = tabHref(tab)
-      history = rememberTab(history, tabKey(tab))
      setRecentKey(tabKey(tab))
      navigate(href)
    }

-    const moveHistory = (direction: "previous" | "next") => {
-      const available = new Set(store.map(tabKey))
-      const result = direction === "previous" ? previousTab(history, available) : nextTab(history, available)
-      if (!result) return
-      const tab = store.find((item) => tabKey(item) === result.key)
-      if (!tab) return
-      history = result.state
-      navigateTab(tab)
-    }
-
    const removeTab = (index: number) => {
      const tab = store[index]
      if (!tab) return
@@ -370,11 +357,8 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
      select: navigateTab,
      remember(tab: Tab) {
        const key = tabKey(tab)
-        history = rememberTab(history, key)
        if (recentKey() !== key) setRecentKey(key)
      },
-      previous: () => moveHistory("previous"),
-      next: () => moveHistory("next"),
      toggleHome(input: { home: boolean; current?: Tab }) {
        if (input.home) {
          const tab = store.find((tab) => tabKey(tab) === recentKey())
@@ -2,17 +2,6 @@ import { describe, expect, test } from "bun:test"
 import { DESKTOP_MENU } from "./desktop-menu"

 describe("desktop menu", () => {
-  test("navigates between tabs", () => {
-    const items = DESKTOP_MENU.flatMap((menu) => menu.items ?? []).filter(
-      (item) => item.type === "item" && (item.command === "tab.prev" || item.command === "tab.next"),
-    )
-
-    expect(items).toEqual([
-      { type: "item", command: "tab.prev", accelerator: { macos: "Option+Up" } },
-      { type: "item", command: "tab.next", accelerator: { macos: "Option+Down" } },
-    ])
-  })
-
  test("exports logs through the desktop command registry", () => {
    const items = DESKTOP_MENU.flatMap((menu) => menu.items ?? []).filter(
      (item) => item.type === "item" && item.labelKey === "desktop.menu.exportLogs",
@@ -237,9 +237,6 @@ export const DESKTOP_MENU: DesktopMenu[] = [
      { type: "item", labelKey: "desktop.menu.back", command: "common.goBack", accelerator: { macos: "Cmd+[" } },
      { type: "item", labelKey: "desktop.menu.forward", command: "common.goForward", accelerator: { macos: "Cmd+]" } },
      { type: "separator" },
-      { type: "item", command: "tab.prev", accelerator: { macos: "Option+Up" } },
-      { type: "item", command: "tab.next", accelerator: { macos: "Option+Down" } },
-      { type: "separator" },
      {
        type: "item",
        labelKey: "desktop.menu.previousSession",
@@ -21,12 +21,6 @@ export function useProviders(directory: Accessor<string | undefined>) {
  const serverSync = useServerSync()
  const params = useParams()
  const dir = () => (directory ? directory() : decode64(params.dir))
-  createEffect(() => {
-    const value = dir()
-    if (value) {
-      serverSync().enableProviders(value)
-    }
-  })
  const providers = () => {
    const value = dir()
    const projectStore = value ? serverSync().child(value)[0] : undefined
@@ -1,16 +1,16 @@
 import type { Session } from "@opencode-ai/sdk/v2/client"
+import { preloadMarkdown } from "@opencode-ai/session-ui/markdown-cache"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { useQuery } from "@tanstack/solid-query"
 import { DateTime } from "luxon"
-import { type Accessor, createEffect, createMemo, createSignal, onCleanup, type JSX, startTransition } from "solid-js"
+import { type Accessor, createEffect, createMemo, createRoot, type JSX, startTransition } from "solid-js"
 import { produce } from "solid-js/store"
 import { useCommand } from "@/context/command"
 import {
-  loadProjectedHomeSessionIndex,
+  loadHomeSessionIndex,
+  retainHomeSessions,
  type HomeSessionEvents,
 } from "@/context/global-sync/home-session-index"
-import { takeRecentSessions } from "@/context/global-sync/session-trim"
-import { decodeHomeSessionPage } from "@/context/session-message-decoder"
 import type { LocalProject } from "@/context/layout"
 import { useLanguage } from "@/context/language"
 import { ServerConnection } from "@/context/server"
@@ -24,7 +24,6 @@ import { archiveHomeSession } from "../home-session-archive"
 import type { HomeController } from "./home-controller"

 const HOME_SESSION_LIMIT = 64
-const HOME_SESSION_RENDER_BATCH = 4
 export type HomeSessionRecord = {
  session: Session
  project: LocalProject
@@ -67,17 +66,8 @@ export function createHomeSessionsController(home: HomeController) {
      if (!ctx) return { sessions: [], eventSequence: 0 }
      const cache = homeSessions()
      const eventSequence = cache.eventSequence()
-      const index = await loadProjectedHomeSessionIndex(
-        async (input, options) => {
-          const response = await ctx.sdk.client.v2.session.list(input, { ...options, parseAs: "arrayBuffer" })
-          if (!(response.data instanceof ArrayBuffer)) throw new Error("Home session response is not an ArrayBuffer")
-          return {
-            data: await decodeHomeSessionPage(response.data, {
-              directories: projectDirectories(),
-              limit: HOME_SESSION_LIMIT,
-            }),
-          }
-        },
+      const index = await loadHomeSessionIndex(
+        (input, options) => ctx.sdk.client.v2.session.list(input, options),
        eventSequence,
        signal,
      )
@@ -89,16 +79,13 @@ export function createHomeSessionsController(home: HomeController) {
    refetchOnMount: true,
    refetchOnReconnect: true,
  }))
-  const indexedSessions = createMemo(() => {
-    const directories = new Set(projectDirectories().map(pathKey))
-    return takeRecentSessions(
-      homeSessions()
-        .sessions(sessionLoad.data, sessionEventLoad.data)
-        .filter((session) => directories.has(pathKey(session.directory))),
+  const indexedSessions = createMemo(() =>
+    retainHomeSessions(
+      homeSessions().sessions(sessionLoad.data, sessionEventLoad.data),
      HOME_SESSION_LIMIT,
-      Number.NEGATIVE_INFINITY,
-    )
-  })
+      Date.now(),
+    ),
+  )
  const allRecords = createMemo(() =>
    buildHomeSessionRecords({
      sessions: indexedSessions,
@@ -107,21 +94,43 @@ export function createHomeSessionsController(home: HomeController) {
      projectByID,
    }),
  )
-  const [visible, setVisible] = createSignal(HOME_SESSION_RENDER_BATCH)
-  let revealFrame: number | undefined
-  createEffect(() => {
-    const count = Math.min(allRecords().length, HOME_SESSION_LIMIT)
-    if (visible() >= count || revealFrame !== undefined) return
-    revealFrame = requestAnimationFrame(() => {
-      revealFrame = undefined
-      setVisible((current) => Math.min(current + HOME_SESSION_RENDER_BATCH, count))
-    })
-  })
-  onCleanup(() => {
-    if (revealFrame !== undefined) cancelAnimationFrame(revealFrame)
-  })
-  const records = createMemo(() => allRecords().slice(0, visible()))
+  const records = createMemo(() => allRecords().slice(0, HOME_SESSION_LIMIT))
  const groups = createMemo(() => groupSessions(records(), language))
+  const prefetched = new Set<string>()
+
+  createEffect(() => {
+    const ctx = home.server.focusedContext()
+    const conn = home.server.focused()
+    if (!ctx || !conn) return
+    records()
+      .slice(0, 2)
+      .forEach((record) => {
+        const key = `${ServerConnection.key(conn)}\0${record.session.id}`
+        if (prefetched.has(key)) return
+        prefetched.add(key)
+        createRoot((dispose) => {
+          try {
+            void ctx.sync.session
+              .sync(record.session.id)
+              .then(() =>
+                Promise.all(
+                  (ctx.sync.session.data.message[record.session.id] ?? []).flatMap((message) =>
+                    (ctx.sync.session.data.part[message.id] ?? []).flatMap((part) => {
+                      if (part.type !== "text" || !part.text) return []
+                      return preloadMarkdown(part.text, part.id)
+                    }),
+                  ),
+                ),
+              )
+              .catch(() => {})
+              .finally(dispose)
+          } catch {
+            dispose()
+          }
+        })
+      })
+  })
+
  command.register("home.palette", () => [
    {
      id: "command.palette",
@@ -1,15 +1,11 @@
-import { createEffect, lazy, Suspense, type ParentProps } from "solid-js"
+import { createEffect, Suspense, type ParentProps } from "solid-js"
 import { createStore } from "solid-js/store"
 import { DebugBar } from "@/components/debug-bar"
-import type { TitlebarUpdate } from "@/components/titlebar"
+import { TabsInfoPopup } from "@/components/help-button"
+import { Titlebar, type TitlebarUpdate } from "@/components/titlebar"
 import { usePlatform } from "@/context/platform"
 import { setV2Toast, ToastRegion } from "@/utils/toast"

-const Titlebar = lazy(() => import("@/components/titlebar").then((module) => ({ default: module.Titlebar })))
-const TabsInfoPopup = lazy(() =>
-  import("@/components/help-button").then((module) => ({ default: module.TabsInfoPopup })),
-)
-
 export default function NewLayout(props: ParentProps) {
  const platform = usePlatform()
  const [state, setState] = createStore({ debugTools: true })
@@ -34,23 +30,19 @@ export default function NewLayout(props: ParentProps) {
        "padding-bottom": "env(safe-area-inset-bottom, 0px)",
      }}
    >
-      <Suspense fallback={<div class="h-10 shrink-0" />}>
-        <Titlebar
-          update={update}
-          debugTools={
-            import.meta.env.DEV
-              ? { visible: state.debugTools, toggle: () => setState("debugTools", (value) => !value) }
-              : undefined
-          }
-        />
-      </Suspense>
+      <Titlebar
+        update={update}
+        debugTools={
+          import.meta.env.DEV
+            ? { visible: state.debugTools, toggle: () => setState("debugTools", (value) => !value) }
+            : undefined
+        }
+      />
      <main class="flex-1 min-h-0 min-w-0 overflow-x-hidden flex flex-col items-start contain-strict">
        <Suspense>{props.children}</Suspense>
      </main>
      {import.meta.env.DEV && state.debugTools && <DebugBar inline />}
-      <Suspense>
-        <TabsInfoPopup />
-      </Suspense>
+      <TabsInfoPopup />
      <ToastRegion v2 />
    </div>
  )
@@ -634,7 +634,7 @@ export default function LegacyLayout(props: ParentProps) {
    running: number
  }

-  const prefetchChunk = 50
+  const prefetchChunk = 200
  const prefetchConcurrency = 2
  const prefetchPendingLimit = 10
  const span = 4
@@ -777,11 +777,18 @@ export default function LegacyLayout(props: ParentProps) {
  }

  createEffect(() => {
-    if (params.id) return
    const sessions = currentSessions()
    if (sessions.length === 0) return
-    const first = sessions[0]
-    if (first) prefetchSession(first, "high")
+
+    const index = params.id ? sessions.findIndex((s) => s.id === params.id) : 0
+    if (index === -1) return
+
+    if (!params.id) {
+      const first = sessions[index]
+      if (first) prefetchSession(first, "high")
+    }
+
+    warm(sessions, index)
  })

  function navigateSessionByOffset(offset: number) {
@@ -143,7 +143,7 @@ function ProviderTip() {
          <TooltipV2
            class="hover-reveal absolute left-full top-0 flex h-6 w-7 items-center justify-end delay-0 duration-0 group-hover/provider-tip:delay-[250ms] group-hover/provider-tip:duration-150 group-hover/provider-tip:opacity-100 focus-within:delay-0 focus-within:duration-0 focus-within:opacity-100"
            placement="top"
-            delay="intent"
+            openDelay={1000}
            value={language.t("common.dismiss")}
          >
            <button
@@ -690,12 +690,8 @@ export default function Page() {
      queryFn: mode
        ? () =>
            sdk()
-              .api.vcs.diff({
-                location: { directory: sdk().directory },
-                mode: mode === "git" ? "working" : mode,
-                context: 0,
-              })
-              .then((result) => result.data.map((diff) => ({ ...diff, patch: "" })))
+              .api.vcs.diff({ location: { directory: sdk().directory }, mode: mode === "git" ? "working" : mode })
+              .then((result) => result.data)
              .catch((error) => {
                console.debug("[session-review] failed to load vcs diff", { mode, error })
                return []
@@ -1,8 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { createApiForServer, createSdkForServer } from "./server"
 import { createCompatibleApi } from "./server-compat"
-import { decodeVcsDiffData } from "./vcs-diff-data"
-import { decodeLegacySessionList } from "@/context/session-message-decode"

 function setup(
  protocol: "v1" | "v2" | Promise<"v1" | "v2">,
@@ -50,8 +48,6 @@ function setup(
    current: createApiForServer({ server, fetch: fetcher }),
    legacy: (directory) => createSdkForServer({ server, fetch: fetcher, directory, throwOnError: true }),
    directory: "/repo",
-    decodeVcsDiff: async (buffer) => decodeVcsDiffData(buffer),
-    decodeSessionList: async (buffer) => decodeLegacySessionList(buffer),
  })
  return { api, requests }
 }
@@ -1,8 +1,7 @@
 import type { ServerApi } from "./server"
 import type { ServerProtocol } from "./server-protocol"
-import type { AgentPartInput, FilePartInput, OpencodeClient, TextPartInput } from "@opencode-ai/sdk/v2/client"
+import type { AgentPartInput, FilePartInput, OpencodeClient, Session, TextPartInput } from "@opencode-ai/sdk/v2/client"
 import type {
-  FileDiffInfo,
  Project,
  ProjectCurrent,
  SessionApi,
@@ -16,7 +15,6 @@ import type {
  SessionShellInput,
  SessionShellOutput,
 } from "@opencode-ai/client/promise"
-import { legacySessionInfo } from "@/context/session-message-decode"

 type LegacyClient = OpencodeClient
 type LegacyFor = (directory?: string) => LegacyClient
@@ -53,8 +51,6 @@ type CompatibleInput = {
  current: ServerApi
  legacy: LegacyFor
  directory?: string
-  decodeVcsDiff: (buffer: ArrayBuffer) => Promise<FileDiffInfo[]>
-  decodeSessionList: (buffer: ArrayBuffer) => Promise<SessionInfo[]>
 }

 function mime(uri: string) {
@@ -62,6 +58,31 @@ function mime(uri: string) {
  return match?.[1] ?? "application/octet-stream"
 }

+function sessionInfo(session: Session): SessionInfo {
+  return {
+    id: session.id,
+    parentID: session.parentID,
+    projectID: session.projectID,
+    agent: session.agent,
+    model: session.model && {
+      id: session.model.id,
+      providerID: session.model.providerID,
+      variant: session.model.variant,
+    },
+    cost: session.cost ?? 0,
+    tokens: session.tokens ?? { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    time: session.time,
+    title: session.title,
+    location: { directory: session.directory, workspaceID: session.workspaceID },
+    subpath: session.path,
+    revert: session.revert && {
+      messageID: session.revert.messageID,
+      partID: session.revert.partID,
+      snapshot: session.revert.snapshot,
+    },
+  }
+}
+
 export function createCompatibleApi(input: CompatibleInput): CompatibleApi {
  const v1 = createV1Api(input)
  return lazyApi(
@@ -127,34 +148,29 @@ function createV1Api(input: CompatibleInput): CompatibleApi {
              search: value.search,
              limit: value.limit,
            },
-            { ...options, parseAs: "arrayBuffer" },
+            options,
          )
-          if (!(result.data instanceof ArrayBuffer)) throw new Error("Session list response is not an ArrayBuffer")
-          return { data: await input.decodeSessionList(result.data), cursor: {} }
+          return { data: (result.data ?? []).map(sessionInfo), cursor: {} }
        }
-        const result = await legacy({ directory: value?.directory }).session.list(
-          {
-            directory: value?.directory,
-            roots: value?.parentID === null ? true : undefined,
-            search: value?.search,
-            limit: value?.limit,
-          },
-          { parseAs: "arrayBuffer" },
-        )
-        if (!(result.data instanceof ArrayBuffer)) throw new Error("Session list response is not an ArrayBuffer")
-        return { data: await input.decodeSessionList(result.data), cursor: {} }
+        const result = await legacy({ directory: value?.directory }).session.list({
+          directory: value?.directory,
+          roots: value?.parentID === null ? true : undefined,
+          search: value?.search,
+          limit: value?.limit,
+        })
+        return { data: (result.data ?? []).map(sessionInfo), cursor: {} }
      },
      async create(value?: Parameters<ServerApi["session"]["create"]>[0]) {
        const result = await legacy(value?.location ?? undefined).session.create({
          directory: directory(value?.location ?? undefined),
        })
        if (!result.data) throw new Error("Failed to create session")
-        return legacySessionInfo(result.data)
+        return sessionInfo(result.data)
      },
      async get(value: Parameters<ServerApi["session"]["get"]>[0]) {
        const result = await legacy().session.get(value)
        if (!result.data) throw new Error(`Session not found: ${value.sessionID}`)
-        return legacySessionInfo(result.data)
+        return sessionInfo(result.data)
      },
      async active() {
        const result = await legacy().session.status()
@@ -176,7 +192,7 @@ function createV1Api(input: CompatibleInput): CompatibleApi {
      async fork(value: Parameters<ServerApi["session"]["fork"]>[0]) {
        const result = await legacy().session.fork(value)
        if (!result.data) throw new Error("Failed to fork session")
-        return legacySessionInfo(result.data)
+        return sessionInfo(result.data)
      },
      async interrupt(value: Parameters<ServerApi["session"]["interrupt"]>[0]) {
        await legacy().session.abort(value)
@@ -325,15 +341,20 @@ function createV1Api(input: CompatibleInput): CompatibleApi {
        return located(result.data ?? [], value?.location)
      },
      async diff(value: Parameters<ServerApi["vcs"]["diff"]>[0]) {
-        const result = await legacy(value.location).vcs.diff(
-          {
-            mode: value.mode === "working" ? "git" : value.mode,
-            context: value.context,
-          },
-          { parseAs: "arrayBuffer" },
+        const result = await legacy(value.location).vcs.diff({
+          mode: value.mode === "working" ? "git" : value.mode,
+          context: value.context,
+        })
+        return located(
+          (result.data ?? []).map((file) => ({
+            file: file.file,
+            patch: file.patch ?? "",
+            additions: file.additions,
+            deletions: file.deletions,
+            status: file.status ?? "modified",
+          })),
+          value.location,
        )
-        if (!(result.data instanceof ArrayBuffer)) throw new Error("VCS diff response is not an ArrayBuffer")
-        return located(await input.decodeVcsDiff(result.data), value.location)
      },
    },
    file: {
@@ -1,20 +0,0 @@
-import type { FileDiffInfo } from "@opencode-ai/client/promise"
-
-export function decodeVcsDiffData(buffer: ArrayBuffer): FileDiffInfo[] {
-  const text = new TextDecoder().decode(buffer)
-  return (text ? JSON.parse(text) : []).map(
-    (file: {
-      file: string
-      patch?: string
-      additions: number
-      deletions: number
-      status?: "added" | "deleted" | "modified"
-    }) => ({
-      file: file.file,
-      patch: file.patch ?? "",
-      additions: file.additions,
-      deletions: file.deletions,
-      status: file.status ?? "modified",
-    }),
-  )
-}
@@ -1,60 +0,0 @@
-import type { FileDiffInfo } from "@opencode-ai/client/promise"
-
-type Response = { id: number; data?: FileDiffInfo[]; error?: string }
-
-let worker: Worker | undefined
-let nextID = 0
-const pending = new Map<number, { resolve: (value: FileDiffInfo[]) => void; reject: (error: Error) => void }>()
-let lastInput = 0
-document.addEventListener(
-  "beforeinput",
-  () => {
-    lastInput = performance.now()
-  },
-  { capture: true },
-)
-
-export function decodeVcsDiff(buffer: ArrayBuffer) {
-  const id = ++nextID
-  return new Promise<FileDiffInfo[]>((resolve, reject) => {
-    pending.set(id, { resolve, reject })
-    getWorker().postMessage({ id, buffer }, [buffer])
-  })
-}
-
-function getWorker() {
-  if (worker) return worker
-  worker = new Worker(new URL("./vcs-diff-decoder.worker.ts", import.meta.url), { type: "module" })
-  worker.onmessage = (event: MessageEvent<Response>) => {
-    const request = pending.get(event.data.id)
-    if (!request) return
-    pending.delete(event.data.id)
-    if (event.data.error) {
-      request.reject(new Error(event.data.error))
-      return
-    }
-    resolveWhenInputIdle(request.resolve, event.data.data ?? [])
-  }
-  worker.onerror = (event) => {
-    const error = new Error(event.message)
-    pending.forEach((request) => request.reject(error))
-    pending.clear()
-    worker?.terminate()
-    worker = undefined
-  }
-  return worker
-}
-
-function resolveWhenInputIdle(resolve: (value: FileDiffInfo[]) => void, value: FileDiffInfo[], initial = true) {
-  const active = document.activeElement
-  const editing =
-    active instanceof HTMLInputElement ||
-    active instanceof HTMLTextAreaElement ||
-    (active instanceof HTMLElement && active.isContentEditable)
-  const delay = Math.max(lastInput + 100 - performance.now(), initial && editing ? 100 : 0)
-  if (delay <= 0) {
-    resolve(value)
-    return
-  }
-  setTimeout(() => resolveWhenInputIdle(resolve, value, false), delay)
-}
@@ -1,13 +0,0 @@
-import { decodeVcsDiffData } from "./vcs-diff-data"
-
-type Request = { id: number; buffer: ArrayBuffer }
-
-self.onmessage = (event: MessageEvent<Request>) => {
-  try {
-    self.postMessage({ id: event.data.id, data: decodeVcsDiffData(event.data.buffer) })
-  } catch (error) {
-    self.postMessage({ id: event.data.id, error: error instanceof Error ? error.message : String(error) })
-  }
-}
-
-export {}
@@ -142,11 +142,8 @@ const main = Effect.gen(function* () {
  app.setAppUserModelId(appId)
  app.setPath(
    "userData",
-    process.env.OPENCODE_PROFILE_USER_DATA ??
-      (onboardingTestRoot ? join(onboardingTestRoot, "desktop") : join(app.getPath("appData"), appId)),
+    onboardingTestRoot ? join(onboardingTestRoot, "desktop") : join(app.getPath("appData"), appId),
  )
-  if (process.env.OPENCODE_PROFILE_USER_DATA)
-    app.setPath("sessionData", join(process.env.OPENCODE_PROFILE_USER_DATA, "session"))
  if (onboardingTestRoot) app.setPath("sessionData", join(onboardingTestRoot, "session"))
  initializeOldLayoutEligibility(app.getPath("userData"))
  logger = initLogging()
@@ -194,16 +191,9 @@ const main = Effect.gen(function* () {
  ensureLoopbackNoProxy()
  useEnvProxy()
  app.commandLine.appendSwitch("proxy-bypass-list", "<-loopback>")
-  const features = [
-    jsCallStackFeature,
-    process.env.OPENCODE_PROFILE_LOAF === "1" ? "AlwaysLogLOAFURL" : "",
-    app.commandLine.getSwitchValue("enable-features"),
-  ]
-    .filter(Boolean)
-    .join(",")
-  app.commandLine.appendSwitch("enable-features", features)
-  if (!app.isPackaged)
-    app.commandLine.appendSwitch("remote-debugging-port", process.env.OPENCODE_PROFILE_CDP_PORT ?? "9222")
+  const features = app.commandLine.getSwitchValue("enable-features")
+  app.commandLine.appendSwitch("enable-features", features ? `${jsCallStackFeature},${features}` : jsCallStackFeature)
+  if (!app.isPackaged) app.commandLine.appendSwitch("remote-debugging-port", "9222")

  if (!app.requestSingleInstanceLock()) {
    app.quit()
@@ -1,7 +1,62 @@
 import * as i18n from "@solid-primitives/i18n"

 import { dict as desktopEn } from "./en"
+import { dict as desktopZh } from "./zh"
+import { dict as desktopZht } from "./zht"
+import { dict as desktopKo } from "./ko"
+import { dict as desktopDe } from "./de"
+import { dict as desktopEs } from "./es"
+import { dict as desktopFr } from "./fr"
+import { dict as desktopDa } from "./da"
+import { dict as desktopJa } from "./ja"
+import { dict as desktopPl } from "./pl"
+import { dict as desktopRu } from "./ru"
+import { dict as desktopUk } from "./uk"
+import { dict as desktopAr } from "./ar"
+import { dict as desktopNo } from "./no"
+import { dict as desktopBr } from "./br"
+import { dict as desktopBs } from "./bs"
+import { dict as desktopTr } from "./tr"
+import { dict as desktopHi } from "./hi"
+import { dict as desktopNl } from "./nl"
+import { dict as desktopId } from "./id"
+import { dict as desktopVi } from "./vi"
+import { dict as desktopIt } from "./it"
+import { dict as desktopUr } from "./ur"
+import { dict as desktopPa } from "./pa"
+import { dict as desktopAz } from "./az"
+import { dict as desktopFi } from "./fi"
+import { dict as desktopSv } from "./sv"
+import { dict as desktopTh } from "./th"
+
 import { dict as appEn } from "../../../../app/src/i18n/en"
+import { dict as appZh } from "../../../../app/src/i18n/zh"
+import { dict as appZht } from "../../../../app/src/i18n/zht"
+import { dict as appKo } from "../../../../app/src/i18n/ko"
+import { dict as appDe } from "../../../../app/src/i18n/de"
+import { dict as appEs } from "../../../../app/src/i18n/es"
+import { dict as appFr } from "../../../../app/src/i18n/fr"
+import { dict as appDa } from "../../../../app/src/i18n/da"
+import { dict as appJa } from "../../../../app/src/i18n/ja"
+import { dict as appPl } from "../../../../app/src/i18n/pl"
+import { dict as appRu } from "../../../../app/src/i18n/ru"
+import { dict as appUk } from "../../../../app/src/i18n/uk"
+import { dict as appAr } from "../../../../app/src/i18n/ar"
+import { dict as appNo } from "../../../../app/src/i18n/no"
+import { dict as appBr } from "../../../../app/src/i18n/br"
+import { dict as appBs } from "../../../../app/src/i18n/bs"
+import { dict as appTr } from "../../../../app/src/i18n/tr"
+import { dict as appHi } from "../../../../app/src/i18n/hi"
+import { dict as appNl } from "../../../../app/src/i18n/nl"
+import { dict as appId } from "../../../../app/src/i18n/id"
+import { dict as appVi } from "../../../../app/src/i18n/vi"
+import { dict as appIt } from "../../../../app/src/i18n/it"
+import { dict as appUr } from "../../../../app/src/i18n/ur"
+import { dict as appPa } from "../../../../app/src/i18n/pa"
+import { dict as appAz } from "../../../../app/src/i18n/az"
+import { dict as appFi } from "../../../../app/src/i18n/fi"
+import { dict as appSv } from "../../../../app/src/i18n/sv"
+import { dict as appTh } from "../../../../app/src/i18n/th"

 export type Locale =
  | "en"
@@ -162,40 +217,35 @@ function pickLocale(value: unknown): Locale | null {

 const base = i18n.flatten({ ...appEn, ...desktopEn })

-const loaders = {
-  zh: () => Promise.all([import("../../../../app/src/i18n/zh"), import("./zh")]),
-  zht: () => Promise.all([import("../../../../app/src/i18n/zht"), import("./zht")]),
-  ko: () => Promise.all([import("../../../../app/src/i18n/ko"), import("./ko")]),
-  de: () => Promise.all([import("../../../../app/src/i18n/de"), import("./de")]),
-  es: () => Promise.all([import("../../../../app/src/i18n/es"), import("./es")]),
-  fr: () => Promise.all([import("../../../../app/src/i18n/fr"), import("./fr")]),
-  da: () => Promise.all([import("../../../../app/src/i18n/da"), import("./da")]),
-  ja: () => Promise.all([import("../../../../app/src/i18n/ja"), import("./ja")]),
-  pl: () => Promise.all([import("../../../../app/src/i18n/pl"), import("./pl")]),
-  ru: () => Promise.all([import("../../../../app/src/i18n/ru"), import("./ru")]),
-  uk: () => Promise.all([import("../../../../app/src/i18n/uk"), import("./uk")]),
-  ar: () => Promise.all([import("../../../../app/src/i18n/ar"), import("./ar")]),
-  no: () => Promise.all([import("../../../../app/src/i18n/no"), import("./no")]),
-  br: () => Promise.all([import("../../../../app/src/i18n/br"), import("./br")]),
-  bs: () => Promise.all([import("../../../../app/src/i18n/bs"), import("./bs")]),
-  tr: () => Promise.all([import("../../../../app/src/i18n/tr"), import("./tr")]),
-  hi: () => Promise.all([import("../../../../app/src/i18n/hi"), import("./hi")]),
-  nl: () => Promise.all([import("../../../../app/src/i18n/nl"), import("./nl")]),
-  id: () => Promise.all([import("../../../../app/src/i18n/id"), import("./id")]),
-  vi: () => Promise.all([import("../../../../app/src/i18n/vi"), import("./vi")]),
-  it: () => Promise.all([import("../../../../app/src/i18n/it"), import("./it")]),
-  ur: () => Promise.all([import("../../../../app/src/i18n/ur"), import("./ur")]),
-  pa: () => Promise.all([import("../../../../app/src/i18n/pa"), import("./pa")]),
-  az: () => Promise.all([import("../../../../app/src/i18n/az"), import("./az")]),
-  fi: () => Promise.all([import("../../../../app/src/i18n/fi"), import("./fi")]),
-  sv: () => Promise.all([import("../../../../app/src/i18n/sv"), import("./sv")]),
-  th: () => Promise.all([import("../../../../app/src/i18n/th"), import("./th")]),
-}
-
-async function build(locale: Locale): Promise<Dictionary> {
+function build(locale: Locale): Dictionary {
  if (locale === "en") return base
-  const dictionaries = await loaders[locale]()
-  return { ...base, ...i18n.flatten(dictionaries[0].dict), ...i18n.flatten(dictionaries[1].dict) }
+  if (locale === "zh") return { ...base, ...i18n.flatten(appZh), ...i18n.flatten(desktopZh) }
+  if (locale === "zht") return { ...base, ...i18n.flatten(appZht), ...i18n.flatten(desktopZht) }
+  if (locale === "de") return { ...base, ...i18n.flatten(appDe), ...i18n.flatten(desktopDe) }
+  if (locale === "es") return { ...base, ...i18n.flatten(appEs), ...i18n.flatten(desktopEs) }
+  if (locale === "fr") return { ...base, ...i18n.flatten(appFr), ...i18n.flatten(desktopFr) }
+  if (locale === "da") return { ...base, ...i18n.flatten(appDa), ...i18n.flatten(desktopDa) }
+  if (locale === "ja") return { ...base, ...i18n.flatten(appJa), ...i18n.flatten(desktopJa) }
+  if (locale === "pl") return { ...base, ...i18n.flatten(appPl), ...i18n.flatten(desktopPl) }
+  if (locale === "ru") return { ...base, ...i18n.flatten(appRu), ...i18n.flatten(desktopRu) }
+  if (locale === "uk") return { ...base, ...i18n.flatten(appUk), ...i18n.flatten(desktopUk) }
+  if (locale === "ar") return { ...base, ...i18n.flatten(appAr), ...i18n.flatten(desktopAr) }
+  if (locale === "no") return { ...base, ...i18n.flatten(appNo), ...i18n.flatten(desktopNo) }
+  if (locale === "br") return { ...base, ...i18n.flatten(appBr), ...i18n.flatten(desktopBr) }
+  if (locale === "bs") return { ...base, ...i18n.flatten(appBs), ...i18n.flatten(desktopBs) }
+  if (locale === "tr") return { ...base, ...i18n.flatten(appTr), ...i18n.flatten(desktopTr) }
+  if (locale === "hi") return { ...base, ...i18n.flatten(appHi), ...i18n.flatten(desktopHi) }
+  if (locale === "nl") return { ...base, ...i18n.flatten(appNl), ...i18n.flatten(desktopNl) }
+  if (locale === "id") return { ...base, ...i18n.flatten(appId), ...i18n.flatten(desktopId) }
+  if (locale === "vi") return { ...base, ...i18n.flatten(appVi), ...i18n.flatten(desktopVi) }
+  if (locale === "it") return { ...base, ...i18n.flatten(appIt), ...i18n.flatten(desktopIt) }
+  if (locale === "ur") return { ...base, ...i18n.flatten(appUr), ...i18n.flatten(desktopUr) }
+  if (locale === "pa") return { ...base, ...i18n.flatten(appPa), ...i18n.flatten(desktopPa) }
+  if (locale === "az") return { ...base, ...i18n.flatten(appAz), ...i18n.flatten(desktopAz) }
+  if (locale === "fi") return { ...base, ...i18n.flatten(appFi), ...i18n.flatten(desktopFi) }
+  if (locale === "sv") return { ...base, ...i18n.flatten(appSv), ...i18n.flatten(desktopSv) }
+  if (locale === "th") return { ...base, ...i18n.flatten(appTh), ...i18n.flatten(desktopTh) }
+  return { ...base, ...i18n.flatten(appKo), ...i18n.flatten(desktopKo) }
 }

 const state = {
@@ -204,6 +254,8 @@ const state = {
  init: undefined as Promise<Locale> | undefined,
 }

+state.dict = build(state.locale)
+
 const translate = i18n.translator(() => state.dict, i18n.resolveTemplate)

 export function t(key: keyof Dictionary, params?: Record<string, string | number>) {
@@ -220,7 +272,7 @@ export function initI18n(): Promise<Locale> {
    const next = pickLocale(value) ?? state.locale

    state.locale = next
-    state.dict = await build(next)
+    state.dict = build(next)
    return next
  })().catch(() => state.locale)

@@ -22,7 +22,7 @@ import { createMemoryHistory, MemoryRouter, type BaseRouterProps } from "@solidj
 import { createEffect, createMemo, createResource, createSignal, onCleanup, Show } from "solid-js"
 import { render } from "solid-js/web"
 import pkg from "../../package.json"
-import { initI18n, t } from "./i18n"
+import { t } from "./i18n"
 import { initializationData } from "./initialization"
 import { DesktopFirstLaunchOnboarding } from "./onboarding"
 import { resetZoom, setPinchZoomEnabled, webviewZoom, zoomIn, zoomOut } from "./webview-zoom"
@@ -60,8 +60,6 @@ if (import.meta.env.VITE_SENTRY_DSN) {
  })
 }

-void initI18n()
-
 const [updaterState, setUpdaterState] = createSignal<UpdaterState>({ status: "disabled" })
 void window.api.updater.subscribe(setUpdaterState)

@@ -636,14 +636,30 @@ const layer = Layer.effect(
          yield* Effect.gen(function* () {
            ctx.currentText = undefined
            ctx.reasoningMap = {}
+            let generated = false
            yield* status.set(ctx.sessionID, { type: "busy" })
            const stream = llm.stream(streamInput)

            yield* stream.pipe(
-              Stream.tap((event) => handleEvent(event)),
+              Stream.tap((event) => {
+                if (
+                  (event.type === "text-delta" && event.text.length > 0) ||
+                  (event.type === "reasoning-delta" && event.text.length > 0) ||
+                  event.type === "tool-input-start" ||
+                  event.type === "tool-call"
+                ) {
+                  generated = true
+                }
+                return handleEvent(event)
+              }),
              Stream.takeUntil(() => ctx.needsCompaction),
              Stream.runDrain,
            )
+            if (ctx.assistantMessage.finish === "unknown" && !generated) {
+              yield* new SessionRetry.EmptyResponseError({
+                message: "The model returned an empty response with an unknown finish reason",
+              })
+            }
          }).pipe(
            Effect.onInterrupt(() =>
              Effect.gen(function* () {
@@ -1,6 +1,6 @@
 import type { NamedError } from "@opencode-ai/core/util/error"
 import { SessionV1 } from "@opencode-ai/core/v1/session"
-import { Cause, Clock, Duration, Effect, Schedule } from "effect"
+import { Cause, Clock, Duration, Effect, Schedule, Schema } from "effect"
 import { MessageV2 } from "./message-v2"
 import { iife } from "@/util/iife"
 import { isRecord } from "@/util/record"
@@ -23,6 +23,10 @@ export type Retryable = {
  }
 }

+export class EmptyResponseError extends Schema.TaggedErrorClass<EmptyResponseError>()("SessionEmptyResponseError", {
+  message: Schema.String,
+}) {}
+
 export const RETRY_INITIAL_DELAY = 2000
 export const RETRY_BACKOFF_FACTOR = 2
 export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
@@ -181,7 +185,8 @@ export function policy(opts: {
  return Schedule.fromStepWithMetadata(
    Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
      const error = opts.parse(meta.input)
-      const retry = retryable(error, opts.provider)
+      const retry =
+        meta.input instanceof EmptyResponseError ? { message: meta.input.message } : retryable(error, opts.provider)
      if (!retry) return Cause.done(meta.attempt)
      return Effect.gen(function* () {
        const wait = delay(meta.attempt, SessionV1.APIError.isInstance(error) ? error : undefined)
@@ -81,11 +81,11 @@ describe("opencode run (non-interactive subprocess)", () => {
    30_000,
  )

-  // The test provider's SSE error item is interpreted by the SDK as an unknown
-  // finish, not a fatal provider/session error. Lock that distinction in so it
-  // is not accidentally used as the failure compatibility oracle.
+  // The test provider's SSE error item is interpreted by the SDK as an empty
+  // response with an unknown finish. That attempt should retry while preserving
+  // output from the preceding tool-call step.
  cliIt.concurrent(
-    "unknown stream finish preserves partial output and exits 0",
+    "empty unknown stream finish retries and preserves partial output",
    ({ llm, opencode }) =>
      Effect.gen(function* () {
        yield* llm.push(
@@ -95,9 +95,10 @@ describe("opencode run (non-interactive subprocess)", () => {
          }),
        )
        yield* llm.fail("upstream provider exploded mid-stream")
+        yield* llm.text("recovered response")
        const result = yield* opencode.run("trigger midstream error", { timeoutMs: 30_000 })
        expect(result.exitCode).toBe(0)
-        expect(result.stdout).toBe("partial response\n")
+        expect(result.stdout).toBe("partial response\nrecovered response\n")
        expect(result.stderr).not.toContain("upstream provider exploded mid-stream")
      }),
    60_000,
@@ -213,7 +214,7 @@ describe("opencode run (non-interactive subprocess)", () => {
  )

  cliIt.concurrent(
-    "--format json records partial output for an unknown stream finish",
+    "--format json records an empty unknown stream retry",
    ({ llm, opencode }) =>
      Effect.gen(function* () {
        yield* llm.push(
@@ -223,6 +224,7 @@ describe("opencode run (non-interactive subprocess)", () => {
          }),
        )
        yield* llm.fail("provider failed")
+        yield* llm.text("recovered json")
        const result = yield* opencode.run("fail after output", { format: "json" })

        const events = opencode.parseJsonEvents(result.stdout)
@@ -234,9 +236,13 @@ describe("opencode run (non-interactive subprocess)", () => {
          "step_finish",
          "step_start",
          "step_finish",
+          "step_start",
+          "text",
+          "step_finish",
        ])
        expect(events[1]?.part).toEqual(expect.objectContaining({ type: "text", text: "partial json" }))
-        expect(events.at(-1)?.part).toEqual(expect.objectContaining({ type: "step-finish", reason: "unknown" }))
+        expect(events.at(-2)?.part).toEqual(expect.objectContaining({ type: "text", text: "recovered json" }))
+        expect(events.at(-1)?.part).toEqual(expect.objectContaining({ type: "step-finish", reason: "stop" }))
      }),
    60_000,
  )
@@ -604,6 +604,68 @@ it.live("session.processor effect tests retry recognized structured json errors"
  ),
 )

+it.live("session.processor effect tests retry empty responses with unknown finish reasons", () =>
+  provideTmpdirServer(
+    ({ dir, llm }) =>
+      Effect.gen(function* () {
+        const { processors, session, provider } = yield* boot()
+
+        yield* llm.push(
+          raw({
+            chunks: [
+              {
+                id: "chatcmpl-test",
+                object: "chat.completion.chunk",
+                choices: [{ delta: { role: "assistant" }, finish_reason: null }],
+              },
+              {
+                id: "chatcmpl-test",
+                object: "chat.completion.chunk",
+                choices: [{ delta: {}, finish_reason: "unknown_reason" }],
+              },
+            ],
+          }),
+          reply().text("after").stop(),
+        )
+
+        const chat = yield* session.create({})
+        const parent = yield* user(chat.id, "retry empty")
+        const msg = yield* assistant(chat.id, parent.id, path.resolve(dir))
+        const mdl = yield* provider.getModel(ref.providerID, ref.modelID)
+        const handle = yield* processors.create({
+          assistantMessage: msg,
+          sessionID: chat.id,
+          model: mdl,
+        })
+
+        const value = yield* handle.process({
+          user: {
+            id: parent.id,
+            sessionID: chat.id,
+            role: "user",
+            time: parent.time,
+            agent: parent.agent,
+            model: { providerID: ref.providerID, modelID: ref.modelID },
+          } satisfies SessionV1.User,
+          sessionID: chat.id,
+          model: mdl,
+          agent: agent(),
+          system: [],
+          messages: [{ role: "user", content: "retry empty" }],
+          tools: {},
+        })
+
+        const parts = yield* MessageV2.parts(msg.id)
+
+        expect(value).toBe("continue")
+        expect(yield* llm.calls).toBe(2)
+        expect(parts.some((part) => part.type === "text" && part.text === "after")).toBe(true)
+        expect(handle.message.error).toBeUndefined()
+      }),
+    { config: (url) => providerCfg(url) },
+  ),
+)
+
 it.live("session.processor effect tests publish retry status updates", () =>
  provideTmpdirServer(
    ({ dir, llm }) =>
@@ -158,12 +158,6 @@ describe("markdown stream", () => {
    expect(final.blocks[2]).toEqual({ raw: "- final item", src: "- final item", mode: "full" })
  })

-  test("splits completed markdown into bounded top-level blocks", () => {
-    const result = project(undefined, "# Plan\n\nFirst paragraph.\n\nSecond paragraph.", false)
-
-    expect(result.blocks.map((block) => block.raw)).toEqual(["# Plan", "First paragraph.", "Second paragraph."])
-  })
-
  test("catches up paced text before finalizing", () => {
    const live = project(undefined, "# Plan\n\nFinished paragraph.\n\n- final", true)
    const final = project(live, `${live.text} item`, false)
@@ -51,7 +51,7 @@ function heal(text: string) {
 }

 export function stream(text: string, live: boolean): Block[] {
-  if (!live) return completedBlocks(text)
+  if (!live) return completedProjection(text).blocks
  if (refs(text)) return [{ raw: text, src: heal(text), mode: "live" }] satisfies Block[]
  const tokens = marked.lexer(text)
  const tail = tokens.findLastIndex((token) => token.type !== "space")
@@ -85,17 +85,6 @@ export function stream(text: string, live: boolean): Block[] {
  return [...result, { raw, src: openCode(code.raw), mode: "code", language: language(code.lang) }]
 }

-function completedBlocks(text: string) {
-  if (refs(text)) return completedProjection(text).blocks
-  const tokens = marked.lexer(text)
-  return tokens.flatMap((token): Block[] => {
-    if (token.type === "space") return []
-    if (token.type !== "code") return [{ raw: token.raw, src: token.raw, mode: "full" }]
-    const code = token as Tokens.Code
-    return [{ raw: code.raw, src: code.text, mode: "code", language: language(code.lang), complete: true }]
-  })
-}
-
 export function project(previous: Projection | undefined, text: string, live: boolean): Projection {
  if (!live) {
    const current =
@@ -104,7 +93,7 @@ export function project(previous: Projection | undefined, text: string, live: bo
        : previous && text.startsWith(previous.text)
          ? project(previous, text, true)
          : undefined
-    if (!current) return { text, blocks: completedBlocks(text) }
+    if (!current) return completedProjection(text)
    return {
      text,
      blocks: current.blocks.map((block) => {
@@ -491,8 +491,6 @@ export function Markdown(
  )

  let copyCleanup: (() => void) | undefined
-  let renderFrame: number | undefined
-  let renderGeneration = 0

  createEffect(() => {
    const container = root()
@@ -501,9 +499,6 @@ export function Markdown(
    const content = local.text ? pendingBlocks(result, projected, local.cacheKey, owner) : []
    if (!container) return
    if (isServer) return
-    const generation = ++renderGeneration
-    if (renderFrame !== undefined) cancelAnimationFrame(renderFrame)
-    renderFrame = undefined
    if (content.length === 0) {
      disposeCopyButtons(container)
      container.innerHTML = ""
@@ -520,40 +515,24 @@ export function Markdown(
    })
    activeCodeKeys.clear()
    nextCodeKeys.forEach((key) => activeCodeKeys.add(key))
-    let index = 0
-    const update = () => {
-      renderFrame = undefined
-      if (generation !== renderGeneration) return
-      const deadline = performance.now() + 8
-      while (index < content.length && performance.now() < deadline) {
-        updateBlock(container, index, content[index]!, labels)
-        index += 1
-      }
-      if (index < content.length) {
-        renderFrame = requestAnimationFrame(update)
-        return
-      }
-      while (container.children.length > content.length) {
-        const child = container.lastElementChild
-        if (!child) break
-        disposeCopyButtons(child)
-        child.remove()
-      }
-      container
-        .querySelectorAll<HTMLElement>('[data-slot="markdown-copy-button"]')
-        .forEach((button) => setCopyState(button, labels, button.dataset.copied === "true"))
-      if (!copyCleanup)
-        copyCleanup = setupCodeCopy(container, () => ({
-          copy: i18n.t("ui.message.copy"),
-          copied: i18n.t("ui.message.copied"),
-        }))
+    content.forEach((block, index) => updateBlock(container, index, block, labels))
+    while (container.children.length > content.length) {
+      const child = container.lastElementChild
+      if (!child) break
+      disposeCopyButtons(child)
+      child.remove()
    }
-    update()
+    container
+      .querySelectorAll<HTMLElement>('[data-slot="markdown-copy-button"]')
+      .forEach((button) => setCopyState(button, labels, button.dataset.copied === "true"))
+    if (!copyCleanup)
+      copyCleanup = setupCodeCopy(container, () => ({
+        copy: i18n.t("ui.message.copy"),
+        copied: i18n.t("ui.message.copied"),
+      }))
  })

  onCleanup(() => {
-    renderGeneration += 1
-    if (renderFrame !== undefined) cancelAnimationFrame(renderFrame)
    if (copyCleanup) copyCleanup()
    disposeMarkdownProjection(owner)
    activeCodeKeys.forEach(disposeCode)
@@ -61,7 +61,6 @@ import { TextShimmer } from "@opencode-ai/ui/text-shimmer"
 import { AnimatedCountList } from "./tool-count-summary"
 import { ToolStatusTitle } from "./tool-status-title"
 import { patchFiles } from "./apply-patch-file"
-import { partDefaultOpen } from "./part-default-open"
 import { animate } from "motion"
 import { attached, inline, kind, typeLabel } from "./message-file"
 import { readPartText } from "./message-part-text"
@@ -719,7 +718,15 @@ export function renderable(part: PartType, showReasoningSummaries = true) {
  return !!PART_MAPPING[part.type]
 }

-export { partDefaultOpen } from "./part-default-open"
+function toolDefaultOpen(tool: string, shell = false, edit = false) {
+  if (tool === "bash" || tool === "shell") return shell
+  if (tool === "edit" || tool === "write" || tool === "patch" || tool === "apply_patch") return edit
+}
+
+export function partDefaultOpen(part: PartType, shell = false, edit = false) {
+  if (part.type !== "tool") return
+  return toolDefaultOpen(part.tool, shell, edit)
+}

 export function AssistantParts(props: {
  messages: AssistantMessage[]
@@ -1,66 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { Part as PartType } from "@opencode-ai/sdk/v2"
-import { partDefaultOpen } from "./part-default-open"
-
-describe("partDefaultOpen", () => {
-  test("keeps edited files expanded when enabled", () => {
-    expect(partDefaultOpen(tool("edit", { filediff: { additions: 1, deletions: 1 } }), false, true)).toBe(true)
-  })
-
-  test("collapses deletion-only edits when enabled", () => {
-    expect(partDefaultOpen(tool("edit", { filediff: { additions: 0, deletions: 1_200 } }), false, true)).toBe(false)
-  })
-
-  test("collapses patches containing only deleted files when enabled", () => {
-    expect(
-      partDefaultOpen(
-        tool("apply_patch", {
-          files: [
-            { filePath: "one.ts", type: "delete" },
-            { filePath: "two.ts", type: "delete" },
-          ],
-        }),
-        false,
-        true,
-      ),
-    ).toBe(false)
-  })
-
-  test("keeps mixed patches expanded when enabled", () => {
-    expect(
-      partDefaultOpen(
-        tool("apply_patch", {
-          files: [
-            { filePath: "one.ts", type: "delete" },
-            { filePath: "two.ts", type: "update" },
-          ],
-        }),
-        false,
-        true,
-      ),
-    ).toBe(true)
-  })
-
-  test("preserves shell defaults", () => {
-    expect(partDefaultOpen(tool("shell", {}), true, false)).toBe(true)
-  })
-})
-
-function tool(name: string, metadata: Record<string, unknown>): PartType {
-  return {
-    id: `part_${name}`,
-    sessionID: "session",
-    messageID: "message",
-    type: "tool",
-    callID: `call_${name}`,
-    tool: name,
-    state: {
-      status: "completed",
-      input: {},
-      output: "",
-      title: name,
-      metadata,
-      time: { start: 0, end: 1 },
-    },
-  }
-}
@@ -1,26 +0,0 @@
-import type { Part as PartType, ToolPart } from "@opencode-ai/sdk/v2"
-
-function deletionOnly(part: ToolPart) {
-  if (!("metadata" in part.state)) return false
-  const metadata = part.state.metadata
-  if (!metadata) return false
-
-  const files = metadata.files
-  if (Array.isArray(files) && files.length > 0) {
-    return files.every((file) => !!file && typeof file === "object" && "type" in file && file.type === "delete")
-  }
-
-  const filediff = metadata.filediff
-  if (!filediff || typeof filediff !== "object") return false
-  if (!("additions" in filediff) || !("deletions" in filediff)) return false
-  return filediff.additions === 0 && typeof filediff.deletions === "number" && filediff.deletions > 0
-}
-
-export function partDefaultOpen(part: PartType, shell = false, edit = false) {
-  if (part.type !== "tool") return
-  if (part.tool === "bash" || part.tool === "shell") return shell
-  if (part.tool === "edit" || part.tool === "write" || part.tool === "patch" || part.tool === "apply_patch") {
-    if (!edit) return false
-    return !deletionOnly(part)
-  }
-}
@@ -24,7 +24,7 @@ function createPool(lineDiffType: "none" | "word-alt") {
    {
      theme: "OpenCode",
      lineDiffType,
-      preferredHighlighter: "shiki-js",
+      preferredHighlighter: "shiki-wasm",
    },
  )

@@ -32,6 +32,7 @@ export function CommentCardV2(props: {
  return (
    <TooltipV2
      placement="top"
+      openDelay={1000}
      value={props.title ?? props.comment}
      disabled={!props.tooltip || !truncated()}
      class={props.wide ? "w-full" : undefined}
@@ -52,11 +52,9 @@ export function PromptInputV2(props: PromptInputV2Props) {
  const view = props.controller.view
  let editor: HTMLDivElement | undefined
  let localInput = false
-  const updateCursor = (event: KeyboardEvent | PointerEvent) => {
+  const updateCursor = () => {
    if (!editor || !window.getSelection()?.isCollapsed) return
-    if (event instanceof KeyboardEvent && !["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"].includes(event.key))
-      return
-    props.controller.onCursor(parsePromptInputV2Editor(editor).cursor)
+    props.controller.onCursor(promptInputV2Cursor(editor))
  }
  const mode = createMemo(() => state.mode)
  const buttons = createMemo(() => ({
@@ -165,7 +163,8 @@ export function PromptInputV2(props: PromptInputV2Props) {
            class="relative z-10 block min-h-[60px] max-h-[180px] w-full overflow-y-auto whitespace-pre-wrap bg-transparent px-4 pt-4 pb-2 text-[13px] font-[440] leading-5 text-v2-text-text-base focus:outline-none empty:before:content-['\200B'] [&_[data-mention=file]]:text-syntax-property [&_[data-mention=agent]]:text-syntax-type [&_[data-mention=reference]]:text-syntax-keyword"
            classList={{ "font-mono!": state.mode === "shell", "opacity-50": props.disabled }}
            onInput={(event) => {
-              const { prompt, cursor } = parsePromptInputV2Editor(event.currentTarget)
+              const cursor = promptInputV2Cursor(event.currentTarget)
+              const prompt = parsePromptInputV2Editor(event.currentTarget)
              const images = props.controller.parts().filter((part) => part.type === "image")
              localInput = true
              props.controller.onInput(prompt.map((part) => part.content).join(""), [...prompt, ...images], cursor)
@@ -301,13 +300,8 @@ function renderPromptInputV2Editor(editor: HTMLDivElement, prompt: PromptInputV2

 function parsePromptInputV2Editor(editor: HTMLDivElement) {
  const parts: Exclude<PromptInputV2Prompt[number], PromptInputV2Attachment>[] = []
-  const selection = window.getSelection()
-  const anchorNode = selection && editor.contains(selection.anchorNode) ? selection.anchorNode : undefined
-  const anchorOffset = anchorNode ? selection!.anchorOffset : 0
  let buffer = ""
  let position = 0
-  let cursor: number | undefined
-  const offset = () => position + buffer.length

  const flush = () => {
    if (!buffer) return
@@ -342,42 +336,43 @@ function parsePromptInputV2Editor(editor: HTMLDivElement) {
  }
  const visit = (node: Node) => {
    if (node.nodeType === Node.TEXT_NODE) {
-      if (node === anchorNode) cursor = offset() + Math.min(anchorOffset, node.textContent?.length ?? 0)
      buffer += node.textContent ?? ""
      return
    }
    if (!(node instanceof HTMLElement)) return
    if (node.dataset.mention) {
-      if (node === anchorNode) cursor = offset() + (anchorOffset > 0 ? (node.textContent?.length ?? 0) : 0)
      mention(node)
      return
    }
    if (node.tagName === "BR") {
-      if (node === anchorNode) cursor = offset() + (anchorOffset > 0 ? 1 : 0)
      buffer += "\n"
      return
    }
-    Array.from(node.childNodes).forEach((child, index) => {
-      if (node === anchorNode && anchorOffset === index) cursor = offset()
-      visit(child)
-    })
-    if (node === anchorNode && anchorOffset >= node.childNodes.length) cursor = offset()
+    Array.from(node.childNodes).forEach(visit)
  }

  Array.from(editor.childNodes).forEach((node, index, nodes) => {
-    if (editor === anchorNode && anchorOffset === index) cursor = offset()
    visit(node)
    if (node instanceof HTMLElement && ["DIV", "P"].includes(node.tagName) && index < nodes.length - 1) buffer += "\n"
  })
-  if (editor === anchorNode && anchorOffset >= editor.childNodes.length) cursor = offset()
  flush()
-  const result =
-    parts.length === 0 ||
-    (parts.every((part) => part.type === "text") &&
-      parts.every((part) => part.content.replace(/[\n\u200B]/g, "") === ""))
-      ? [{ type: "text" as const, content: "", start: 0, end: 0 }]
-      : parts
-  return { prompt: result, cursor: cursor ?? offset() }
+  if (
+    parts.every((part) => part.type === "text") &&
+    parts.every((part) => part.content.replace(/[\n\u200B]/g, "") === "")
+  ) {
+    return [{ type: "text" as const, content: "", start: 0, end: 0 }]
+  }
+  if (parts.length > 0) return parts
+  return [{ type: "text" as const, content: "", start: 0, end: 0 }]
+}
+
+function promptInputV2Cursor(editor: HTMLDivElement) {
+  const selection = window.getSelection()
+  if (!selection?.rangeCount || !editor.contains(selection.anchorNode)) return editor.textContent?.length ?? 0
+  const range = selection.getRangeAt(0).cloneRange()
+  range.selectNodeContents(editor)
+  range.setEnd(selection.anchorNode!, selection.anchorOffset)
+  return range.toString().length
 }

 export function PromptInputV2Attachments(props: {
@@ -401,7 +396,12 @@ export function PromptInputV2Attachments(props: {
          <For each={props.comments ?? []}>
            {(comment) => (
              <div class="relative group shrink-0">
-                <TooltipV2 value={comment.comment} placement="top" contentClass="max-w-[300px] break-words">
+                <TooltipV2
+                  value={comment.comment}
+                  placement="top"
+                  openDelay={800}
+                  contentClass="max-w-[300px] break-words"
+                >
                  <CommentCardV2
                    comment={comment.comment ?? ""}
                    path={comment.path}
@@ -220,6 +220,7 @@ export function SessionReviewV2(props: SessionReviewV2Props) {
      </Show>
      <div class="flex items-center">
        <TooltipV2
+          openDelay={2000}
          inactive={!prev()}
          value={
            <>
@@ -239,6 +240,7 @@ export function SessionReviewV2(props: SessionReviewV2Props) {
          />
        </TooltipV2>
        <TooltipV2
+          openDelay={2000}
          inactive={!next()}
          value={
            <>
@@ -272,12 +274,12 @@ export function SessionReviewV2(props: SessionReviewV2Props) {
        class="session-review-v2-segmented-control session-review-v2-segmented-control--icon"
        aria-label={i18n.t("ui.sessionReviewV2.expandMode")}
      >
-        <TooltipV2 value={i18n.t("ui.sessionReviewV2.showAllLines")}>
+        <TooltipV2 openDelay={2000} value={i18n.t("ui.sessionReviewV2.showAllLines")}>
          <SegmentedControlItemV2 value="expand" aria-label={i18n.t("ui.sessionReviewV2.showAllLines")}>
            <Icon name="expand" />
          </SegmentedControlItemV2>
        </TooltipV2>
-        <TooltipV2 value={i18n.t("ui.sessionReviewV2.hideNonDiffLines")}>
+        <TooltipV2 openDelay={2000} value={i18n.t("ui.sessionReviewV2.hideNonDiffLines")}>
          <SegmentedControlItemV2 value="collapse" aria-label={i18n.t("ui.sessionReviewV2.hideNonDiffLines")}>
            <Icon name="collapse" />
          </SegmentedControlItemV2>
@@ -293,12 +295,12 @@ export function SessionReviewV2(props: SessionReviewV2Props) {
          class="session-review-v2-segmented-control session-review-v2-segmented-control--icon"
          aria-label={i18n.t("ui.sessionReviewV2.diffView")}
        >
-          <TooltipV2 value={i18n.t("ui.sessionReviewV2.unifiedDiff")}>
+          <TooltipV2 openDelay={2000} value={i18n.t("ui.sessionReviewV2.unifiedDiff")}>
            <SegmentedControlItemV2 value="unified" aria-label={i18n.t("ui.sessionReviewV2.unifiedDiff")}>
              <Icon name="unified" />
            </SegmentedControlItemV2>
          </TooltipV2>
-          <TooltipV2 value={i18n.t("ui.sessionReviewV2.splitDiff")}>
+          <TooltipV2 openDelay={2000} value={i18n.t("ui.sessionReviewV2.splitDiff")}>
            <SegmentedControlItemV2 value="split" aria-label={i18n.t("ui.sessionReviewV2.splitDiff")}>
              <Icon name="split" />
            </SegmentedControlItemV2>
@@ -104,6 +104,7 @@ const appGlobalBindingCommands = [
 ] as const

 const appBindingCommands = [
+  "command.palette.show",
  "model.list",
  "model.cycle_recent",
  "model.cycle_recent_reverse",
@@ -962,11 +963,6 @@ function App(props: { onSnapshot?: () => Promise<string[]>; pluginHost: TuiPlugi
    commands: appCommands(),
  }))

-  useBindings(() => ({
-    enabled: () => dialog.stack.length === 0,
-    bindings: tuiConfig.keybinds.get(COMMAND_PALETTE_COMMAND),
-  }))
-
  useBindings(() => ({
    mode: OPENCODE_BASE_MODE,
    bindings: tuiConfig.keybinds.gather("app", appBindingCommands),
@@ -5,13 +5,7 @@ import { testRender, useRenderer } from "@opentui/solid"
 import { expect, test } from "bun:test"
 import { onCleanup } from "solid-js"
 import { TuiKeybind } from "../src/config/keybind"
-import {
-  COMMAND_PALETTE_COMMAND,
-  getOpencodeModeStack,
-  OPENCODE_BASE_MODE,
-  OpencodeKeymapProvider,
-  registerOpencodeKeymap,
-} from "../src/keymap"
+import { getOpencodeModeStack, OPENCODE_BASE_MODE, OpencodeKeymapProvider, registerOpencodeKeymap } from "../src/keymap"

 function createResolvedKeymapConfig(input: TuiKeybind.KeybindOverrides = {}) {
  const keybinds = TuiKeybind.parse(input)
@@ -79,14 +73,12 @@ test("mode-less bindings stay active when opencode mode changes", async () => {
    const offKeymap = registerOpencodeKeymap(keymap, renderer, config)
    const offGlobal = keymap.registerLayer({
      commands: [
-        { name: COMMAND_PALETTE_COMMAND, run() {} },
        { name: "session.list", run() {} },
        { name: "session.new", run() {} },
        { name: "session.page.up", run() {} },
        { name: "session.first", run() {} },
      ],
      bindings: config.keybinds.gather("test.global", [
-        COMMAND_PALETTE_COMMAND,
        "session.list",
        "session.new",
        "session.page.up",
@@ -103,14 +95,7 @@ test("mode-less bindings stay active when opencode mode changes", async () => {
        Array.from(
          keymap.getCommandBindings({
            visibility: "active",
-            commands: [
-              COMMAND_PALETTE_COMMAND,
-              "session.list",
-              "session.new",
-              "session.page.up",
-              "session.first",
-              "model.list",
-            ],
+            commands: ["session.list", "session.new", "session.page.up", "session.first", "model.list"],
          }),
          ([command, bindings]) => [command, bindings.length],
        ),
@@ -140,24 +125,9 @@ test("mode-less bindings stay active when opencode mode changes", async () => {
  const app = await testRender(() => <Harness />)
  try {
    expect(counts).toEqual({
-      base: {
-        [COMMAND_PALETTE_COMMAND]: 1,
-        "session.list": 1,
-        "session.new": 1,
-        "session.page.up": 2,
-        "session.first": 2,
-        "model.list": 1,
-      },
-      question: {
-        [COMMAND_PALETTE_COMMAND]: 1,
-        "session.list": 1,
-        "session.new": 1,
-        "session.page.up": 2,
-        "session.first": 2,
-        "model.list": 0,
-      },
+      base: { "session.list": 1, "session.new": 1, "session.page.up": 2, "session.first": 2, "model.list": 1 },
+      question: { "session.list": 1, "session.new": 1, "session.page.up": 2, "session.first": 2, "model.list": 0 },
      autocomplete: {
-        [COMMAND_PALETTE_COMMAND]: 1,
        "session.list": 1,
        "session.new": 1,
        "session.page.up": 2,
@@ -1,35 +0,0 @@
-const OPEN_DELAY = 1_000
-
-// Kobalte warms every tooltip globally. Keep intent previews isolated so opening
-// a model picker never inherits warm state from an unrelated tooltip.
-let warm = false
-let reset: ReturnType<typeof setTimeout> | undefined
-
-export function openTooltipIntent(open: () => void) {
-  clearTimeout(reset)
-  reset = undefined
-  if (warm) {
-    open()
-    return
-  }
-  const timer = setTimeout(() => {
-    warm = true
-    open()
-  }, OPEN_DELAY)
-  return () => clearTimeout(timer)
-}
-
-export function closeTooltipIntent() {
-  clearTimeout(reset)
-  // Adjacent triggers enter before the next task; leaving the group does not.
-  reset = setTimeout(() => {
-    warm = false
-    reset = undefined
-  })
-}
-
-export function resetTooltipIntent() {
-  clearTimeout(reset)
-  reset = undefined
-  warm = false
-}
@@ -2,22 +2,19 @@ import { Tooltip as KobalteTooltip } from "@kobalte/core/tooltip"
 import { createEffect, Match, onCleanup, splitProps, Switch, type JSX } from "solid-js"
 import type { ComponentProps } from "solid-js"
 import { createStore } from "solid-js/store"
-import { closeTooltipIntent, openTooltipIntent, resetTooltipIntent } from "./tooltip-intent"
 import "./tooltip-v2.css"

-export interface TooltipV2Props extends Omit<ComponentProps<typeof KobalteTooltip>, "openDelay"> {
+export interface TooltipV2Props extends ComponentProps<typeof KobalteTooltip> {
  value: JSX.Element
  class?: string
  contentClass?: string
  contentStyle?: JSX.CSSProperties
  inactive?: boolean
-  delay?: "standard" | "intent"
  forceOpen?: boolean
 }

 export function TooltipV2(props: TooltipV2Props) {
  let ref: HTMLDivElement | undefined
-  let cancelIntent: (() => void) | undefined
  const [state, setState] = createStore({
    open: false,
    block: false,
@@ -29,37 +26,19 @@ export function TooltipV2(props: TooltipV2Props) {
    "contentClass",
    "contentStyle",
    "inactive",
-    "delay",
    "forceOpen",
    "ignoreSafeArea",
    "value",
  ])

+  const close = () => setState("open", false)
+
  const inside = () => {
    const active = document.activeElement
    if (!ref || !active) return false
    return ref.contains(active)
  }

-  const close = () => {
-    cancelIntent?.()
-    cancelIntent = undefined
-    if (local.delay === "intent") closeTooltipIntent()
-    setState("open", false)
-  }
-
-  const show = () => {
-    if (local.delay !== "intent" || inside()) {
-      setState("open", true)
-      return
-    }
-    if (cancelIntent) return
-    cancelIntent = openTooltipIntent(() => {
-      cancelIntent = undefined
-      setState("open", true)
-    })
-  }
-
  const drop = (expand = state.expand) => {
    if (expand) return
    if (ref?.matches(":hover")) return
@@ -101,11 +80,6 @@ export function TooltipV2(props: TooltipV2Props) {
    onCleanup(() => obs.disconnect())
  })

-  onCleanup(() => {
-    cancelIntent?.()
-    if (local.delay === "intent") resetTooltipIntent()
-  })
-
  let justClickedTrigger = false

  return (
@@ -114,8 +88,8 @@ export function TooltipV2(props: TooltipV2Props) {
      <Match when={true}>
        <KobalteTooltip
          gutter={4}
-          openDelay={local.delay === "intent" ? 0 : 400}
-          skipDelayDuration={local.delay === "intent" ? 0 : 300}
+          openDelay={400}
+          skipDelayDuration={300}
          {...others}
          closeDelay={0}
          ignoreSafeArea={local.ignoreSafeArea ?? true}
@@ -127,11 +101,7 @@ export function TooltipV2(props: TooltipV2Props) {
              justClickedTrigger = false
              return
            }
-            if (open) {
-              show()
-              return
-            }
-            close()
+            setState("open", open)
          }}
        >
          <KobalteTooltip.Trigger
Author	SHA1	Message	Date
Aiden Cline	5562652f63	test(opencode): expect empty response retry	2026-08-04 23:13:23 +00:00
Aiden Cline	031510e1c3	fix(opencode): retry empty unknown responses	2026-08-04 22:52:01 +00:00