perf: overhaul session loading, caching, and runtime isolation (#2360)

Improve OpenChamber responsiveness under large session workloads while fixing
cache, synchronization, and persistence correctness across runtimes, projects,
directories, and worktrees.

- prioritize selected and visible sessions during bootstrap and defer
  non-critical enrichment work
- reduce redundant message loading, event processing, store publication, and
  hidden sidebar work
- prevent stale session and message requests from overwriting newer
  authoritative state
- preserve existing data when authoritative fetches fail instead of treating
  failures as successful empty responses
- scope session materialization, messages, drafts, queues, todos, pins,
  permissions, folders, tabs, Git state, and pull request data by runtime and
  directory identity
- harden runtime switching, reconnect, cleanup, mutation reconciliation, and
  persisted-state ordering
- preserve live subagent Task linkage when metadata arrives after an older
  message request or while streaming parts are suspended
- coalesce overlapping tail refreshes without losing newer refresh demand
- improve cold-session loading by moving deferrable work out of the critical
  bootstrap path
- isolate URL authentication, mobile credentials, native secrets, and other
  runtime-owned state across endpoint changes
- bound long-lived caches and remove avoidable allocations from event and
  rendering hot paths
- limit virtualization to archive collections where it improves rendering
  without disrupting active sidebar layout
- stabilize session folders, pin ordering, expanded state, and persisted
  sidebar behavior
- open skill files through the same secure editor and outside-workspace grant
  flow used by file navigation, including worktree sessions
- expand regression coverage for stale completions, runtime collisions,
  reconnect behavior, persistence races, authoritative empty results, and
  subagent refresh ordering
- document the updated synchronization, cache ownership, performance, and
  runtime-isolation invariants

packages/ui/src/sync/bootstrap.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from "bun:test"
+import type { OpencodeClient, Project } from "@opencode-ai/sdk/v2/client"
+import { bootstrapDirectory } from "./bootstrap"
+import { INITIAL_STATE, type State } from "./types"
+
+const createSdk = (options?: { commandList?: () => Promise<{ data: unknown[] }> }) => ({
+  project: { current: async () => ({ data: { id: "project-a" } }) },
+  config: { get: async () => ({ data: {} }) },
+  path: { get: async () => ({ data: { state: "", config: "", worktree: "/repo", directory: "/repo", home: "/home" } }) },
+  session: { status: async () => ({ data: {} }) },
+  command: { list: options?.commandList ?? (async () => ({ data: [] })) },
+  mcp: { status: async () => ({ data: {} }) },
+  lsp: { status: async () => ({ data: [] }) },
+  vcs: { get: async () => ({ data: { branch: "main" } }) },
+  question: { list: async () => ({ data: [] }) },
+  permission: { list: async () => ({ data: [] }) },
+}) as unknown as OpencodeClient
+
+const createState = (): State => ({
+  ...INITIAL_STATE,
+  message: {},
+  part: {},
+})
+
+const project = { id: "project-a", worktree: "/repo" } as Project
+
+describe("bootstrapDirectory", () => {
+  test("prioritizes session loading without waiting for deferred fields", async () => {
+    let state = createState()
+    let deferredStarted = false
+    let resolveDeferred!: () => void
+    const deferred = new Promise<{ data: unknown[] }>((resolve) => {
+      resolveDeferred = () => resolve({ data: [] })
+    })
+    let resolveSessions!: () => void
+    const sessions = new Promise<void>((resolve) => {
+      resolveSessions = resolve
+    })
+    let settled = false
+    const sdk = createSdk({
+      commandList: async () => {
+        deferredStarted = true
+        return deferred
+      },
+    })
+    const bootstrapping = bootstrapDirectory({
+      directory: "/repo",
+      sdk,
+      getState: () => state,
+      set: (patch) => {
+        state = { ...state, ...patch }
+      },
+      global: { config: {}, projects: [project] },
+      loadSessions: () => sessions,
+    }).then((result) => {
+      settled = true
+      return result
+    })
+
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(settled).toBe(false)
+    expect(deferredStarted).toBe(false)
+    resolveSessions()
+
+    expect(await bootstrapping).toBe("complete")
+    expect(state.status).toBe("complete")
+    expect(deferredStarted).toBe(false)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(deferredStarted).toBe(true)
+    resolveDeferred()
+  })
+
+  test("reports session-list failure without clearing existing state", async () => {
+    let state = { ...createState(), session: [{ id: "cached" }] as State["session"] }
+    const result = await bootstrapDirectory({
+      directory: "/repo",
+      sdk: createSdk(),
+      getState: () => state,
+      set: (patch) => {
+        state = { ...state, ...patch }
+      },
+      global: { config: {}, projects: [project] },
+      loadSessions: async () => {
+        throw new Error("unavailable")
+      },
+    })
+
+    expect(result).toBe("failed")
+    expect(state.session.map((session) => session.id)).toEqual(["cached"])
+  })
+
+  test("rejects stale work before committing", async () => {
+    const state = createState()
+    let commits = 0
+    const result = await bootstrapDirectory({
+      directory: "/repo",
+      sdk: createSdk(),
+      getState: () => state,
+      set: () => {
+        commits += 1
+      },
+      isStale: () => true,
+      global: { config: {}, projects: [project] },
+      loadSessions: async () => undefined,
+    })
+
+    expect(result).toBe("stale")
+    expect(commits).toBe(0)
+  })
+})