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/contexts/content-cache-owner.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test"
+import type { FilesAPI } from "@/lib/api/types"
+import { createContentCachedFiles } from "./content-cache-owner"
+
+const deferred = <T>() => {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((res) => { resolve = res })
+  return { promise, resolve }
+}
+
+describe("content cache owner", () => {
+  test("reuses only strongly validated content", async () => {
+    let reads = 0
+    const files = {
+      readFile: async (path: string) => ({ path, content: `value-${++reads}` }),
+      statFile: async () => ({ isFile: true, isDirectory: false, size: 7, mtimeMs: 1 }),
+    } as unknown as FilesAPI
+    const owner = createContentCachedFiles(files)
+
+    expect((await owner.files.readFile!("file.ts")).content).toBe("value-1")
+    expect((await owner.files.readFile!("file.ts")).content).toBe("value-1")
+    expect(reads).toBe(1)
+    owner.dispose()
+  })
+
+  test("does not retain size-only reads without mtime", async () => {
+    let reads = 0
+    const owner = createContentCachedFiles({
+      readFile: async (path: string) => ({ path, content: `value-${++reads}` }),
+      statFile: async () => ({ isFile: true, isDirectory: false, size: 7 }),
+    } as unknown as FilesAPI)
+
+    await owner.files.readFile!("file.ts")
+    await owner.files.readFile!("file.ts")
+    expect(reads).toBe(2)
+    owner.dispose()
+  })
+
+  test("retries a read that overlaps a write", async () => {
+    const firstRead = deferred<{ path: string; content: string }>()
+    let content = "old"
+    let reads = 0
+    const owner = createContentCachedFiles({
+      readFile: async (path: string) => {
+        reads += 1
+        return reads === 1 ? firstRead.promise : { path, content }
+      },
+      statFile: async () => ({ isFile: true, isDirectory: false, size: content.length, mtimeMs: content === "old" ? 1 : 2 }),
+      writeFile: async (_path: string, next: string) => { content = next },
+    } as unknown as FilesAPI)
+
+    const reading = owner.files.readFile!("file.ts")
+    await owner.files.writeFile!("file.ts", "new")
+    firstRead.resolve({ path: "file.ts", content: "old" })
+
+    expect((await reading).content).toBe("new")
+    expect(reads).toBe(2)
+    owner.dispose()
+  })
+
+  test("separates identical paths by directory scope", async () => {
+    let reads = 0
+    const owner = createContentCachedFiles({
+      readFile: async (path: string, options?: Parameters<NonNullable<FilesAPI['readFile']>>[1]) => ({ path, content: `${options?.directory}-${++reads}` }),
+      statFile: async () => ({ isFile: true, isDirectory: false, size: 1, mtimeMs: 1 }),
+    } as unknown as FilesAPI)
+
+    const first = await owner.files.readFile!("file.ts", { directory: "/a" })
+    const second = await owner.files.readFile!("file.ts", { directory: "/b" })
+    expect(first.content).toBe("/a-1")
+    expect(second.content).toBe("/b-2")
+    owner.dispose()
+  })
+})