fix(opencode): redact provider model secrets

.github/workflows/test.yml

@@ -69,11 +69,6 @@ jobs:
         env:
           OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
 
-      - name: Check generated client
-        if: runner.os == 'Linux'
-        working-directory: packages/client
-        run: bun run check:generated
-
       - name: Run HttpApi exerciser gates
         if: runner.os == 'Linux'
         working-directory: packages/opencode

AGENTS.md

@@ -28,7 +28,6 @@ Examples: `fix(tui): simplify thinking toggle styling`, `docs: update contributi
 - Rely on type inference when possible; avoid explicit type annotations or interfaces unless necessary for exports or clarity
 - Prefer functional array methods (flatMap, filter, map) over for loops; use type guards on filter to maintain type inference downstream
 - In `src/config`, follow the existing self-export pattern at the top of the file (for example `export * as ConfigAgent from "./agent"`) when adding a new config module.
-- In Effect generators, bind services to named variables before calling methods. Do not use nested service yields such as `yield* (yield* Foo.Service).bar()`.
 
 Reduce total variable count by inlining when a value is only used once.
 

CONTEXT.md

@@ -60,21 +60,6 @@ A temporary file created under OpenCode's shared tool-output directory to retain
 **PTY Environment**:
 The host-supplied environment overlay applied by the server when creating a PTY, observed for the request Location and resolved PTY working directory.
 
-**OpenCode Client**:
-The generated Effect API shared by networked and in-process consumers, executed through an `HttpClient` against the same `HttpApi` router and handlers.
-_Avoid_: Remote client
-
-**SDK Contract IR**:
-The runtime-neutral compiled representation of the authoritative `HttpApi`, preserving encoded and decoded type projections plus transport metadata so independent SDK emitters can choose their public value model and runtime interpreter.
-
-**Embedded OpenCode**:
-A scoped in-process host that structurally extends the **OpenCode Client**, supplies an in-memory HTTP transport, and exposes additional same-process capabilities directly.
-_Avoid_: Local implementation
-
-**Page**:
-A bounded ordered result containing `items` and opaque `previous` and `next` cursor links for navigating the same query in either direction.
-_Avoid_: Response envelope
-
 ## Relationships
 
 - A **System Context** is an opaque carrier composed from zero or more **Context Sources**.
@@ -123,51 +108,6 @@ _Avoid_: Response envelope
 - Completed compaction starts a new **Context Epoch** on the next provider attempt, folding the current complete **System Context** into a fresh baseline and removing earlier **Mid-Conversation System Messages** from active model history.
 - A model/provider switch preserves the current **Context Epoch** and chronological conversation history; the new selection applies to the next provider turn.
 - The **PTY Environment** is a server concern rather than a Core PTY concern. PTY creation merges caller values, then the host overlay, then Core-forced terminal invariants such as `TERM` and `OPENCODE_TERMINAL`.
-- Networked and **Embedded OpenCode** use the same **OpenCode Client** and preserve the full HTTP encoding, routing, middleware, and decoding boundary; only the `HttpClient` transport differs.
-- The Effect-native network constructor obtains `HttpClient.HttpClient` from its environment so callers own transport selection, recording, tracing, retries, and tests. Convenience runtimes may provide a fetch transport separately.
-- Creating **Embedded OpenCode** is scoped. Closing its owning Scope releases the in-process server resources, database resources, registrations, and fibers.
-- **Embedded OpenCode** exposes shared client capabilities and embedded-only capabilities on one object; consumers do not navigate through a nested `.client` property.
-- The beta **OpenCode Client** currently uses plural consumer-facing capability groups such as `sessions`; whether the stable Session namespace should instead be singular `session` must be settled before stabilization. Internal server identifiers do not implicitly define public client names.
-- Server's concrete `HttpApi` is authoritative for shared **OpenCode Client** capabilities. Codegen compiles its Session group directly; the Effect runtime uses an equivalent Protocol-only projection so generated artifacts remain independent of Core and Server.
-- SDK generation reflects the public `HttpApi` once into an **SDK Contract IR**. Promise and Effect emitters share endpoint structure and transport metadata without being required to expose identical public values: an emitter may select encoded wire types, decoded domain types, compile-time brands, runtime validation, and its own execution abstraction independently.
-- The first Effect emitter is the rich projection: it exposes decoded Effect-native values, preserves brands and schema transformations, performs runtime schema decoding, and delegates transport interpretation to `HttpApiClient`. Lighter wire-shaped Effect output remains possible through another emitter policy rather than constraining the shared IR.
-- The rich Effect emitter regenerates private executable schemas when the **SDK Contract IR** proves that their transport semantics can be reproduced exactly. Contracts with authoritative custom transformations use the import-based Effect emitter against a Protocol-only client projection whose generated transport output is tested against Server's concrete API; the Promise emitter still derives zero-Effect structural wire types from the same IR.
-- `@opencode-ai/protocol` owns Session endpoint construction and middleware placement. Server supplies concrete middleware keys to produce the authoritative build-time API; the client projection supplies transport-only keys without importing Core or Server at runtime.
-- The first Promise emitter targets the same clean domain-oriented method organization rather than Hey API source compatibility. It returns unwrapped values directly, rejects declared and infrastructure failures, and begins with minimal client-level transport configuration; result wrappers, interceptors, and legacy generated signatures are outside the initial surface.
-- The first Promise emitter parses response syntax and trusts its generated structural types; it does not perform runtime structural validation. Malformed payload syntax fails, while a syntactically valid shape mismatch is not detected at the SDK boundary. Standalone validator generation remains an optional future emitter policy.
-- Declared Promise-client failures retain their tagged structural wire values and have generated type guards. Consumers do not depend on generated `Error` subclass identity, preserving discrimination across package copies and realms while remaining structurally aligned with Effect domain errors.
-- Promise-client infrastructure failures use one generated `ClientError` class with a structured reason such as transport failure, unexpected status, unsupported content type, or malformed response. Promise methods reject with either a tagged declared domain failure or `ClientError`, matching the Effect client's conceptual domain/infrastructure error division.
-- Promise methods accept a separate optional per-call transport-options argument containing `AbortSignal` and header overrides. Cancellation and transport metadata do not enter the domain input object; broader interceptor and response-mode APIs remain deferred.
-- Promise streaming methods return a lazy `AsyncIterable` directly rather than a Promise-wrapped stream object. Iteration opens the connection, `AbortSignal` cancels it, and ending iteration closes the underlying request; the Effect emitter analogously returns `Stream` directly.
-- Promise SSE connection establishment, declared HTTP failures, and infrastructure failures occur during `AsyncIterable` iteration, beginning with its first `next()` call, rather than during synchronous method construction.
-- Neither generated streaming runtime automatically reconnects after disconnection. Promise `AsyncIterable` and Effect `Stream` fail explicitly; live consumers refresh and resubscribe, while durable sequence-based resume remains explicit composition above the generated client.
-- Promise client construction is synchronous and network-free. It requires `baseUrl`, defaults to `globalThis.fetch`, accepts client-level headers, and merges them with per-call header overrides.
-- Effect client construction accepts an explicit `baseUrl` and obtains `HttpClient.HttpClient` from the Effect environment. It does not install fetch or duplicate per-call transport policy; callers transform/provide the client for headers, tracing, retries, recording, and tests, while fiber interruption owns cancellation.
-- Promise and Effect emitters each own their generated public type modules. The **SDK Contract IR**, not a physically shared generated type package, is the common source; this permits zero-Effect wire types and rich decoded Effect types to evolve independently.
-- Promise and Effect network clients ship from `@opencode-ai/client` behind isolated root and `/effect` exports. The root has no runtime path to Effect; `/effect` imports only Effect, Schema, and Protocol.
-- The Effect-native scoped host belongs to `@opencode-ai/sdk-next`, which will assume the existing `@opencode-ai/sdk` name after legacy consumers migrate. Client remains network-only and SDK depends one-way on Client.
-- SDK executes Server's assembled `HttpRouter` in memory. It opens no listener and performs no network I/O, while preserving Server routing, middleware, codecs, handlers, and errors.
-- The Effect Client and SDK re-export their decoded datatype facade from Schema so callers do not depend on internal package locations or Core's versioned names.
-- A capability intended for both networked and **Embedded OpenCode** belongs in the authoritative public `HttpApi`; embedded-only same-process capabilities extend **Embedded OpenCode** separately.
-- `sessions.events({ sessionID, after })` is a public durable Session event stream. It verifies the Session, replays durable events after the optional aggregate sequence, continues with newly committed durable events, excludes live-only fragments, and is transported as SSE in both networked and embedded modes.
-- `events.subscribe()` is a distinct public instance-wide live stream for Session and non-Session activity. It has no replay guarantee and includes connection, heartbeat, and instance-disposal lifecycle events; consumers recover from disconnection by refreshing authoritative state.
-- A Session ID is not an optional filter on `events.subscribe()`: instance-wide live events and durable Session events have different schemas, replay guarantees, cursors, lifecycle events, and failure behavior.
-- The initial common OpenCode Client does not expose server-global event aggregation. `events.subscribe()` is bounded to the connected OpenCode instance or workspace; any future cross-instance administrative stream requires a separately designed API.
-- `events.subscribe()` does not automatically reconnect after transport loss. The live-only stream fails with `ClientError`; consumers refresh authoritative state before explicitly opening a new subscription because events missed during disconnection cannot be replayed.
-- `sessions.events({ sessionID, after })` returns the generated HTTP client's cold durable event stream and does not build reconnection policy into the endpoint or client constructor. Transport loss fails the stream with `ClientError`. Callers may compose an explicit resuming stream above it by retaining the last observed durable sequence and opening a new subscription with `after`; any reusable resume helper remains a separate API design question.
-- The stable `sessions.list(...)` design returns a **Page** in both networked and **Embedded OpenCode**; embedded execution does not define a separate unbounded array-returning list operation. The beta client currently preserves the existing HTTP `{ data, cursor }` envelope until emitter-level Page projection is implemented.
-- Session list cursors are opaque branded values carrying continuation query and ordering state. Consumers pass them back unchanged and do not inspect storage anchors or encoded filter fields.
-- A Session list continuation accepts only its opaque cursor. Scope, filters, ordering, and page size are fixed by the initial query and carried by that cursor.
-- `sessions.messages(...)` returns a **Page** and uses the same cursor discipline as `sessions.list(...)`: the initial request supplies `sessionID`, ordering, and page size; continuation supplies `sessionID` plus only an opaque branded message cursor carrying ordering, page size, direction, and message anchor. Using a cursor with another Session is invalid.
-- `sessions.message({ sessionID, messageID })` is a required resource lookup. An unknown Session fails with `SessionNotFoundError`; a known Session with an absent or differently owned message fails with `SessionMessageNotFoundError` without disclosing cross-Session ownership. Absence is not represented as `undefined` across the public HTTP boundary.
-- `sessions.interrupt({ sessionID })` first verifies that the durable Session exists, failing with `SessionNotFoundError` otherwise. For a known Session, interruption is idempotent: idle, already-settled, or locally unowned execution is a no-op.
-- `sessions.context({ sessionID })` preserves the existing message-only operation. It returns projected conversational messages selected as Session context; it does not include or represent the complete provider request context, whose baseline system context and other contributions remain separate.
-- **Open question**: Should a future, separately named operation expose the complete provider request context, including baseline system context, selected source contributions, and context-epoch metadata?
-- `sessions.prompt(...)` exposes `resume?: boolean`. Omitting it preserves durable admission followed by an advisory execution wake; `resume: false` requests durable admit-only behavior.
-- The public operation remains `sessions.prompt(...)`; `SessionInput.admit` is the internal primitive, while the public `Admission` result and `resume` option express its durable admission semantics.
-- `sessions.create(...)` accepts an optional `location`. Omission resolves through the connected OpenCode instance's default or current location; an explicit value selects a known location. Networked and embedded transports use the same handler semantics.
-- `sessions.switchAgent({ sessionID, agent })` is part of the common client alongside `sessions.switchModel(...)`. It affects subsequent Session activity and fails with `SessionNotFoundError` for an unknown Session.
-- The **Embedded OpenCode** Layer delegates to the same scoped creation path; it does not define a second implementation.
 - A **PTY Environment** adapter observes plugins in the request Location while passing the resolved PTY working directory to the hook; standalone servers use an empty adapter.
 - A **Mid-Conversation System Message** lowers to the provider's native chronological instruction role when supported and to a wrapped chronological fallback otherwise.
 - When the effective aggregate instruction set changes, its **Mid-Conversation System Message** includes the complete current ordered set and supersedes the prior aggregate value; when no ambient instructions remain, the message states that previously loaded instructions no longer apply.
@@ -184,23 +124,6 @@ _Avoid_: Response envelope
 - **Managed Tool Output Files** use globally unique names in one shared flat directory. Their absolute paths are readable and searchable by ordinary tools; other absolute paths remain outside Location-scoped filesystem authority.
 - Provider-executed tool results remain provider-native transcript facts outside generic Tool Registry bounding. Their context control requires provider-aware pruning or compaction because some providers require exact structured round-trip payloads.
 
-## Client contract architecture
-
-Semantic values that mean the same thing internally and publicly live in the lightweight Schema leaf. Core consumes Schema for domain behavior; Protocol composes Schema values into paths, payloads, envelopes, errors, cursors, and streams; Server imports both, hosts Protocol's exact groups, and owns protocol/domain adaptation. The root Promise client remains zero-Effect, `/effect` depends on Effect plus Schema and Protocol, and `@opencode-ai/sdk-next` composes the scoped in-process host above Client, Core, and Server.
-
-Shared public records are plain objects declared with `Schema.Struct`. A same-name inferred interface gives object records readable TypeScript signatures without constructors, prototypes, or nominal identity; unions retain explicit type aliases.
-
-Before stabilizing the client API:
-
-- Keep additional public schemas in Schema and additional network groups in Protocol; neither package may transitively load databases, Drizzle, Session execution, providers, watchers, native modules, or WASM.
-- Keep concrete Location middleware keys in Server while Protocol owns their placement. Client projections may supply transport-only keys, but must prove generated equivalence with Server's concrete API.
-- Project the existing list response envelope to the stable client **Page** shape and enforce separate initial-query and cursor-continuation inputs without changing the hosted V2 wire contract.
-- Settle the stable consumer namespace (`session` versus the current beta `sessions`) and use an explicit codegen annotation if the consumer name should differ from the server group identifier.
-- Preserve V2 route paths, operation IDs, codecs, errors, middleware behavior, and OpenAPI output while making this change.
-- Preserve browser-safe `@opencode-ai/client` and `@opencode-ai/client/effect` bundles through import-boundary tests.
-- Define embedded-host placement before supporting multiple hosts over one database. Hosts that share durable Session storage must also share process-local Session execution coordination, or each host must receive isolated storage explicitly.
-- Keep an embedded request scope alive until any streamed response body finishes. The initial non-streaming Session surface does not exercise this lifetime boundary; Session and instance event streams must do so before joining the embedded client.
-
 ## Example dialogue
 
 > **Dev:** "The date changed while the session was active. Should the **Mid-Conversation System Message** say what the old date was?"

bun.lock

@@ -110,29 +110,6 @@
         "@typescript/native-preview": "catalog:",
       },
     },
-    "packages/client": {
-      "name": "@opencode-ai/client",
-      "dependencies": {
-        "@opencode-ai/protocol": "workspace:*",
-        "@opencode-ai/schema": "workspace:*",
-      },
-      "devDependencies": {
-        "@effect/platform-node": "catalog:",
-        "@opencode-ai/core": "workspace:*",
-        "@opencode-ai/httpapi-codegen": "workspace:*",
-        "@opencode-ai/server": "workspace:*",
-        "@tsconfig/bun": "catalog:",
-        "@types/bun": "catalog:",
-        "@typescript/native-preview": "catalog:",
-        "effect": "catalog:",
-      },
-      "peerDependencies": {
-        "effect": "4.0.0-beta.83",
-      },
-      "optionalPeers": [
-        "effect",
-      ],
-    },
     "packages/console/app": {
       "name": "@opencode-ai/console-app",
       "version": "1.17.10",
@@ -502,18 +479,6 @@
         "effect": "4.0.0-beta.83",
       },
     },
-    "packages/httpapi-codegen": {
-      "name": "@opencode-ai/httpapi-codegen",
-      "dependencies": {
-        "effect": "catalog:",
-        "prettier": "3.6.2",
-      },
-      "devDependencies": {
-        "@tsconfig/bun": "catalog:",
-        "@types/bun": "catalog:",
-        "@typescript/native-preview": "catalog:",
-      },
-    },
     "packages/llm": {
       "name": "@opencode-ai/llm",
       "version": "1.17.10",
@@ -574,7 +539,6 @@
         "@openauthjs/openauth": "catalog:",
         "@opencode-ai/llm": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
-        "@opencode-ai/protocol": "workspace:*",
         "@opencode-ai/schema": "workspace:*",
         "@opencode-ai/script": "workspace:*",
         "@opencode-ai/sdk": "workspace:*",
@@ -692,18 +656,6 @@
         "@opentui/solid",
       ],
     },
-    "packages/protocol": {
-      "name": "@opencode-ai/protocol",
-      "dependencies": {
-        "@opencode-ai/schema": "workspace:*",
-        "effect": "catalog:",
-      },
-      "devDependencies": {
-        "@tsconfig/bun": "catalog:",
-        "@types/bun": "catalog:",
-        "@typescript/native-preview": "catalog:",
-      },
-    },
     "packages/schema": {
       "name": "@opencode-ai/schema",
       "dependencies": {
@@ -725,20 +677,6 @@
         "@types/semver": "^7.5.8",
       },
     },
-    "packages/sdk-next": {
-      "name": "@opencode-ai/sdk-next",
-      "dependencies": {
-        "@opencode-ai/client": "workspace:*",
-        "@opencode-ai/core": "workspace:*",
-        "@opencode-ai/server": "workspace:*",
-        "effect": "catalog:",
-      },
-      "devDependencies": {
-        "@tsconfig/bun": "catalog:",
-        "@types/bun": "catalog:",
-        "@typescript/native-preview": "catalog:",
-      },
-    },
     "packages/sdk/js": {
       "name": "@opencode-ai/sdk",
       "version": "1.17.10",
@@ -759,7 +697,6 @@
       "version": "1.17.10",
       "dependencies": {
         "@opencode-ai/core": "workspace:*",
-        "@opencode-ai/protocol": "workspace:*",
         "drizzle-orm": "catalog:",
         "effect": "catalog:",
       },
@@ -1896,8 +1833,6 @@
 
     "@opencode-ai/cli": ["@opencode-ai/cli@workspace:packages/cli"],
 
-    "@opencode-ai/client": ["@opencode-ai/client@workspace:packages/client"],
-
     "@opencode-ai/console-app": ["@opencode-ai/console-app@workspace:packages/console/app"],
 
     "@opencode-ai/console-core": ["@opencode-ai/console-core@workspace:packages/console/core"],
@@ -1924,22 +1859,16 @@
 
     "@opencode-ai/http-recorder": ["@opencode-ai/http-recorder@workspace:packages/http-recorder"],
 
-    "@opencode-ai/httpapi-codegen": ["@opencode-ai/httpapi-codegen@workspace:packages/httpapi-codegen"],
-
     "@opencode-ai/llm": ["@opencode-ai/llm@workspace:packages/llm"],
 
     "@opencode-ai/plugin": ["@opencode-ai/plugin@workspace:packages/plugin"],
 
-    "@opencode-ai/protocol": ["@opencode-ai/protocol@workspace:packages/protocol"],
-
     "@opencode-ai/schema": ["@opencode-ai/schema@workspace:packages/schema"],
 
     "@opencode-ai/script": ["@opencode-ai/script@workspace:packages/script"],
 
     "@opencode-ai/sdk": ["@opencode-ai/sdk@workspace:packages/sdk/js"],
 
-    "@opencode-ai/sdk-next": ["@opencode-ai/sdk-next@workspace:packages/sdk-next"],
-
     "@opencode-ai/server": ["@opencode-ai/server@workspace:packages/server"],
 
     "@opencode-ai/session-ui": ["@opencode-ai/session-ui@workspace:packages/session-ui"],

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-4RYkrGAbsrUw/n0ecPJpntSZYuV6GsmMMjK9R6MbMxU=",
-    "aarch64-linux": "sha256-kwSkouFxbEYzYAsr9gaVUQrT7YfbcoKb4kB9dhNtaFM=",
-    "aarch64-darwin": "sha256-mukRph5X1noBRhd5+0Ct7ZshTYxooGcoY+tZEXzfSvo=",
-    "x86_64-darwin": "sha256-CE8JgBAfZQmUnunPPw4XPPw3bkso1OALmNgmyGgJr1k="
+    "x86_64-linux": "sha256-gV5PVd9+MB5tM3pPH+S6YhGPRPXqHv5Ayw+8gngNlqY=",
+    "aarch64-linux": "sha256-1pxoseGyRwAawiPblo8FeaaAAdl0mkKRs6BS8qxxoh0=",
+    "aarch64-darwin": "sha256-81D/v2Ka7mtFHp4iM9eB9kjFcumSTvR07ABb1ahRLS0=",
+    "x86_64-darwin": "sha256-nolxEbc/1ItbmuHPUjaSu3DHwBV/0/Si2xuM6wpiq0k="
   }
 }

packages/app/e2e/performance/timeline/session-timeline-benchmark.fixture.ts

@@ -119,6 +119,7 @@ export async function setupTimelineBenchmark(page: Page, options: { historyTurns
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
+          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/performance/timeline/timeline-test-helpers.ts

@@ -13,6 +13,7 @@ export async function installTimelineSettings(page: Page) {
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
+          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/regression/cross-server-tab-close.spec.ts

@@ -1,135 +0,0 @@
-import { expect, test, type Page, type Route } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/core/util/encode"
-
-const serverA = "http://127.0.0.1:4096"
-const serverB = "http://127.0.0.1:4097"
-const sessionA = session("ses_server_a", "C:/server-a", "Server A session")
-const sessionB = session("ses_server_b", "/home/server-b", "Server B session")
-
-test("closing the active server's last tab opens the remaining server tab", async ({ page }) => {
-  const requests: string[] = []
-  await mockServers(page, requests)
-  await page.addInitScript(
-    ({ serverB, sessionA, sessionB }) => {
-      localStorage.setItem("settings.v3", JSON.stringify({ general: { newLayoutDesigns: true } }))
-      localStorage.setItem("opencode.global.dat:server", JSON.stringify({ list: [serverB] }))
-      localStorage.setItem(
-        "opencode.global.dat:tabs",
-        JSON.stringify([
-          { type: "session", server: "http://127.0.0.1:4096", sessionId: sessionA },
-          { type: "session", server: serverB, sessionId: sessionB },
-        ]),
-      )
-    },
-    { serverB, sessionA: sessionA.id, sessionB: sessionB.id },
-  )
-
-  const hrefA = `/server/${base64Encode(serverA)}/session/${sessionA.id}`
-  const hrefB = `/server/${base64Encode(serverB)}/session/${sessionB.id}`
-  await page.goto(hrefA)
-  await expect(page.getByText(sessionA.title).first()).toBeVisible()
-
-  const tabA = page.locator(`[data-titlebar-tab-slot]:has(a[href="${hrefA}"])`)
-  await tabA.locator('[data-slot="tab-close"] button').click()
-
-  await expect(page).toHaveURL(new RegExp(`${hrefB.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`))
-  await expect.poll(() => requests.some((url) => url.startsWith(`${serverB}/session/${sessionB.id}`))).toBe(true)
-  await expect(page.getByText(sessionB.title).first()).toBeVisible()
-  const sessionBRequests = requests.filter((url) => url.includes(`/session/${sessionB.id}`))
-  expect(sessionBRequests.every((url) => url.startsWith(serverB))).toBe(true)
-  expect(
-    requests.some((request) => {
-      const url = new URL(request)
-      return url.origin === serverB && url.searchParams.get("directory") === sessionB.directory
-    }),
-  ).toBe(true)
-})
-
-test("legacy session routes preserve an existing tab's server", async ({ page }) => {
-  await mockServers(page, [])
-  await page.addInitScript(
-    ({ serverB, sessionB }) => {
-      localStorage.setItem("settings.v3", JSON.stringify({ general: { newLayoutDesigns: true } }))
-      localStorage.setItem("opencode.global.dat:server", JSON.stringify({ list: [serverB] }))
-      localStorage.setItem(
-        "opencode.global.dat:tabs",
-        JSON.stringify([{ type: "session", server: serverB, sessionId: sessionB }]),
-      )
-    },
-    { serverB, sessionB: sessionB.id },
-  )
-
-  const hrefB = `/server/${base64Encode(serverB)}/session/${sessionB.id}`
-  await page.goto(`/${base64Encode(sessionB.directory)}/session/${sessionB.id}`)
-  await expect(page).toHaveURL(new RegExp(`${hrefB.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`))
-})
-
-function session(id: string, directory: string, title: string) {
-  return {
-    id,
-    slug: id,
-    projectID: `project-${id}`,
-    directory,
-    title,
-    version: "dev",
-    time: { created: 1, updated: 1 },
-  }
-}
-
-async function mockServers(page: Page, requests: string[]) {
-  await page.route("**/*", async (route) => {
-    const url = new URL(route.request().url())
-    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
-    requests.push(url.toString())
-    const current = url.origin === serverA ? sessionA : sessionB
-    const directory = url.searchParams.get("directory")
-    if (directory && directory !== current.directory) return json(route, { name: "InvalidDirectory" }, 500)
-    if (url.pathname === "/global/event" || url.pathname === "/event") return sse(route)
-    if (url.pathname === "/global/health") return json(route, { healthy: true })
-    if (url.pathname === "/session") return json(route, [current])
-    if (url.pathname === `/session/${current.id}`) return json(route, current)
-    if (/^\/session\/[^/]+$/.test(url.pathname)) return json(route, { name: "NotFoundError" }, 404)
-    if (url.pathname === `/session/${current.id}/message`) return json(route, [])
-    if (/^\/session\/[^/]+\/(children|todo|diff)$/.test(url.pathname)) return json(route, [])
-    if (["/skill", "/command", "/lsp", "/formatter", "/permission", "/question", "/vcs/diff"].includes(url.pathname))
-      return json(route, [])
-    if (["/global/config", "/config", "/provider/auth", "/mcp", "/session/status"].includes(url.pathname))
-      return json(route, {})
-    if (url.pathname === "/provider")
-      return json(route, { all: [], connected: [], default: { providerID: "", modelID: "" } })
-    if (url.pathname === "/agent") return json(route, [{ name: "build", mode: "primary" }])
-    if (url.pathname === "/project" || url.pathname === "/project/current") {
-      const project = {
-        id: current.projectID,
-        worktree: current.directory,
-        vcs: "git",
-        time: { created: 1, updated: 1 },
-        sandboxes: [],
-      }
-      return json(route, url.pathname === "/project" ? [project] : project)
-    }
-    if (url.pathname === "/path")
-      return json(route, {
-        state: current.directory,
-        config: current.directory,
-        worktree: current.directory,
-        directory: current.directory,
-        home: current.directory,
-      })
-    if (url.pathname === "/vcs") return json(route, { branch: "main", default_branch: "main" })
-    return json(route, {})
-  })
-}
-
-function json(route: Route, body: unknown, status = 200) {
-  return route.fulfill({
-    status,
-    contentType: "application/json",
-    headers: { "access-control-allow-origin": "*" },
-    body: JSON.stringify(body),
-  })
-}
-
-function sse(route: Route) {
-  return route.fulfill({ status: 200, contentType: "text/event-stream", body: ": ok\n\n" })
-}

packages/app/e2e/regression/session-request-docks.spec.ts

@@ -1,132 +0,0 @@
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import { expect, test, type Page } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/RequestDocks"
-const projectID = "proj_request_docks"
-const sessionID = "ses_request_docks"
-const title = "Request dock regression"
-
-test("shows a pending question dock", async ({ page }) => {
-  await mockServer(page, {
-    questions: [
-      {
-        id: "question-request",
-        sessionID,
-        questions: [
-          {
-            header: "Implementation",
-            question: "Which implementation should be used?",
-            options: [
-              { label: "Minimal", description: "Use the smallest correct change" },
-              { label: "Extended", description: "Include additional behavior" },
-            ],
-          },
-        ],
-      },
-    ],
-  })
-
-  await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-  await expectSessionTitle(page, title)
-
-  const question = page.locator('[data-component="dock-prompt"][data-kind="question"]')
-  await expect(question).toBeVisible()
-  await expect(question.getByText("Which implementation should be used?")).toBeVisible()
-  await expect(question.getByRole("radio", { name: /Minimal/ })).toBeVisible()
-  await expect(question.getByRole("radio", { name: /Extended/ })).toBeVisible()
-  await expect(page.locator('[data-component="session-composer"]')).toHaveCount(0)
-
-  await question.getByRole("radio", { name: /Minimal/ }).click()
-  const reply = page.waitForRequest(
-    (request) => request.method() === "POST" && new URL(request.url()).pathname === "/question/question-request/reply",
-  )
-  await question.getByRole("button", { name: "Submit" }).click()
-  expect((await reply).postDataJSON()).toEqual({ answers: [["Minimal"]] })
-})
-
-test("shows a pending permission dock", async ({ page }) => {
-  await mockServer(page, {
-    permissions: [
-      {
-        id: "permission-request",
-        sessionID,
-        permission: "bash",
-        patterns: ["git status", "git diff"],
-        metadata: {},
-        always: [],
-      },
-    ],
-  })
-
-  await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-  await expectSessionTitle(page, title)
-
-  const permission = page.locator('[data-component="dock-prompt"][data-kind="permission"]')
-  await expect(permission).toBeVisible()
-  await expect(permission.getByText("git status")).toBeVisible()
-  await expect(permission.getByText("git diff")).toBeVisible()
-  await expect(permission.locator('[data-slot="permission-footer-actions"] button')).toHaveCount(3)
-  await expect(page.locator('[data-component="session-composer"]')).toHaveCount(0)
-
-  const reply = page.waitForRequest((request) => request.method() === "POST")
-  await permission.getByRole("button", { name: "Allow once" }).click()
-  const request = await reply
-  expect(new URL(request.url()).pathname).toBe(`/session/${sessionID}/permissions/permission-request`)
-  expect(request.postDataJSON()).toEqual({ response: "once" })
-})
-
-async function mockServer(
-  page: Page,
-  requests: {
-    permissions?: unknown[] | (() => unknown[])
-    questions?: unknown[] | (() => unknown[])
-  },
-) {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: projectID,
-      worktree: directory,
-      vcs: "git",
-      name: "request-docks",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: {
-      all: [
-        {
-          id: "opencode",
-          name: "OpenCode",
-          models: {
-            "claude-opus-4-6": {
-              id: "claude-opus-4-6",
-              name: "Claude Opus 4.6",
-              limit: { context: 200_000 },
-            },
-          },
-        },
-      ],
-      connected: ["opencode"],
-      default: { providerID: "opencode", modelID: "claude-opus-4-6" },
-    },
-    sessions: [
-      {
-        id: sessionID,
-        slug: "request-docks",
-        projectID,
-        directory,
-        title,
-        version: "dev",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-    ],
-    pageMessages: () => ({ items: [] }),
-    permissions: requests.permissions,
-    questions: requests.questions,
-  })
-  await page.addInitScript(() => {
-    localStorage.setItem("settings.v3", JSON.stringify({ general: { newLayoutDesigns: true } }))
-  })
-}

packages/app/e2e/regression/session-timeline-collapse-state.spec.ts

@@ -261,6 +261,7 @@ async function configurePage(page: Page) {
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
+          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/regression/session-timeline-context-resize.spec.ts

@@ -47,6 +47,7 @@ async function configurePage(page: Page) {
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
+          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/regression/session-todo-dock-navigation.spec.ts

@@ -1,186 +0,0 @@
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import { expect, test, type Page } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/TodoDockNavigation"
-const projectID = "proj_todo_dock_navigation"
-const sourceID = "ses_todo_dock_source"
-const otherID = "ses_todo_dock_other"
-const sourceTitle = "Todo dock animation"
-const otherTitle = "Separate session"
-
-const activeTodos = [
-  { id: "todo-1", content: "Receive todos in the active session", status: "completed", priority: "high" },
-  { id: "todo-2", content: "Keep the dock visible across tabs", status: "completed", priority: "high" },
-  { id: "todo-3", content: "Close after the final todo", status: "in_progress", priority: "high" },
-]
-
-type EventPayload = {
-  directory: string
-  payload: Record<string, unknown>
-}
-
-test.use({ viewport: { width: 1440, height: 900 }, reducedMotion: "no-preference" })
-
-test("animates todo lifecycle without replaying it across session tabs", async ({ page }) => {
-  test.setTimeout(90_000)
-  const events: EventPayload[] = []
-  const todos: Record<string, typeof activeTodos> = { [sourceID]: [], [otherID]: [] }
-
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: projectID,
-      worktree: directory,
-      vcs: "git",
-      name: "todo-dock-navigation",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: {
-      all: [
-        {
-          id: "opencode",
-          name: "OpenCode",
-          models: {
-            "claude-opus-4-6": {
-              id: "claude-opus-4-6",
-              name: "Claude Opus 4.6",
-              limit: { context: 200_000 },
-            },
-          },
-        },
-      ],
-      connected: ["opencode"],
-      default: { providerID: "opencode", modelID: "claude-opus-4-6" },
-    },
-    sessions: [session(sourceID, sourceTitle, 1700000000000), session(otherID, otherTitle, 1700000001000)],
-    pageMessages: () => ({ items: [] }),
-    events: () => events.splice(0, 1),
-    eventRetry: 16,
-    todos: (sessionID) => todos[sessionID] ?? [],
-  })
-  await configurePage(page)
-
-  await page.goto(sessionHref(sourceID))
-  await expectSessionTitle(page, sourceTitle)
-  const dock = page.locator('[data-component="session-todo-dock"]')
-  await expect(dock).toHaveCount(0)
-
-  events.push(statusEvent(sourceID, "busy"))
-  await expect(page.getByRole("button", { name: "Stop" })).toBeVisible()
-
-  await page.waitForTimeout(700)
-  const opening = sampleDock(page, 1_000)
-  todos[sourceID] = activeTodos
-  events.push(todoEvent(sourceID, activeTodos))
-  await expect(dock).toBeVisible()
-  await expect(dock.locator('[data-state="in_progress"]')).toHaveCount(1)
-  expect((await opening).some((sample) => sample.opacity > 0.05 && sample.opacity < 0.95)).toBe(true)
-
-  await switchSession(page, otherID, otherTitle)
-  await expect(dock).toHaveCount(0)
-
-  const returningOpen = sampleDock(page, 700)
-  await switchSession(page, sourceID, sourceTitle)
-  const openSamples = (await returningOpen).filter((sample) => sample.present)
-  expect(openSamples.length).toBeGreaterThan(0)
-  expect(openSamples[0]!.opacity).toBeGreaterThan(0.98)
-  expect(openSamples[0]!.height).toBeGreaterThan(70)
-  await expect(dock.locator('[data-state="in_progress"]')).toHaveCount(1)
-
-  const completedTodos = activeTodos.map((todo) => ({ ...todo, status: "completed" }))
-  const closing = sampleDock(page, 1_000)
-  todos[sourceID] = completedTodos
-  events.push(todoEvent(sourceID, completedTodos))
-  await expect(dock).toHaveCount(0)
-  expect((await closing).some((sample) => sample.opacity > 0.05 && sample.opacity < 0.95)).toBe(true)
-  todos[sourceID] = []
-  events.push(todoEvent(sourceID, []))
-
-  await switchSession(page, otherID, otherTitle)
-  const returningEmpty = sampleDock(page, 700)
-  await switchSession(page, sourceID, sourceTitle)
-  await expect(dock).toHaveCount(0)
-  expect((await returningEmpty).every((sample) => !sample.present)).toBe(true)
-})
-
-function session(id: string, title: string, created: number) {
-  return {
-    id,
-    slug: id,
-    projectID,
-    directory,
-    title,
-    version: "dev",
-    time: { created, updated: created },
-  }
-}
-
-function statusEvent(sessionID: string, type: "busy" | "idle"): EventPayload {
-  return {
-    directory,
-    payload: { type: "session.status", properties: { sessionID, status: { type } } },
-  }
-}
-
-function todoEvent(sessionID: string, next: typeof activeTodos): EventPayload {
-  return {
-    directory,
-    payload: { type: "todo.updated", properties: { sessionID, todos: next } },
-  }
-}
-
-async function configurePage(page: Page) {
-  const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-  await page.addInitScript(
-    ({ directory, dirBase64, server, sessionIDs }) => {
-      localStorage.setItem("settings.v3", JSON.stringify({ general: { newLayoutDesigns: true } }))
-      localStorage.setItem(
-        "opencode.global.dat:server",
-        JSON.stringify({
-          projects: { local: [{ worktree: directory, expanded: true }] },
-          lastProject: { local: directory },
-        }),
-      )
-      localStorage.setItem(
-        "opencode.global.dat:tabs",
-        JSON.stringify(sessionIDs.map((sessionId) => ({ type: "session", server, dirBase64, sessionId }))),
-      )
-    },
-    { directory, dirBase64: base64Encode(directory), server, sessionIDs: [sourceID, otherID] },
-  )
-}
-
-function sessionHref(sessionID: string) {
-  const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-  return `/server/${base64Encode(server)}/session/${sessionID}`
-}
-
-async function switchSession(page: Page, sessionID: string, title: string) {
-  const href = sessionHref(sessionID)
-  const tab = page.locator(`[data-slot="titlebar-tabs"] a[href="${href}"]`).first()
-  await expect(tab).toBeVisible()
-  await tab.click()
-  await expectSessionTitle(page, title)
-}
-
-function sampleDock(page: Page, duration: number) {
-  return page.evaluate(async (duration) => {
-    const samples: { present: boolean; height: number; opacity: number }[] = []
-    const start = performance.now()
-    while (performance.now() - start < duration) {
-      const dock = document.querySelector<HTMLElement>('[data-component="session-todo-dock"]')
-      const clip = dock?.parentElement?.parentElement
-      const label = dock?.querySelector<HTMLElement>('[data-action="session-todo-toggle"] span[aria-label]')
-      samples.push({
-        present: !!dock,
-        height: clip?.getBoundingClientRect().height ?? 0,
-        opacity: label ? Number.parseFloat(getComputedStyle(label).opacity) : 0,
-      })
-      await new Promise(requestAnimationFrame)
-    }
-    return samples
-  }, duration)
-}

packages/app/e2e/smoke/session-timeline.spec.ts

@@ -362,6 +362,7 @@ async function configureSmokePage(page: Page, directory: string) {
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
+          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/utils/mock-server.ts

@@ -1,6 +1,15 @@
 import type { Page, Route } from "@playwright/test"
 
-const emptyList = new Set(["/skill", "/command", "/lsp", "/formatter", "/vcs/status", "/vcs/diff"])
+const emptyList = new Set([
+  "/skill",
+  "/command",
+  "/lsp",
+  "/formatter",
+  "/permission",
+  "/question",
+  "/vcs/status",
+  "/vcs/diff",
+])
 const emptyObject = new Set(["/global/config", "/config", "/provider/auth", "/mcp", "/session/status"])
 
 export interface MockServerConfig {
@@ -14,9 +23,6 @@ export interface MockServerConfig {
   onMessages?: (input: { sessionID: string; before?: string; phase: "start" | "end" }) => void
   events?: () => unknown[]
   eventRetry?: number
-  todos?: (sessionID: string) => unknown[]
-  permissions?: unknown[] | (() => unknown[])
-  questions?: unknown[] | (() => unknown[])
 }
 
 export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
@@ -49,10 +55,6 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
     const path = url.pathname
     if (path === "/global/event" || path === "/event") return sse(route, config.events?.(), config.eventRetry)
     if (path === "/global/health") return json(route, { healthy: true })
-    if (path === "/permission")
-      return json(route, typeof config.permissions === "function" ? config.permissions() : (config.permissions ?? []))
-    if (path === "/question")
-      return json(route, typeof config.questions === "function" ? config.questions() : (config.questions ?? []))
     if (path === "/vcs/diff" && config.vcsDiff) return json(route, config.vcsDiff)
     if (emptyObject.has(path)) return json(route, {})
     if (emptyList.has(path)) return json(route, [])
@@ -64,9 +66,7 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
       return json(route, session ?? {})
     }
 
-    const todoMatch = path.match(/^\/session\/([^/]+)\/todo$/)
-    if (todoMatch) return json(route, config.todos?.(todoMatch[1]!) ?? [])
-    if (/^\/session\/[^/]+\/(children|diff)$/.test(path)) return json(route, [])
+    if (/^\/session\/[^/]+\/(children|todo|diff)$/.test(path)) return json(route, [])
 
     const messagesMatch = path.match(/^\/session\/([^/]+)\/message$/)
     if (messagesMatch) {

packages/app/package.json

@@ -17,9 +17,9 @@
     "dev": "vite",
     "build": "vite build",
     "serve": "vite preview",
-    "test": "bun run test:unit && bun run test:browser",
+    "test": "bun run test:unit && bun run test:virtualizer",
     "test:unit": "bun test --only-failures --preload ./happydom.ts ./src",
-    "test:browser": "bun test --conditions=browser --preload ./happydom.ts ./test-browser",
+    "test:virtualizer": "bun test --conditions=browser --preload ./happydom.ts ./test-browser/solid-virtual.test.ts",
     "test:unit:watch": "bun test --watch --preload ./happydom.ts ./src",
     "test:e2e": "playwright test",
     "test:e2e:local": "playwright test",

packages/app/src/app.tsx

@@ -31,8 +31,8 @@ import { CommandProvider } from "@/context/command"
 import { CommentsProvider } from "@/context/comments"
 import { FileProvider } from "@/context/file"
 import { ServerSDKProvider, useServerSDK } from "@/context/server-sdk"
-import { ServerSyncProvider, useServerSync } from "@/context/server-sync"
-import { GlobalProvider } from "@/context/global"
+import { ServerSyncProvider } from "@/context/server-sync"
+import { GlobalProvider, useGlobal } from "@/context/global"
 import { HighlightsProvider } from "@/context/highlights"
 import { LanguageProvider, type Locale, useLanguage } from "@/context/language"
 import { LayoutProvider } from "@/context/layout"
@@ -51,13 +51,7 @@ 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,
-  selectSessionLineage,
-  sessionHref,
-} from "./utils/session-route"
+import { legacySessionHref, requireServerKey, rootSession, sessionHref } from "./utils/session-route"
 
 import Session from "@/pages/session"
 import { NewHome, LegacyHome } from "@/pages/home"
@@ -73,15 +67,7 @@ const SessionRoute = () => {
   const tabs = useTabs()
 
   if (params.id && settings.general.newLayoutDesigns()) {
-    const sessionID = params.id
-    return (
-      <Show when={tabs.ready()}>
-        {(_) => {
-          const persisted = tabs.store.filter((item) => item.type === "session")
-          return <Navigate href={sessionHref(legacySessionServer(persisted, sessionID, server.key), sessionID)} />
-        }}
-      </Show>
-    )
+    return <Navigate href={sessionHref(server.key, params.id)} />
   }
 
   // When the new layout is enabled, the legacy new-session route (/:dir/session with no id)
@@ -109,7 +95,7 @@ const TargetSessionRoute = () => {
   })
 
   return (
-    <Show when={requireServerKey(params.serverKey)} keyed>
+    <Show when={`${params.serverKey}\0${params.id}`} keyed>
       <ServerSDKProvider server={conn}>
         <ServerSyncProvider server={conn}>
           <ResolvedTargetSessionRoute />
@@ -123,32 +109,43 @@ function ResolvedTargetSessionRoute() {
   const params = useParams<{ serverKey: string; id: string }>()
   const settings = useSettings()
   const tabs = useTabs()
-  const sync = useServerSync()
+  const global = useGlobal()
+  const serverSDK = useServerSDK()
   const serverKey = createMemo(() => requireServerKey(params.serverKey))
-  const cached = createMemo(() => sync().session.lineage.peek(params.id))
+  const placement = createMemo(() => global.sessionPlacement.get(serverKey(), params.id))
   const [resolved] = createResource(
     () => {
-      if (cached()) return
-      return { id: params.id, sync: sync() }
+      if (placement()) return
+      return { id: params.id, sdk: serverSDK() }
+    },
+    async ({ id, sdk }) => {
+      const session = (await sdk.client.session.get({ sessionID: id })).data!
+      const root = await rootSession(session, (sessionID) =>
+        sdk.client.session.get({ sessionID }).then((result) => result.data!),
+      )
+      return global.sessionPlacement.set({
+        server: serverKey(),
+        leafID: session.id,
+        rootID: root.id,
+        directory: session.directory,
+      })
     },
-    ({ id, sync }) => sync.session.lineage.resolve(id),
   )
-  const current = createMemo(() => selectSessionLineage(params.id, cached(), resolved()))
-  const directory = createMemo(() => current()?.session.directory)
+  const directory = createMemo(() => placement()?.directory ?? resolved()?.directory)
   const targetDirectory = () => directory()!
 
   createEffect(() => {
-    const session = current()
-    if (!session) return
+    const current = placement() ?? resolved()
+    if (!current) return
     tabs.addSessionTab({
       server: serverKey(),
-      sessionId: session.root.id,
+      sessionId: current.rootID,
     })
   })
 
   return (
     <TargetServerScopedProviders directory={directory} sessionID={() => params.id}>
-      <Show when={!!current() || resolved.state !== "errored"} fallback={<ErrorPage error={resolved.error} />}>
+      <Show when={!resolved.error} fallback={<ErrorPage error={resolved.error} />}>
         <Show when={directory()}>
           <Show
             when={settings.general.newLayoutDesigns()}
@@ -308,7 +305,7 @@ function ServerScopedProviders(props: ServerScopedShellProps) {
     <PermissionProvider directory={props.directory}>
       <LayoutProvider>
         <NotificationProvider directory={props.directory} sessionID={props.sessionID}>
-          <ModelsProvider directory={props.directory}>{props.children}</ModelsProvider>
+          <ModelsProvider>{props.children}</ModelsProvider>
         </NotificationProvider>
       </LayoutProvider>
     </PermissionProvider>
@@ -337,7 +334,7 @@ function TargetServerScopedProviders(props: ServerScopedShellProps) {
   return (
     <PermissionProvider directory={props.directory}>
       <NotificationProvider directory={props.directory} sessionID={props.sessionID}>
-        <ModelsProvider directory={props.directory}>{props.children}</ModelsProvider>
+        <ModelsProvider>{props.children}</ModelsProvider>
       </NotificationProvider>
     </PermissionProvider>
   )

packages/app/src/components/dialog-connect-provider.tsx

@@ -9,7 +9,7 @@ import { ProviderIcon } from "@opencode-ai/ui/provider-icon"
 import { Spinner } from "@opencode-ai/ui/spinner"
 import { TextField } from "@opencode-ai/ui/text-field"
 import { showToast } from "@/utils/toast"
-import { type Accessor, createEffect, createMemo, createResource, Match, onCleanup, onMount, Switch } from "solid-js"
+import { createEffect, createMemo, createResource, Match, onCleanup, onMount, Switch } from "solid-js"
 import { createStore, produce } from "solid-js/store"
 import { Link } from "@/components/link"
 import { useServerSDK } from "@/context/server-sdk"
@@ -17,16 +17,16 @@ import { useServerSync } from "@/context/server-sync"
 import { useLanguage } from "@/context/language"
 import { useProviders } from "@/hooks/use-providers"
 
-export function DialogConnectProvider(props: { provider: string; directory?: Accessor<string | undefined> }) {
+export function DialogConnectProvider(props: { provider: string }) {
   const dialog = useDialog()
   const serverSync = useServerSync()
   const serverSDK = useServerSDK()
   const language = useLanguage()
-  const providers = useProviders(props.directory)
+  const providers = useProviders()
 
   const all = () => {
     void import("./dialog-select-provider").then((x) => {
-      dialog.show(() => <x.DialogSelectProvider directory={props.directory} />)
+      dialog.show(() => <x.DialogSelectProvider />)
     })
   }
 

packages/app/src/components/dialog-custom-provider.tsx

@@ -6,7 +6,7 @@ import { ProviderIcon } from "@opencode-ai/ui/provider-icon"
 import { useMutation } from "@tanstack/solid-query"
 import { TextField } from "@opencode-ai/ui/text-field"
 import { showToast } from "@/utils/toast"
-import { type Accessor, batch, For } from "solid-js"
+import { batch, For } from "solid-js"
 import { createStore, produce } from "solid-js/store"
 import { Link } from "@/components/link"
 import { useServerSDK } from "@/context/server-sdk"
@@ -17,7 +17,6 @@ import { DialogSelectProvider } from "./dialog-select-provider"
 
 type Props = {
   back?: "providers" | "close"
-  directory?: Accessor<string | undefined>
 }
 
 export function DialogCustomProvider(props: Props) {
@@ -41,7 +40,7 @@ export function DialogCustomProvider(props: Props) {
       dialog.close()
       return
     }
-    dialog.show(() => <DialogSelectProvider directory={props.directory} />)
+    dialog.show(() => <DialogSelectProvider />)
   }
 
   const addModel = () => {

packages/app/src/components/dialog-manage-models.tsx

@@ -9,16 +9,14 @@ import { popularProviders } from "@/hooks/use-providers"
 import { useLanguage } from "@/context/language"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { DialogSelectProvider } from "./dialog-select-provider"
-import { decode64 } from "@/utils/base64"
 
 export const DialogManageModels: Component = () => {
   const local = useLocal()
   const language = useLanguage()
   const dialog = useDialog()
-  const directory = () => decode64(local.slug())
 
   const handleConnectProvider = () => {
-    dialog.show(() => <DialogSelectProvider directory={directory} />)
+    dialog.show(() => <DialogSelectProvider />)
   }
   const providerRank = (id: string) => popularProviders.indexOf(id)
   const providerList = (providerID: string) => local.model.list().filter((x) => x.provider.id === providerID)

packages/app/src/components/dialog-select-model-unpaid.tsx

@@ -10,27 +10,24 @@ import { useLocal } from "@/context/local"
 import { popularProviders, useProviders } from "@/hooks/use-providers"
 import { ModelTooltip } from "./model-tooltip"
 import { useLanguage } from "@/context/language"
-import { decode64 } from "@/utils/base64"
 
 type ModelState = ReturnType<typeof useLocal>["model"]
 
 export const DialogSelectModelUnpaid: Component<{ model?: ModelState }> = (props) => {
-  const local = useLocal()
-  const model = props.model ?? local.model
+  const model = props.model ?? useLocal().model
   const dialog = useDialog()
-  const directory = () => decode64(local.slug())
-  const providers = useProviders(directory)
+  const providers = useProviders()
   const language = useLanguage()
 
   const connect = (provider: string) => {
     void import("./dialog-connect-provider").then((x) => {
-      dialog.show(() => <x.DialogConnectProvider provider={provider} directory={directory} />)
+      dialog.show(() => <x.DialogConnectProvider provider={provider} />)
     })
   }
 
   const all = () => {
     void import("./dialog-select-provider").then((x) => {
-      dialog.show(() => <x.DialogSelectProvider directory={directory} />)
+      dialog.show(() => <x.DialogSelectProvider />)
     })
   }
 

packages/app/src/components/dialog-select-model.tsx

@@ -12,7 +12,6 @@ import { List } from "@opencode-ai/ui/list"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { ModelTooltip } from "./model-tooltip"
 import { useLanguage } from "@/context/language"
-import { decode64 } from "@/utils/base64"
 
 const isFree = (provider: string, cost: { input: number } | undefined) =>
   provider === "opencode" && (!cost || cost.input === 0)
@@ -105,8 +104,6 @@ export function ModelSelectorPopover(props: {
     dismiss: null,
   })
   const dialog = useDialog()
-  const local = useLocal()
-  const directory = () => decode64(local.slug())
 
   const close = (dismiss: Dismiss) => {
     setStore("dismiss", dismiss)
@@ -123,7 +120,7 @@ export function ModelSelectorPopover(props: {
   const handleConnectProvider = () => {
     close("provider")
     void import("./dialog-select-provider").then((x) => {
-      dialog.show(() => <x.DialogSelectProvider directory={directory} />)
+      dialog.show(() => <x.DialogSelectProvider />)
     })
   }
   const language = useLanguage()
@@ -202,12 +199,10 @@ export function ModelSelectorPopover(props: {
 export const DialogSelectModel: Component<{ provider?: string; model?: ModelState }> = (props) => {
   const dialog = useDialog()
   const language = useLanguage()
-  const local = useLocal()
-  const directory = () => decode64(local.slug())
 
   const provider = () => {
     void import("./dialog-select-provider").then((x) => {
-      dialog.show(() => <x.DialogSelectProvider directory={directory} />)
+      dialog.show(() => <x.DialogSelectProvider />)
     })
   }
 

packages/app/src/components/dialog-select-provider.tsx

@@ -1,4 +1,4 @@
-import { type Accessor, Component, Show } from "solid-js"
+import { Component, Show } from "solid-js"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { popularProviders, useProviders } from "@/hooks/use-providers"
 import { Dialog } from "@opencode-ai/ui/dialog"
@@ -11,9 +11,9 @@ import { DialogCustomProvider } from "./dialog-custom-provider"
 
 const CUSTOM_ID = "_custom"
 
-export const DialogSelectProvider: Component<{ directory?: Accessor<string | undefined> }> = (props) => {
+export const DialogSelectProvider: Component = () => {
   const dialog = useDialog()
-  const providers = useProviders(props.directory)
+  const providers = useProviders()
   const language = useLanguage()
 
   const popularGroup = () => language.t("dialog.provider.group.popular")
@@ -56,10 +56,10 @@ export const DialogSelectProvider: Component<{ directory?: Accessor<string | und
         onSelect={(x) => {
           if (!x) return
           if (x.id === CUSTOM_ID) {
-            dialog.show(() => <DialogCustomProvider back="providers" directory={props.directory} />)
+            dialog.show(() => <DialogCustomProvider back="providers" />)
             return
           }
-          dialog.show(() => <DialogConnectProvider provider={x.id} directory={props.directory} />)
+          dialog.show(() => <DialogConnectProvider provider={x.id} />)
         }}
       >
         {(i) => (

packages/app/src/components/prompt-input.stories.tsx

@@ -1,27 +1,11 @@
 // @ts-nocheck
 import { createStore } from "solid-js/store"
-import type { Todo } from "@opencode-ai/sdk/v2"
 import { createPromptState } from "@/context/prompt"
-import { SessionComposerRegion } from "@/pages/session/composer"
 import { createPromptInputHistory, PromptInput } from "./prompt-input"
 
-function createPromptInputStoryRuntime() {
-  const state = createPromptState()
-  return {
-    state,
-    history: createPromptInputHistory(),
-    submission: {
-      abort() {},
-      handleSubmit(event: Event) {
-        event.preventDefault()
-        state.reset()
-      },
-    },
-  }
-}
-
 function PromptInputExample() {
-  const input = createPromptInputStoryRuntime()
+  const state = createPromptState()
+  const history = createPromptInputHistory()
   const [controls, setControls] = createStore({
     agent: "build",
     variant: undefined as string | undefined,
@@ -38,6 +22,13 @@ function PromptInputExample() {
       set: (variant?: string) => setControls("variant", variant),
     },
   }
+  const submission = {
+    abort() {},
+    handleSubmit(event: Event) {
+      event.preventDefault()
+      state.reset()
+    },
+  }
   const inputControls = {
     agents: {
       available: [{ name: "review", hidden: false, mode: "subagent" }],
@@ -78,7 +69,7 @@ function PromptInputExample() {
   const addReviewComment = () => {
     const comment = controls.comments + 1
     setControls("comments", comment)
-    input.state.context.add({
+    state.context.add({
       type: "file",
       path: "src/components/prompt-input.tsx",
       selection: {
@@ -96,7 +87,7 @@ function PromptInputExample() {
 
   return (
     <div class="flex flex-col gap-3">
-      <PromptInput controls={inputControls} {...input} />
+      <PromptInput controls={inputControls} state={state} history={history} submission={submission} />
       <div>
         <button
           type="button"
@@ -110,82 +101,6 @@ function PromptInputExample() {
   )
 }
 
-const todos: Todo[] = [
-  { id: "todo-1", content: "Inspect the session composer animation", status: "completed" },
-  { id: "todo-2", content: "Keep the dock settled on initial render", status: "in_progress" },
-  { id: "todo-3", content: "Verify session navigation behavior", status: "pending" },
-]
-
-function PromptInputWithOpenDock() {
-  const input = createPromptInputStoryRuntime()
-  const [controls, setControls] = createStore({
-    agent: "build",
-    activeTab: undefined as string | undefined,
-    todoCollapsed: false,
-  })
-  const inputControls = {
-    agents: {
-      available: [],
-      options: ["build"],
-      get current() {
-        return controls.agent
-      },
-      loading: false,
-      visible: true,
-      select: (agent?: string) => setControls("agent", agent ?? "build"),
-    },
-    model: {
-      selection: {
-        current: () => ({ id: "claude-3-7-sonnet", name: "Claude 3.7 Sonnet", provider: { id: "anthropic" } }),
-        variant: { list: () => [], current: () => undefined, set: () => {} },
-      },
-      paid: true,
-      loading: false,
-    },
-    projects: { available: [], directory: "/tmp/story", select: () => {}, add: () => {} },
-    session: {
-      id: "story-session",
-      tabs: {
-        active: () => controls.activeTab,
-        all: () => [],
-        open: () => {},
-        setActive: (tab: string) => setControls("activeTab", tab),
-      },
-      reviewPanel: { opened: () => false, open: () => {} },
-    },
-    newLayoutDesigns: true,
-  }
-  const state = {
-    blocked: () => false,
-    questionRequest: () => undefined,
-    permissionRequest: () => undefined,
-    permissionResponding: () => false,
-    decide: () => {},
-    todos: () => todos,
-    dock: () => true,
-    closing: () => false,
-    opening: () => false,
-  }
-
-  return (
-    <SessionComposerRegion
-      state={state}
-      sessionKey="story-session"
-      sessionID="story-session"
-      controls={inputControls}
-      promptInput={{ ...input, ref: () => {}, newSessionWorktree: "", onNewSessionWorktreeReset: () => {} }}
-      todo={{
-        collapsed: controls.todoCollapsed,
-        onToggle: () => setControls("todoCollapsed", (collapsed) => !collapsed),
-      }}
-      ready
-      centered={false}
-      onResponseSubmit={() => {}}
-      setPromptDockRef={() => {}}
-    />
-  )
-}
-
 export default {
   title: "App/PromptInput",
   id: "app-prompt-input",
@@ -200,12 +115,3 @@ export const Basic = {
     </div>
   ),
 }
-
-export const DockAlreadyOpen = {
-  render: () => (
-    <div class="pt-10">
-      <h1 class="mb-4">Prompt Input with open Todo dock</h1>
-      <PromptInputWithOpenDock />
-    </div>
-  ),
-}

packages/app/src/components/prompt-input.tsx

@@ -67,7 +67,6 @@ import { PromptContextItems } from "./prompt-input/context-items"
 import { PromptImageAttachments } from "./prompt-input/image-attachments"
 import { PromptDragOverlay } from "./prompt-input/drag-overlay"
 import { promptPlaceholder } from "./prompt-input/placeholder"
-import { createPromptInputTransientState } from "./prompt-input/transient-state"
 import { showToast } from "@/utils/toast"
 import { ImagePreview } from "@opencode-ai/ui/image-preview"
 import { pathKey } from "@/utils/path-key"
@@ -347,10 +346,25 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     prompt.current().filter((part): part is ImageAttachmentPart => part.type === "image"),
   )
 
-  const [store, setStore] = createPromptInputTransientState(
-    () => prompt.capture(),
-    Math.floor(Math.random() * EXAMPLES.length),
-  )
+  const [store, setStore] = createStore<{
+    popover: "at" | "slash" | null
+    historyIndex: number
+    savedPrompt: PromptHistoryEntry | null
+    placeholder: number
+    draggingType: "image" | "@mention" | null
+    mode: "normal" | "shell"
+    applyingHistory: boolean
+    variantOpen: boolean
+  }>({
+    popover: null,
+    historyIndex: -1,
+    savedPrompt: null as PromptHistoryEntry | null,
+    placeholder: Math.floor(Math.random() * EXAMPLES.length),
+    draggingType: null,
+    mode: "normal",
+    applyingHistory: false,
+    variantOpen: false,
+  })
   const [picker, setPicker] = createStore({
     projectOpen: false,
     projectSearch: "",

packages/app/src/components/prompt-input/attachments.ts

@@ -25,19 +25,6 @@ function dataUrl(file: File, mime: string) {
   })
 }
 
-type PromptTarget = Pick<ReturnType<ReturnType<typeof usePrompt>["capture"]>, "current" | "cursor" | "set">
-type AttachmentTarget = { prompt: PromptTarget; cursor: number | undefined }
-
-type PromptAttachmentsCoreInput = {
-  capture: () => PromptTarget
-  editor: () => HTMLDivElement | undefined
-  focusEditor?: () => void
-  addPart?: (part: ContentPart) => boolean
-  warn?: () => void
-  readClipboardImage?: () => Promise<File | null>
-  getPathForFile?: (file: File) => string
-}
-
 type PromptAttachmentsInput = {
   prompt: ReturnType<typeof usePrompt>
   editor: () => HTMLDivElement | undefined
@@ -49,22 +36,27 @@ type PromptAttachmentsInput = {
   getPathForFile?: (file: File) => string
 }
 
-export function createPromptAttachmentsCore(input: PromptAttachmentsCoreInput) {
-  const capture = (): AttachmentTarget | undefined => {
-    const prompt = input.capture()
-    const editor = input.editor()
-    if (!editor) return
-    return { prompt, cursor: prompt.cursor() ?? getCursorPosition(editor) }
+export function createPromptAttachments(input: PromptAttachmentsInput) {
+  const prompt = input.prompt
+  const language = useLanguage()
+
+  const warn = () => {
+    showToast({
+      title: language.t("prompt.toast.pasteUnsupported.title"),
+      description: language.t("prompt.toast.pasteUnsupported.description"),
+    })
   }
 
-  const add = async (file: File, toast = true, target = capture()) => {
-    if (!target) return false
+  const add = async (file: File, toast = true) => {
     const mime = await attachmentMime(file)
     if (!mime) {
-      if (toast) input.warn?.()
+      if (toast) warn()
       return false
     }
 
+    const editor = input.editor()
+    if (!editor) return false
+
     const url = await dataUrl(file, mime)
     if (!url) return false
 
@@ -76,42 +68,34 @@ export function createPromptAttachmentsCore(input: PromptAttachmentsCoreInput) {
       mime,
       dataUrl: url,
     }
-    target.prompt.set([...target.prompt.current(), attachment], target.cursor)
+    const cursor = prompt.cursor() ?? getCursorPosition(editor)
+    prompt.set([...prompt.current(), attachment], cursor)
     return true
   }
 
   const addAttachment = (file: File) => add(file)
 
-  const addAttachments = async (files: File[], toast = true, target = capture()) => {
+  const addAttachments = async (files: File[], toast = true) => {
     let found = false
 
     for (const file of files) {
-      const ok = await add(file, false, target)
+      const ok = await add(file, false)
       if (ok) found = true
     }
 
-    if (!found && files.length > 0 && toast) input.warn?.()
+    if (!found && files.length > 0 && toast) warn()
     return found
   }
 
-  const addClipboardAttachment = async (pending: Promise<File | null>, target = capture()) => {
-    const file = await pending
-    if (!file) return false
-    return add(file, true, target)
-  }
-
   const removeAttachment = (id: string) => {
-    const target = input.capture()
-    const current = target.current()
+    const current = prompt.current()
     const next = current.filter((part) => part.type !== "image" || part.id !== id)
-    target.set(next, target.cursor())
+    prompt.set(next, prompt.cursor())
   }
 
   const handlePaste = async (event: ClipboardEvent) => {
     const clipboardData = event.clipboardData
     if (!clipboardData) return
-    const target = capture()
-    if (!target) return
 
     event.preventDefault()
     event.stopPropagation()
@@ -123,7 +107,7 @@ export function createPromptAttachmentsCore(input: PromptAttachmentsCoreInput) {
     })
 
     if (files.length > 0) {
-      await addAttachments(files, true, target)
+      await addAttachments(files)
       return
     }
 
@@ -131,7 +115,11 @@ export function createPromptAttachmentsCore(input: PromptAttachmentsCoreInput) {
 
     // Desktop: Browser clipboard has no images and no text, try platform's native clipboard for images
     if (input.readClipboardImage && !plainText) {
-      if (await addClipboardAttachment(input.readClipboardImage(), target)) return
+      const file = await input.readClipboardImage()
+      if (file) {
+        await addAttachment(file)
+        return
+      }
     }
 
     if (!plainText) return
@@ -139,9 +127,9 @@ export function createPromptAttachmentsCore(input: PromptAttachmentsCoreInput) {
     const text = normalizePaste(plainText)
 
     const put = () => {
-      if (input.addPart?.({ type: "text", content: text, start: 0, end: 0 })) return true
-      input.focusEditor?.()
-      return input.addPart?.({ type: "text", content: text, start: 0, end: 0 }) ?? false
+      if (input.addPart({ type: "text", content: text, start: 0, end: 0 })) return true
+      input.focusEditor()
+      return input.addPart({ type: "text", content: text, start: 0, end: 0 })
     }
 
     if (pasteMode(text) === "manual") {
@@ -155,28 +143,6 @@ export function createPromptAttachmentsCore(input: PromptAttachmentsCoreInput) {
     put()
   }
 
-  return {
-    addAttachment,
-    addAttachments,
-    addClipboardAttachment,
-    removeAttachment,
-    handlePaste,
-  }
-}
-
-export function createPromptAttachments(input: PromptAttachmentsInput) {
-  const language = useLanguage()
-  const attachments = createPromptAttachmentsCore({
-    ...input,
-    capture: input.prompt.capture,
-    warn: () => {
-      showToast({
-        title: language.t("prompt.toast.pasteUnsupported.title"),
-        description: language.t("prompt.toast.pasteUnsupported.description"),
-      })
-    },
-  })
-
   const handleGlobalDragOver = (event: DragEvent) => {
     if (input.isDialogActive()) return
 
@@ -215,7 +181,7 @@ export function createPromptAttachments(input: PromptAttachmentsInput) {
     const dropped = event.dataTransfer?.files
     if (!dropped) return
 
-    await attachments.addAttachments(Array.from(dropped))
+    await addAttachments(Array.from(dropped))
   }
 
   onMount(() => {
@@ -224,5 +190,10 @@ export function createPromptAttachments(input: PromptAttachmentsInput) {
     makeEventListener(document, "drop", handleGlobalDrop)
   })
 
-  return attachments
+  return {
+    addAttachment,
+    addAttachments,
+    removeAttachment,
+    handlePaste,
+  }
 }

packages/app/src/components/prompt-input/submission-state.ts

@@ -1,31 +0,0 @@
-import { type ContextItem, type Prompt, type usePrompt } from "@/context/prompt"
-
-type PromptTarget = ReturnType<ReturnType<typeof usePrompt>["capture"]>
-
-export function createPromptSubmissionState(input: {
-  target: PromptTarget
-  prompt: Prompt
-  context: (ContextItem & { key: string })[]
-}) {
-  let target = input.target
-  let cleared: Prompt | undefined
-
-  return {
-    prompt: input.prompt,
-    context: input.context,
-    target: () => target,
-    clear() {
-      target.reset()
-      cleared = target.current()
-    },
-    retarget(next: PromptTarget) {
-      input.context.forEach(next.context.add)
-      target = next
-    },
-    current: (value: PromptTarget) => target === value,
-    restore() {
-      if (cleared !== undefined && target.current() !== cleared) return
-      return { target, prompt: input.prompt, context: input.context }
-    },
-  }
-}

packages/app/src/components/prompt-input/submit.test.ts

@@ -41,7 +41,6 @@ const prompt = {
     replaceComments: () => undefined,
     items: () => [],
   },
-  capture: () => prompt,
 }
 
 const clientFor = (directory: string) => {
@@ -186,10 +185,6 @@ beforeAll(async () => {
 
   mock.module("@/context/server-sync", () => ({
     useServerSync: () => () => ({
-      session: {
-        remember: () => undefined,
-        set: () => undefined,
-      },
       child: (directory: string) => {
         syncedDirectories.push(directory)
         storedSessions[directory] ??= []

packages/app/src/components/prompt-input/submit.ts

@@ -4,6 +4,7 @@ import { base64Encode } from "@opencode-ai/core/util/encode"
 import { Binary } from "@opencode-ai/core/util/binary"
 import { useNavigate, useParams, useSearchParams } from "@solidjs/router"
 import { batch, type Accessor } from "solid-js"
+import type { FileSelection } from "@/context/file"
 import { useServer } from "@/context/server"
 import { useTabs } from "@/context/tabs"
 import { useServerSync, type ServerSync } from "@/context/server-sync"
@@ -20,7 +21,6 @@ import { buildRequestParts } from "./build-request-parts"
 import { setCursorPosition } from "./editor-dom"
 import { formatServerError } from "@/utils/server-errors"
 import { ScopedKey } from "@/utils/server-scope"
-import { createPromptSubmissionState } from "./submission-state"
 
 type PendingPrompt = {
   abort: AbortController
@@ -56,14 +56,16 @@ const draftImages = (prompt: Prompt) => prompt.filter((part): part is ImageAttac
 export async function sendFollowupDraft(input: FollowupSendInput) {
   const text = draftText(input.draft.prompt)
   const images = draftImages(input.draft.prompt)
+  const [, setStore] = input.serverSync.child(input.draft.sessionDirectory)
+
   const setBusy = () => {
     if (!input.optimisticBusy) return
-    input.serverSync.session.set("session_status", input.draft.sessionID, { type: "busy" })
+    setStore("session_status", input.draft.sessionID, { type: "busy" })
   }
 
   const setIdle = () => {
     if (!input.optimisticBusy) return
-    input.serverSync.session.set("session_status", input.draft.sessionID, { type: "idle" })
+    setStore("session_status", input.draft.sessionID, { type: "idle" })
   }
 
   const wait = async () => {
@@ -194,6 +196,15 @@ type PromptSubmitInput = {
   onSubmit?: () => void
 }
 
+type CommentItem = {
+  path: string
+  selection?: FileSelection
+  comment?: string
+  commentID?: string
+  commentOrigin?: "review" | "file"
+  preview?: string
+}
+
 export function createPromptSubmit(input: PromptSubmitInput) {
   const navigate = useNavigate()
   const sdk = useSDK()
@@ -223,7 +234,9 @@ export function createPromptSubmit(input: PromptSubmitInput) {
     const sessionID = params.id
     if (!sessionID) return Promise.resolve()
 
-    serverSync().session.set("todo", sessionID, [])
+    serverSync().todo.set(sessionID, [])
+    const [, setStore] = serverSync().child(sdk().directory)
+    setStore("todo", sessionID, [])
 
     input.onAbort?.()
 
@@ -242,12 +255,9 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       .catch(() => {})
   }
 
-  const restoreCommentItems = (
-    target: ReturnType<ReturnType<typeof usePrompt>["capture"]>,
-    items: (ContextItem & { key: string })[],
-  ) => {
+  const restoreCommentItems = (items: CommentItem[]) => {
     for (const item of items) {
-      target.context.add({
+      prompt.context.add({
         type: "file",
         path: item.path,
         selection: item.selection,
@@ -259,14 +269,19 @@ export function createPromptSubmit(input: PromptSubmitInput) {
     }
   }
 
-  const clearContext = (target: ReturnType<ReturnType<typeof usePrompt>["capture"]>) => {
-    for (const item of target.context.items()) {
-      target.context.remove(item.key)
+  const removeCommentItems = (items: { key: string }[]) => {
+    for (const item of items) {
+      prompt.context.remove(item.key)
+    }
+  }
+
+  const clearContext = () => {
+    for (const item of prompt.context.items()) {
+      prompt.context.remove(item.key)
     }
   }
 
   const seed = (dir: string, info: Session) => {
-    serverSync().session.remember(info)
     const [, setStore] = serverSync().child(dir)
     setStore("session", (list: Session[]) => {
       const result = Binary.search(list, info.id, (item) => item.id)
@@ -283,14 +298,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
   const handleSubmit = async (event: Event) => {
     event.preventDefault()
 
-    const target = prompt.capture()
-    const submission = createPromptSubmissionState({
-      target,
-      prompt: target.current(),
-      context: target.context.items().slice(),
-    })
-    const currentPrompt = submission.prompt
-    const context = submission.context
+    const currentPrompt = prompt.current()
     const text = currentPrompt.map((part) => ("content" in part ? part.content : "")).join("")
     const images = input.imageAttachments().slice()
     const mode = input.mode()
@@ -382,7 +390,6 @@ export function createPromptSubmit(input: PromptSubmitInput) {
         const draftID = search.draftId
         if (draftID) tabs.promoteDraft(draftID, { server: server.key, sessionId: session.id })
         else navigate(`/${base64Encode(sessionDirectory)}/session/${session.id}`)
-        submission.retarget(prompt.capture({ dir: base64Encode(sessionDirectory), id: session.id }))
       }
     }
     if (!session) {
@@ -398,6 +405,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       providerID: currentModel.provider.id,
     }
     const agent = currentAgent.name
+    const context = prompt.context.items().slice()
     const draft: FollowupDraft = {
       sessionID: session.id,
       sessionDirectory,
@@ -409,16 +417,13 @@ export function createPromptSubmit(input: PromptSubmitInput) {
     }
 
     const clearInput = () => {
-      submission.clear()
+      prompt.reset()
       input.setMode("normal")
       input.setPopover(null)
     }
 
     const restoreInput = () => {
-      const restored = submission.restore()
-      if (!restored) return false
-      restored.target.set(restored.prompt, input.promptLength(restored.prompt))
-      if (!submission.current(prompt.capture())) return true
+      prompt.set(currentPrompt, input.promptLength(currentPrompt))
       input.setMode(mode)
       input.setPopover(null)
       requestAnimationFrame(() => {
@@ -428,12 +433,11 @@ export function createPromptSubmit(input: PromptSubmitInput) {
         setCursorPosition(editor, input.promptLength(currentPrompt))
         input.queueScroll()
       })
-      return true
     }
 
     if (!isNewSession && mode === "normal" && input.shouldQueue?.()) {
       input.onQueue?.(draft)
-      clearContext(submission.target())
+      clearContext()
       clearInput()
       return
     }
@@ -503,7 +507,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       })
     }
 
-    for (const item of commentItems) submission.target().context.remove(item.key)
+    removeCommentItems(commentItems)
     clearInput()
 
     const waitForWorktree = async () => {
@@ -520,7 +524,8 @@ export function createPromptSubmit(input: PromptSubmitInput) {
           sync().set("session_status", session.id, { type: "idle" })
         }
         removeOptimisticMessage()
-        if (restoreInput()) restoreCommentItems(submission.target(), commentItems)
+        restoreCommentItems(commentItems)
+        restoreInput()
       }
 
       pending.set(pendingKey(session.id), { abort: controller, cleanup })
@@ -582,7 +587,8 @@ export function createPromptSubmit(input: PromptSubmitInput) {
         description: errorMessage(err),
       })
       removeOptimisticMessage()
-      if (restoreInput()) restoreCommentItems(submission.target(), commentItems)
+      restoreCommentItems(commentItems)
+      restoreInput()
     })
   }
 

packages/app/src/components/prompt-input/transient-state.ts

@@ -1,43 +0,0 @@
-import { createComputed, on, type Accessor } from "solid-js"
-import { createStore, type SetStoreFunction } from "solid-js/store"
-import type { PromptHistoryEntry } from "./history"
-
-export type PromptInputTransientState = {
-  popover: "at" | "slash" | null
-  historyIndex: number
-  savedPrompt: PromptHistoryEntry | null
-  placeholder: number
-  draggingType: "image" | "@mention" | null
-  mode: "normal" | "shell"
-  applyingHistory: boolean
-  variantOpen: boolean
-}
-
-function resetPromptInputTransientState(setStore: SetStoreFunction<PromptInputTransientState>) {
-  setStore({
-    popover: null,
-    historyIndex: -1,
-    savedPrompt: null,
-    draggingType: null,
-    mode: "normal",
-    applyingHistory: false,
-    variantOpen: false,
-  })
-}
-
-export function createPromptInputTransientState(identity: Accessor<unknown>, placeholder: number) {
-  const [store, setStore] = createStore<PromptInputTransientState>({
-    popover: null,
-    historyIndex: -1,
-    savedPrompt: null,
-    placeholder,
-    draggingType: null,
-    mode: "normal",
-    applyingHistory: false,
-    variantOpen: false,
-  })
-
-  createComputed(on(identity, () => resetPromptInputTransientState(setStore), { defer: true }))
-
-  return [store, setStore] as const
-}

packages/app/src/components/session-context-usage.tsx

@@ -8,7 +8,6 @@ import { useLayout } from "@/context/layout"
 import { useSync } from "@/context/sync"
 import { useLanguage } from "@/context/language"
 import { useProviders } from "@/hooks/use-providers"
-import { useSDK } from "@/context/sdk"
 import { getSessionContextMetrics } from "@/components/session/session-context-metrics"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { createSessionTabs } from "@/pages/session/helpers"
@@ -34,8 +33,7 @@ export function SessionContextUsage(props: SessionContextUsageProps) {
   const file = useFile()
   const layout = useLayout()
   const language = useLanguage()
-  const sdk = useSDK()
-  const providers = useProviders(() => sdk().directory)
+  const providers = useProviders()
   const { params, tabs, view } = useSessionLayout()
 
   const variant = createMemo(() => props.variant ?? "button")

packages/app/src/components/session/session-context-tab.tsx

@@ -13,7 +13,6 @@ import { ScrollView } from "@opencode-ai/ui/scroll-view"
 import type { Message, Part, UserMessage } from "@opencode-ai/sdk/v2/client"
 import { useLanguage } from "@/context/language"
 import { useProviders } from "@/hooks/use-providers"
-import { useSDK } from "@/context/sdk"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { getSessionContextMetrics } from "./session-context-metrics"
 import { estimateSessionContextBreakdown, type SessionContextBreakdownKey } from "./session-context-breakdown"
@@ -94,8 +93,7 @@ const emptyUserMessages: UserMessage[] = []
 export function SessionContextTab() {
   const sync = useSync()
   const language = useLanguage()
-  const sdk = useSDK()
-  const providers = useProviders(() => sdk().directory)
+  const providers = useProviders()
   const { params, view } = useSessionLayout()
 
   const info = createMemo(() => (params.id ? sync().session.get(params.id) : undefined))

packages/app/src/components/settings-general.tsx

@@ -335,6 +335,18 @@ export const SettingsGeneral: Component = () => {
           </div>
         </SettingsRow>
 
+        <SettingsRow
+          title={language.t("settings.general.row.showSessionProgressBar.title")}
+          description={language.t("settings.general.row.showSessionProgressBar.description")}
+        >
+          <div data-action="settings-show-session-progress-bar">
+            <Switch
+              checked={settings.general.showSessionProgressBar()}
+              onChange={(checked) => settings.general.setShowSessionProgressBar(checked)}
+            />
+          </div>
+        </SettingsRow>
+
         <SettingsRow
           title={language.t("settings.general.row.newLayoutDesigns.title")}
           description={language.t("settings.general.row.newLayoutDesigns.description")}

packages/app/src/components/settings-v2/general.tsx

@@ -318,6 +318,18 @@ export const SettingsGeneralV2: Component = () => {
           </div>
         </SettingsRowV2>
 
+        <SettingsRowV2
+          title={language.t("settings.general.row.showSessionProgressBar.title")}
+          description={language.t("settings.general.row.showSessionProgressBar.description")}
+        >
+          <div data-action="settings-show-session-progress-bar">
+            <Switch
+              checked={settings.general.showSessionProgressBar()}
+              onChange={(checked) => settings.general.setShowSessionProgressBar(checked)}
+            />
+          </div>
+        </SettingsRowV2>
+
         <SettingsRowV2
           title={language.t("settings.general.row.newLayoutDesigns.title")}
           description={language.t("settings.general.row.newLayoutDesigns.description")}

packages/app/src/components/titlebar-tab-drag.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { captureTabDragLayout, insertIndexFromVirtualLayout } from "./titlebar-tab-drag"
-import {
-  canOpenTabRename,
-  captureTabPointerDown,
-  canStartTabDrag,
-  createTabDragPreview,
-  forwardTabRef,
-  isPrimaryPointerPressed,
-  isTabCloseTarget,
-} from "./titlebar-tab-gesture"
-
-describe("titlebar tab drag", () => {
-  const layout = {
-    listLeft: 100,
-    dividerWidth: 13,
-    tabWidthById: new Map([
-      ["a", 40],
-      ["b", 40],
-      ["c", 40],
-      ["d", 40],
-    ]),
-  }
-
-  test("moves across multiple tabs from one pointer update", () => {
-    expect(insertIndexFromVirtualLayout(260, ["a", "b", "c", "d"], "a", 0, layout)).toBe(3)
-    expect(insertIndexFromVirtualLayout(90, ["a", "b", "c", "d"], "d", 3, layout)).toBe(0)
-  })
-
-  test("keeps the current index inside the left hysteresis deadband", () => {
-    expect(insertIndexFromVirtualLayout(146, ["a", "b", "c", "d"], "b", 1, layout)).toBe(1)
-  })
-
-  test("includes slot margins in captured divider width", () => {
-    const list = document.createElement("div")
-    const first = document.createElement("div")
-    const second = document.createElement("div")
-    const firstTab = document.createElement("div")
-    const secondTab = document.createElement("div")
-    first.dataset.titlebarTabSlot = ""
-    first.dataset.tabKey = "a"
-    second.dataset.titlebarTabSlot = ""
-    second.dataset.tabKey = "b"
-    second.style.marginLeft = "6px"
-    firstTab.dataset.titlebarTab = ""
-    secondTab.dataset.titlebarTab = ""
-    first.append(firstTab)
-    second.append(secondTab)
-    list.append(first, second)
-    document.body.append(list)
-    firstTab.getBoundingClientRect = () => ({ width: 40 }) as DOMRect
-    secondTab.getBoundingClientRect = () => ({ width: 40 }) as DOMRect
-    second.getBoundingClientRect = () => ({ width: 47 }) as DOMRect
-    list.getBoundingClientRect = () => ({ left: 100 }) as DOMRect
-
-    expect(captureTabDragLayout(list, ["a", "b"]).dividerWidth).toBe(13)
-    list.remove()
-  })
-})
-
-describe("titlebar tab gestures", () => {
-  test("excludes close controls from tab gestures", () => {
-    const close = document.createElement("div")
-    const button = document.createElement("button")
-    const link = document.createElement("a")
-    close.dataset.slot = "tab-close"
-    close.append(button)
-    expect(isTabCloseTarget(close)).toBe(true)
-    expect(isTabCloseTarget(button)).toBe(true)
-    expect(isTabCloseTarget(link)).toBe(false)
-  })
-
-  test("forwards component refs", () => {
-    const element = document.createElement("div")
-    let received: HTMLDivElement | undefined
-    forwardTabRef((value) => (received = value), element)
-    expect(received).toBe(element)
-  })
-
-  test("does not reopen rename while a save is pending", () => {
-    expect(canOpenTabRename(false, false, false)).toBe(true)
-    expect(canOpenTabRename(false, false, true)).toBe(false)
-  })
-
-  test("keeps the rendered tab content in the drag preview", () => {
-    const tab = document.createElement("div")
-    tab.innerHTML = '<span data-slot="project-avatar-slot"></span><span data-slot="tab-title">Session</span>'
-    const preview = createTabDragPreview(tab)
-    expect(preview.querySelector('[data-slot="project-avatar-slot"]')).not.toBeNull()
-    expect(preview.querySelector('[data-slot="tab-title"]')?.textContent).toBe("Session")
-  })
-
-  test("captures the grab offset before navigation scrolls the tab", () => {
-    const tab = document.createElement("div")
-    tab.getBoundingClientRect = () => ({ left: 80, top: 10, width: 120 }) as DOMRect
-
-    expect(captureTabPointerDown(tab, 100, 20)).toEqual({
-      startX: 100,
-      startY: 20,
-      grabOffsetX: 20,
-      grabOffsetY: 10,
-      width: 120,
-      element: tab,
-    })
-  })
-
-  test("detects when the primary pointer button was released outside the window", () => {
-    expect(isPrimaryPointerPressed(1)).toBe(true)
-    expect(isPrimaryPointerPressed(3)).toBe(true)
-    expect(isPrimaryPointerPressed(0)).toBe(false)
-    expect(isPrimaryPointerPressed(2)).toBe(false)
-  })
-
-  test("preserves native panning for touch pointers", () => {
-    expect(canStartTabDrag("mouse")).toBe(true)
-    expect(canStartTabDrag("pen")).toBe(true)
-    expect(canStartTabDrag("touch")).toBe(false)
-  })
-})

packages/app/src/components/titlebar-tab-drag.ts

@@ -1,135 +0,0 @@
-export type TabDragLayout = {
-  tabWidthById: Map<string, number>
-  dividerWidth: number
-  listLeft: number
-}
-
-export const ACTIVATION_DISTANCE = 4
-export const HYSTERESIS_DEADBAND = 8
-export const AUTOSCROLL_EDGE = 24
-export const AUTOSCROLL_MAX_SPEED = 8
-export const FLOATER_OVERSHOOT_MAX = 8
-
-export function pointerDistance(x1: number, y1: number, x2: number, y2: number) {
-  const dx = x2 - x1
-  const dy = y2 - y1
-  return Math.sqrt(dx * dx + dy * dy)
-}
-
-export function captureTabDragLayout(list: HTMLElement, order: string[]) {
-  const tabWidthById = new Map<string, number>()
-  const slots = list.querySelectorAll<HTMLElement>("[data-titlebar-tab-slot]")
-  for (const slot of slots) {
-    const id = slot.dataset.tabKey
-    if (!id) continue
-    const tab = slot.querySelector<HTMLElement>("[data-titlebar-tab]")
-    if (!tab) continue
-    tabWidthById.set(id, tab.getBoundingClientRect().width)
-  }
-
-  let dividerWidth = 0
-  if (order.length >= 2) {
-    const secondId = order[1]
-    for (const slot of slots) {
-      if (slot.dataset.tabKey !== secondId) continue
-      const tab = slot.querySelector<HTMLElement>("[data-titlebar-tab]")
-      if (!tab) break
-      const style = getComputedStyle(slot)
-      dividerWidth =
-        slot.getBoundingClientRect().width -
-        tab.getBoundingClientRect().width +
-        (Number.parseFloat(style.marginLeft) || 0) +
-        (Number.parseFloat(style.marginRight) || 0)
-      break
-    }
-  }
-
-  return {
-    tabWidthById,
-    dividerWidth,
-    listLeft: list.getBoundingClientRect().left,
-  }
-}
-
-export function syncLayoutScroll(list: HTMLElement, layout: TabDragLayout) {
-  layout.listLeft = list.getBoundingClientRect().left
-}
-
-function slotWidthAt(order: readonly string[], index: number, layout: TabDragLayout) {
-  const id = order[index]
-  if (!id) return 0
-  const tabWidth = layout.tabWidthById.get(id) ?? 0
-  return index === 0 ? tabWidth : layout.dividerWidth + tabWidth
-}
-
-function slotLeft(order: readonly string[], index: number, layout: TabDragLayout) {
-  let left = layout.listLeft
-  for (let i = 0; i < index; i++) {
-    left += slotWidthAt(order, i, layout)
-  }
-  return left
-}
-
-export function insertIndexFromVirtualLayout(
-  pointerX: number,
-  order: readonly string[],
-  draggedId: string,
-  currentIndex: number,
-  layout: TabDragLayout,
-  deadband = HYSTERESIS_DEADBAND,
-) {
-  if (order.length === 0) return 0
-
-  const others = order.filter((id) => id !== draggedId)
-  let target = currentIndex
-
-  while (target > 0 && pointerX < slotLeft(others, target, layout) - deadband) target--
-  while (target < order.length - 1 && pointerX >= slotLeft(others, target + 1, layout)) target++
-
-  return target
-}
-
-export function movePlaceholder(order: readonly string[], draggedId: string, toIndex: number) {
-  const fromIndex = order.indexOf(draggedId)
-  if (fromIndex === -1 || fromIndex === toIndex) return [...order]
-  const next = [...order]
-  next.splice(toIndex, 0, ...next.splice(fromIndex, 1))
-  return next
-}
-
-export function draftOrderChanged(initial: readonly string[], final: readonly string[]) {
-  if (initial.length === 0 || final.length === 0 || initial.length !== final.length) return false
-  return final.some((key, index) => key !== initial[index])
-}
-
-function easeOvershoot(overshoot: number) {
-  return (FLOATER_OVERSHOOT_MAX * overshoot) / (overshoot + FLOATER_OVERSHOOT_MAX)
-}
-
-export function clampFloaterLeft(left: number, width: number, stripLeft: number, stripRight: number) {
-  const stripWidth = stripRight - stripLeft
-  if (width >= stripWidth) return stripLeft
-
-  const maxLeft = stripRight - width
-  if (left > maxLeft) return maxLeft + easeOvershoot(left - maxLeft)
-  if (left < stripLeft) return stripLeft - easeOvershoot(stripLeft - left)
-
-  return left
-}
-
-export function autoscrollSpeed(pointerX: number, containerLeft: number, containerRight: number) {
-  const leftEdge = containerLeft + AUTOSCROLL_EDGE
-  const rightEdge = containerRight - AUTOSCROLL_EDGE
-
-  if (pointerX < leftEdge) {
-    const depth = (leftEdge - pointerX) / AUTOSCROLL_EDGE
-    return -Math.ceil(AUTOSCROLL_MAX_SPEED * Math.min(depth, 1))
-  }
-
-  if (pointerX > rightEdge) {
-    const depth = (pointerX - rightEdge) / AUTOSCROLL_EDGE
-    return Math.ceil(AUTOSCROLL_MAX_SPEED * Math.min(depth, 1))
-  }
-
-  return 0
-}

packages/app/src/components/titlebar-tab-gesture.ts

@@ -1,37 +0,0 @@
-import type { Ref } from "solid-js"
-
-export function isTabCloseTarget(target: EventTarget | null) {
-  return target instanceof Element && !!target.closest('[data-slot="tab-close"]')
-}
-
-export function canStartTabDrag(pointerType: string) {
-  return pointerType !== "touch"
-}
-
-export function isPrimaryPointerPressed(buttons: number) {
-  return (buttons & 1) !== 0
-}
-
-export function captureTabPointerDown(element: HTMLDivElement, clientX: number, clientY: number) {
-  const rect = element.getBoundingClientRect()
-  return {
-    startX: clientX,
-    startY: clientY,
-    grabOffsetX: clientX - rect.left,
-    grabOffsetY: clientY - rect.top,
-    width: rect.width,
-    element,
-  }
-}
-
-export function forwardTabRef(ref: Ref<HTMLDivElement> | undefined, element: HTMLDivElement) {
-  if (typeof ref === "function") ref(element)
-}
-
-export function canOpenTabRename(dragging: boolean | undefined, editing: boolean, committing: boolean) {
-  return !dragging && !editing && !committing
-}
-
-export function createTabDragPreview(element: HTMLDivElement) {
-  return element.cloneNode(true) as HTMLDivElement
-}

packages/app/src/components/titlebar-tab-nav.css

@@ -1,69 +0,0 @@
-[data-titlebar-tab] [data-slot="tab-close"] {
-  position: absolute;
-  top: 0;
-  right: 0;
-  display: flex;
-  height: 28px;
-  width: 28px;
-  align-items: center;
-  justify-content: center;
-}
-
-[data-titlebar-tab] [data-slot="tab-close"]::before {
-  content: "";
-  position: absolute;
-  top: 0;
-  height: 28px;
-  width: 16px;
-  pointer-events: none;
-  background: linear-gradient(to right, transparent, var(--tab-bg));
-  display: none;
-}
-
-[data-titlebar-tab][data-title-overflow="true"]:not([data-editing="true"]) [data-slot="tab-close"]::before {
-  display: block;
-  right: 0;
-}
-
-[data-titlebar-tab][data-title-overflow="true"]:hover:not([data-editing="true"]) [data-slot="tab-close"]::before,
-[data-titlebar-tab][data-title-overflow="true"][data-active="true"]:not([data-editing="true"])
-  [data-slot="tab-close"]::before {
-  right: 100%;
-}
-
-[data-titlebar-tab] [data-slot="tab-link"] {
-  padding-right: 22px;
-}
-
-[data-titlebar-tab][data-title-overflow="true"]:not(:hover):not([data-active="true"]):not([data-editing="true"])
-  [data-slot="tab-link"] {
-  padding-right: 0;
-}
-
-[data-titlebar-tab][data-editing="true"] [data-slot="tab-link"] {
-  padding-right: 22px;
-}
-
-[data-titlebar-tab] [data-slot="tab-title"] {
-  min-width: 0;
-}
-
-[data-titlebar-tab][data-editing="true"] [data-slot="tab-title"] {
-  min-width: 0;
-  max-width: 100%;
-  flex: 1 1 auto;
-  overflow-x: auto;
-  overflow-y: hidden;
-  white-space: nowrap;
-  scrollbar-width: none;
-}
-
-[data-titlebar-tab][data-editing="true"] [data-slot="tab-title"]::-webkit-scrollbar {
-  display: none;
-}
-
-[data-titlebar-tab]:hover [data-slot="tab-close"],
-[data-titlebar-tab][data-active="true"] [data-slot="tab-close"],
-[data-titlebar-tab][data-editing="true"] [data-slot="tab-close"] {
-  background: var(--tab-bg);
-}

packages/app/src/components/titlebar-tab-nav.tsx

@@ -1,344 +0,0 @@
-import { createEffect, createMemo, createSignal, onCleanup, Show, type Ref } from "solid-js"
-import { makeEventListener } from "@solid-primitives/event-listener"
-import { createResizeObserver } from "@solid-primitives/resize-observer"
-import { IconButtonV2 } from "@opencode-ai/ui/v2/icon-button-v2"
-import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
-import { useGlobal } from "@/context/global"
-import { useLanguage } from "@/context/language"
-import { ServerConnection } from "@/context/server"
-import { projectForSession } from "@/pages/layout/helpers"
-import { SessionTabAvatar } from "@/pages/layout/session-tab-avatar"
-import { showToast } from "@/utils/toast"
-import type { Session } from "@opencode-ai/sdk/v2"
-import { canOpenTabRename, forwardTabRef } from "./titlebar-tab-gesture"
-import "./titlebar-tab-nav.css"
-
-export function TabNavItem(props: {
-  ref?: Ref<HTMLDivElement>
-  href: string
-  server: ServerConnection.Key
-  session: () => Session | undefined
-  onTitleChange?: (title: string) => void
-  onTitleChangeFailed?: (title: string) => void
-  onClose: () => void
-  onNavigate: () => void
-  active?: boolean
-  activeServer: boolean
-  forceTruncate?: boolean
-  suppressNavigation?: () => boolean
-  dragging?: boolean
-  pressed?: boolean
-  hidden?: boolean
-}) {
-  const language = useLanguage()
-  const [editing, setEditing] = createSignal(false)
-  const [titleOverflowing, setTitleOverflowing] = createSignal(false)
-  let tabRoot!: HTMLDivElement
-  let titleEl!: HTMLSpanElement
-  let committing = false
-  let measureFrame: number | undefined
-
-  const closeTab = (event: MouseEvent) => {
-    event.preventDefault()
-    event.stopPropagation()
-    props.onClose()
-  }
-  const global = useGlobal()
-  const serverCtx = createMemo(() => {
-    const conn = global.servers.list().find((item) => ServerConnection.key(item) === props.server)
-    if (conn) return global.ensureServerCtx(conn)
-  })
-  const project = createMemo(() => {
-    const session = props.session()
-    if (!session) return
-    return projectForSession(session, serverCtx()?.projects.list() ?? [])
-  })
-
-  const measureTitleOverflow = () => {
-    if (!titleEl || editing()) {
-      setTitleOverflowing(false)
-      return
-    }
-    setTitleOverflowing(titleEl.scrollWidth > titleEl.clientWidth)
-  }
-
-  const scheduleTitleOverflow = () => {
-    if (measureFrame !== undefined) return
-    measureFrame = requestAnimationFrame(() => {
-      measureFrame = undefined
-      measureTitleOverflow()
-    })
-  }
-
-  createEffect(() => {
-    props.session()?.title
-    props.forceTruncate
-    editing()
-    scheduleTitleOverflow()
-  })
-
-  createResizeObserver(() => tabRoot, scheduleTitleOverflow)
-  onCleanup(() => {
-    if (measureFrame !== undefined) cancelAnimationFrame(measureFrame)
-  })
-
-  const selectTitle = () => {
-    const range = document.createRange()
-    range.selectNodeContents(titleEl)
-    const selection = window.getSelection()
-    selection?.removeAllRanges()
-    selection?.addRange(range)
-  }
-
-  const rename = async (title: string) => {
-    const ctx = serverCtx()
-    const session = props.session()
-    if (!ctx || !session) return
-    const client = ctx.sdk.createClient({ directory: session.directory, throwOnError: true })
-    await client.session.update({ sessionID: session.id, title })
-  }
-
-  const closeRename = async (save: boolean) => {
-    if (committing || !editing()) return
-    committing = true
-
-    const original = props.session()?.title ?? ""
-    const next = (titleEl.textContent ?? "").trim()
-
-    titleEl.scrollLeft = 0
-    if (save && next && next !== original) props.onTitleChange?.(next)
-    setEditing(false)
-
-    if (!save || !next || next === original) {
-      committing = false
-      return
-    }
-
-    try {
-      await rename(next)
-    } catch (err) {
-      props.onTitleChangeFailed?.(original)
-      showToast({
-        title: language.t("common.requestFailed"),
-        description: err instanceof Error ? err.message : undefined,
-      })
-    }
-
-    committing = false
-  }
-
-  createEffect(() => {
-    if (editing()) return
-    if (!titleEl) return
-    const title = props.session()?.title
-    if (title === undefined) return
-    titleEl.textContent = title
-  })
-
-  const openRename = (event: MouseEvent) => {
-    event.preventDefault()
-    event.stopPropagation()
-    if (!canOpenTabRename(props.dragging, editing(), committing)) return
-    const session = props.session()
-    if (!session) return
-    titleEl.textContent = session.title
-    setEditing(true)
-
-    requestAnimationFrame(() => {
-      titleEl.focus()
-      selectTitle()
-    })
-  }
-
-  createEffect(() => {
-    if (!editing()) return
-
-    const cleanup = makeEventListener(
-      document,
-      "pointerdown",
-      (event) => {
-        const target = event.target
-        if (!(target instanceof Node)) return
-        if (tabRoot.contains(target)) return
-        void closeRename(true)
-      },
-      { capture: true },
-    )
-
-    onCleanup(cleanup)
-  })
-
-  return (
-    <div
-      ref={(el) => {
-        tabRoot = el
-        forwardTabRef(props.ref, el)
-      }}
-      data-titlebar-tab
-      data-title-overflow={titleOverflowing()}
-      data-editing={editing()}
-      class="group relative flex h-7 min-w-24 max-w-60 select-none flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[dragging='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[pressed='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[editing='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
-      classList={{ invisible: props.hidden }}
-      data-active={props.active}
-      data-dragging={props.dragging}
-      data-pressed={props.pressed}
-      onMouseDown={(event) => {
-        if (event.button !== 1) return
-        closeTab(event)
-      }}
-    >
-      <Show when={props.session()}>
-        {(session) => {
-          return (
-            <a
-              data-slot="tab-link"
-              href={props.href}
-              draggable={false}
-              onDragStart={(event) => {
-                event.preventDefault()
-                event.stopPropagation()
-              }}
-              onClick={(event) => {
-                event.preventDefault()
-                if (editing()) return
-                if (props.suppressNavigation?.()) return
-                props.onNavigate()
-              }}
-              class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 text-[13px] font-medium text-v2-text-text-faint group-data-[active='true']:text-v2-text-text-base group-data-[editing='true']:text-v2-text-text-base [-webkit-user-drag:none]"
-            >
-              <span data-slot="project-avatar-slot">
-                <SessionTabAvatar
-                  project={project()}
-                  directory={session().directory}
-                  sessionId={session().id}
-                  activeServer={props.activeServer}
-                />
-              </span>
-              <span
-                ref={(el) => {
-                  titleEl = el
-                  titleEl.textContent = session().title
-                }}
-                data-slot="tab-title"
-                class="min-w-0 flex-1 outline-none leading-4"
-                classList={{
-                  "overflow-hidden text-clip whitespace-nowrap": !editing(),
-                  "select-text": editing(),
-                }}
-                contenteditable={editing() ? true : undefined}
-                onDblClick={openRename}
-                onKeyDown={(event) => {
-                  event.stopPropagation()
-                  if (event.key === "Enter") {
-                    event.preventDefault()
-                    void closeRename(true)
-                    return
-                  }
-                  if (event.key !== "Escape") return
-                  event.preventDefault()
-                  titleEl.textContent = session().title
-                  void closeRename(false)
-                }}
-                onBlur={() => void closeRename(true)}
-                onPointerDown={(event) => {
-                  if (!editing()) return
-                  event.stopPropagation()
-                }}
-                onClick={(event) => {
-                  if (!editing()) return
-                  event.preventDefault()
-                }}
-              />
-            </a>
-          )
-        }}
-      </Show>
-
-      <div data-slot="tab-close">
-        <IconButtonV2
-          size="small"
-          variant="ghost-muted"
-          class="relative z-10 opacity-0 group-hover:opacity-100 group-data-[active=true]:opacity-100 group-data-[editing=true]:opacity-100"
-          onPointerDown={(event) => {
-            event.preventDefault()
-            event.stopPropagation()
-          }}
-          onClick={closeTab}
-          icon={<IconV2 name="xmark-small" />}
-        />
-      </div>
-    </div>
-  )
-}
-
-export function DraftTabItem(props: {
-  ref?: Ref<HTMLDivElement>
-  href: string
-  title: string
-  active?: boolean
-  onNavigate: () => void
-  onClose: () => void
-  suppressNavigation?: () => boolean
-  dragging?: boolean
-  pressed?: boolean
-  hidden?: boolean
-}) {
-  const closeTab = (event: MouseEvent) => {
-    event.preventDefault()
-    event.stopPropagation()
-    props.onClose()
-  }
-  return (
-    <div
-      ref={(el) => forwardTabRef(props.ref, el)}
-      data-titlebar-tab
-      data-active={props.active}
-      data-dragging={props.dragging}
-      data-pressed={props.pressed}
-      class="group relative shrink-0 flex h-7 max-w-60 flex-row items-center gap-1.5 overflow-hidden rounded-[6px] bg-[var(--tab-bg)] pl-1.5 pr-8 whitespace-nowrap [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-overlay-simple-overlay-pressed)] data-[dragging='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[pressed='true']:[--tab-bg:var(--v2-background-bg-layer-02)] focus-within:outline focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-[var(--v2-border-border-focus)]"
-      classList={{ invisible: props.hidden }}
-      onMouseDown={(event) => {
-        if (event.button !== 1) return
-        closeTab(event)
-      }}
-    >
-      <a
-        data-slot="tab-link"
-        href={props.href}
-        draggable={false}
-        onDragStart={(event) => {
-          event.preventDefault()
-          event.stopPropagation()
-        }}
-        onClick={(event) => {
-          event.preventDefault()
-          if (props.suppressNavigation?.()) return
-          props.onNavigate()
-        }}
-        class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 overflow-hidden text-[13px] font-medium leading-5 text-v2-text-text-faint group-data-[active='true']:text-[var(--v2-text-text-base)]"
-      >
-        <span class="flex size-4 shrink-0 rotate-90 items-center justify-center">
-          <IconV2 name="edit" />
-        </span>
-        <span class="truncate leading-5">{props.title}</span>
-      </a>
-      <div data-slot="tab-close" class="absolute right-0 inset-y-0 flex w-7 items-center justify-center">
-        <IconButtonV2
-          size="small"
-          variant="ghost-muted"
-          onPointerDown={(event) => {
-            event.preventDefault()
-            event.stopPropagation()
-          }}
-          onMouseDown={(event) => {
-            event.preventDefault()
-            event.stopPropagation()
-          }}
-          onClick={closeTab}
-          icon={<IconV2 name="xmark-small" />}
-          aria-label="Close tab"
-        />
-      </div>
-    </div>
-  )
-}

packages/app/src/components/titlebar-tab-strip.tsx

@@ -1,581 +0,0 @@
-import {
-  createEffect,
-  createMemo,
-  createResource,
-  createRoot,
-  createSignal,
-  For,
-  onCleanup,
-  onMount,
-  Show,
-} from "solid-js"
-import { Portal } from "solid-js/web"
-import { createStore } from "solid-js/store"
-import { makeEventListener } from "@solid-primitives/event-listener"
-import { createResizeObserver } from "@solid-primitives/resize-observer"
-import { tabHref, tabKey, type SessionTab, type Tab } from "@/context/tabs"
-import { ServerConnection } from "@/context/server"
-import { DraftTabItem, TabNavItem } from "@/components/titlebar-tab-nav"
-import { useGlobal, type ServerCtx } from "@/context/global"
-import { useLanguage } from "@/context/language"
-import { useCommand } from "@/context/command"
-import { useTabs } from "@/context/tabs"
-import { createTabPromptState } from "@/context/prompt"
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import {
-  captureTabPointerDown,
-  canStartTabDrag,
-  createTabDragPreview,
-  isPrimaryPointerPressed,
-  isTabCloseTarget,
-} from "./titlebar-tab-gesture"
-import {
-  ACTIVATION_DISTANCE,
-  autoscrollSpeed,
-  captureTabDragLayout,
-  clampFloaterLeft,
-  draftOrderChanged,
-  insertIndexFromVirtualLayout,
-  movePlaceholder,
-  pointerDistance,
-  syncLayoutScroll,
-  type TabDragLayout,
-} from "@/components/titlebar-tab-drag"
-
-function SessionTabSlot(props: {
-  tab: SessionTab
-  id: string
-  first: () => boolean
-  active: () => boolean
-  activeServerKey: ServerConnection.Key
-  forceTruncate: boolean
-  dragActive: boolean
-  dragged: () => boolean
-  pressed: () => boolean
-  serverCtx: () => ServerCtx | undefined
-  suppressNavigation: () => boolean
-  onPointerDown: (event: PointerEvent) => void
-  onNavigate: (element: HTMLDivElement) => void
-  onClose: () => void
-}) {
-  const tabs = useTabs()
-  let ref!: HTMLDivElement
-  const sdk = createMemo(() => props.serverCtx()?.sdk ?? null)
-  const cachedSession = createMemo(() => props.serverCtx()?.sync.session.peek(props.tab.sessionId))
-  const [loadedSession] = createResource(
-    () => {
-      const ctx = props.serverCtx()
-      return ctx ? { id: props.tab.sessionId, ctx } : null
-    },
-    ({ id, ctx }) => ctx.sync.session.resolve(id).catch(() => undefined),
-  )
-  const session = createMemo(() => cachedSession() ?? loadedSession())
-  let prefetched = false
-
-  createEffect(() => {
-    const ctx = props.serverCtx()
-    const value = session()
-    if (!ctx || !value || prefetched) return
-    prefetched = true
-    createRoot((dispose) => {
-      try {
-        void ctx.sync
-          .ensureDirSyncContext(value.directory)
-          .session.sync(value.id)
-          .catch(() => {})
-          .finally(dispose)
-      } catch {
-        dispose()
-      }
-    })
-  })
-
-  createEffect(() => {
-    const value = session()
-    const current = sdk()
-    if (!value || !current) return
-    createTabPromptState(tabs, props.tab, current.scope, {
-      dir: base64Encode(value.directory),
-      id: value.id,
-    })
-  })
-
-  return (
-    <div
-      data-titlebar-tab-slot
-      data-tab-key={props.id}
-      class="flex shrink-0"
-      classList={{
-        hidden: !session(),
-        "ml-1.5 border-l border-[var(--v2-background-bg-layer-02)] pl-1.5": !props.first(),
-        "pointer-events-none": props.dragActive,
-      }}
-      onPointerDown={props.onPointerDown}
-    >
-      <TabNavItem
-        ref={ref}
-        href={tabHref(props.tab)}
-        server={props.tab.server}
-        session={session}
-        onTitleChange={(title) => {
-          const value = session()
-          const ctx = props.serverCtx()
-          if (value && ctx) ctx.sync.session.remember({ ...value, title })
-        }}
-        onTitleChangeFailed={(title) => {
-          const value = session()
-          const ctx = props.serverCtx()
-          if (value && ctx) ctx.sync.session.remember({ ...value, title })
-        }}
-        onNavigate={() => props.onNavigate(ref)}
-        onClose={props.onClose}
-        active={props.active()}
-        activeServer={props.tab.server === props.activeServerKey}
-        forceTruncate={props.forceTruncate}
-        suppressNavigation={props.suppressNavigation}
-        pressed={props.pressed()}
-        hidden={props.dragged()}
-      />
-    </div>
-  )
-}
-
-export function TitlebarTabStrip(props: {
-  tabs: Tab[]
-  currentTab: () => Tab | undefined
-  activeServerKey: ServerConnection.Key
-  forceTruncate: boolean
-  onNavigate: (tab: Tab, el?: HTMLDivElement) => void
-  onClose: (tab: Tab) => void
-  onReorder: (keys: string[]) => void
-  onOverflowChange: (overflowing: boolean) => void
-}) {
-  const global = useGlobal()
-  const language = useLanguage()
-  const [drag, setDrag] = createStore({
-    active: false,
-    draggedId: undefined as string | undefined,
-    placeholderIndex: 0,
-    draftOrder: [] as string[],
-    initialOrder: [] as string[],
-    draggedWidth: 0,
-    pointerX: 0,
-    grabOffsetX: 0,
-    floaterTop: 0,
-  })
-
-  const [gesture, setGesture] = createStore({
-    pending: undefined as
-      | {
-          id: string
-          startX: number
-          startY: number
-          grabOffsetX: number
-          grabOffsetY: number
-          pointerId: number
-          width: number
-          element: HTMLDivElement
-        }
-      | undefined,
-  })
-
-  const [suppressNavigation, setSuppressNavigation] = createSignal(false)
-  const [pressedId, setPressedId] = createSignal<string | undefined>()
-  const [stripScrollLeft, setStripScrollLeft] = createSignal(0)
-  let scrollRef!: HTMLDivElement
-  let listRef!: HTMLDivElement
-  let dragLayout: TabDragLayout | undefined
-  let dragPointerId: number | undefined
-  let autoscrollFrame: number | undefined
-  let resizeFrame: number | undefined
-  let dragPreview: HTMLDivElement | undefined
-
-  const tabIds = () => props.tabs.map(tabKey)
-
-  const displayTabs = createMemo(() => {
-    if (!drag.active || drag.draftOrder.length === 0) return props.tabs
-    const byKey = new Map(props.tabs.map((tab) => [tabKey(tab), tab]))
-    return drag.draftOrder.map((key) => byKey.get(key)).filter((tab): tab is Tab => !!tab)
-  })
-
-  function refreshOverflow() {
-    if (!scrollRef) return
-    props.onOverflowChange(scrollRef.scrollWidth > scrollRef.clientWidth)
-  }
-
-  createResizeObserver(
-    () => [scrollRef, listRef],
-    () => {
-      if (resizeFrame !== undefined) return
-      resizeFrame = requestAnimationFrame(() => {
-        resizeFrame = undefined
-        refreshOverflow()
-        if (!drag.active || !listRef) return
-        dragLayout = captureTabDragLayout(listRef, drag.draftOrder)
-        updateInsertIndex()
-      })
-    },
-  )
-
-  function syncScroll() {
-    if (!scrollRef || !listRef || !dragLayout) return
-    syncLayoutScroll(listRef, dragLayout)
-    setStripScrollLeft(scrollRef.scrollLeft)
-    updateInsertIndex()
-  }
-
-  function stopAutoscroll() {
-    if (autoscrollFrame === undefined) return
-    cancelAnimationFrame(autoscrollFrame)
-    autoscrollFrame = undefined
-  }
-
-  function tickAutoscroll() {
-    if (!drag.active || !scrollRef) return
-
-    const strip = scrollRef.getBoundingClientRect()
-    const speed = autoscrollSpeed(drag.pointerX, strip.left, strip.right)
-
-    if (speed !== 0) {
-      scrollRef.scrollLeft += speed
-      syncScroll()
-    }
-
-    autoscrollFrame = requestAnimationFrame(tickAutoscroll)
-  }
-
-  function startAutoscroll() {
-    stopAutoscroll()
-    autoscrollFrame = requestAnimationFrame(tickAutoscroll)
-  }
-
-  function applyPlaceholderIndex(nextIndex: number) {
-    const id = drag.draggedId
-    if (!id) return
-    const next = movePlaceholder(drag.draftOrder, id, nextIndex)
-    setDrag({
-      draftOrder: next,
-      placeholderIndex: nextIndex,
-    })
-  }
-
-  function updateInsertIndex() {
-    if (!drag.active || !dragLayout) return
-    const draggedId = drag.draggedId
-    if (!draggedId) return
-    const nextIndex = insertIndexFromVirtualLayout(
-      drag.pointerX,
-      drag.draftOrder,
-      draggedId,
-      drag.placeholderIndex,
-      dragLayout,
-    )
-    if (nextIndex === drag.placeholderIndex) return
-    applyPlaceholderIndex(nextIndex)
-  }
-
-  function startDrag(id: string) {
-    const order = tabIds()
-    const index = order.indexOf(id)
-    const pending = gesture.pending
-    if (index === -1 || !pending || !listRef || !scrollRef) return
-
-    dragLayout = captureTabDragLayout(listRef, order)
-    dragPreview = createTabDragPreview(pending.element)
-    dragPointerId = pending.pointerId
-    setGesture("pending", undefined)
-
-    setDrag({
-      active: true,
-      draggedId: id,
-      placeholderIndex: index,
-      draftOrder: order,
-      initialOrder: order,
-      draggedWidth: pending.width,
-      pointerX: pending.startX,
-      grabOffsetX: pending.grabOffsetX,
-      floaterTop: pending.startY - pending.grabOffsetY,
-    })
-    setPressedId(undefined)
-    setStripScrollLeft(scrollRef.scrollLeft)
-    startAutoscroll()
-  }
-
-  function endDrag(commit: boolean) {
-    const initial = drag.initialOrder
-    const final = drag.draftOrder
-    const moved = drag.active
-
-    if (commit && moved && draftOrderChanged(initial, final)) {
-      props.onReorder(final)
-    }
-
-    if (moved) setSuppressNavigation(true)
-
-    setDrag({
-      active: false,
-      draggedId: undefined,
-      placeholderIndex: 0,
-      draftOrder: [],
-      initialOrder: [],
-      draggedWidth: 0,
-      pointerX: 0,
-      grabOffsetX: 0,
-      floaterTop: 0,
-    })
-
-    dragLayout = undefined
-    dragPreview = undefined
-    dragPointerId = undefined
-    setGesture("pending", undefined)
-    setPressedId(undefined)
-    stopAutoscroll()
-    refreshOverflow()
-    requestAnimationFrame(() => setSuppressNavigation(false))
-  }
-
-  function onPointerDown(id: string, event: PointerEvent) {
-    if (event.button !== 0 || drag.active) return
-    if (!canStartTabDrag(event.pointerType)) return
-    if (isTabCloseTarget(event.target)) return
-    const tabEl = (event.currentTarget as HTMLElement).querySelector<HTMLDivElement>("[data-titlebar-tab]")
-    if (!tabEl) return
-    if (!tabEl.querySelector('[data-slot="tab-link"]')) return
-    const tab = props.tabs.find((item) => tabKey(item) === id)
-    if (!tab) return
-    const pointer = captureTabPointerDown(tabEl, event.clientX, event.clientY)
-    setSuppressNavigation(true)
-    props.onNavigate(tab, tabEl)
-    setPressedId(id)
-    setGesture("pending", {
-      id,
-      pointerId: event.pointerId,
-      ...pointer,
-    })
-  }
-
-  function onPointerMove(event: PointerEvent) {
-    const pending = gesture.pending
-    if (pending && event.pointerId !== pending.pointerId) return
-    if (drag.active && dragPointerId !== undefined && event.pointerId !== dragPointerId) return
-    if (!isPrimaryPointerPressed(event.buttons)) {
-      if (drag.active) endDrag(true)
-      if (pending) {
-        setGesture("pending", undefined)
-        setPressedId(undefined)
-        requestAnimationFrame(() => setSuppressNavigation(false))
-      }
-      return
-    }
-
-    if (pending && !drag.active) {
-      if (pointerDistance(pending.startX, pending.startY, event.clientX, event.clientY) < ACTIVATION_DISTANCE) return
-      startDrag(pending.id)
-    }
-
-    if (!drag.active) return
-
-    setDrag("pointerX", event.clientX)
-    syncScroll()
-  }
-
-  function onPointerUp(event: PointerEvent) {
-    if (drag.active) {
-      if (dragPointerId !== undefined && event.pointerId !== dragPointerId) return
-      setDrag("pointerX", event.clientX)
-      syncScroll()
-      endDrag(true)
-      return
-    }
-
-    const pending = gesture.pending
-    if (pending && event.pointerId !== pending.pointerId) return
-
-    setGesture("pending", undefined)
-    setPressedId(undefined)
-    requestAnimationFrame(() => setSuppressNavigation(false))
-  }
-
-  function onPointerCancel(event: PointerEvent) {
-    if (drag.active) {
-      if (dragPointerId !== undefined && event.pointerId !== dragPointerId) return
-      endDrag(false)
-      return
-    }
-
-    if (!gesture.pending) return
-    if (gesture.pending.pointerId !== event.pointerId) return
-    setGesture("pending", undefined)
-    setPressedId(undefined)
-    requestAnimationFrame(() => setSuppressNavigation(false))
-  }
-
-  onMount(() => {
-    const cleanups = [
-      makeEventListener(window, "pointermove", onPointerMove),
-      makeEventListener(window, "pointerup", onPointerUp),
-      makeEventListener(window, "pointercancel", onPointerCancel),
-    ]
-    refreshOverflow()
-    onCleanup(() => cleanups.forEach((cleanup) => cleanup()))
-  })
-
-  onCleanup(stopAutoscroll)
-  onCleanup(() => {
-    if (resizeFrame !== undefined) cancelAnimationFrame(resizeFrame)
-  })
-
-  createEffect(() => {
-    props.tabs.length
-    tabIds()
-    refreshOverflow()
-  })
-
-  createEffect(() => {
-    if (!drag.active || !scrollRef) return
-    onCleanup(makeEventListener(scrollRef, "scroll", syncScroll))
-  })
-
-  const floaterStyle = () => {
-    stripScrollLeft()
-    const strip = scrollRef?.getBoundingClientRect()
-    const left = strip
-      ? clampFloaterLeft(drag.pointerX - drag.grabOffsetX, drag.draggedWidth, strip.left, strip.right)
-      : drag.pointerX - drag.grabOffsetX
-
-    return {
-      position: "fixed" as const,
-      top: `${drag.floaterTop}px`,
-      left: `${left}px`,
-      width: `${drag.draggedWidth}px`,
-      "z-index": "10000",
-      "pointer-events": "none" as const,
-    }
-  }
-
-  const draggedTab = createMemo(() => {
-    const id = drag.draggedId
-    if (!id) return
-    return props.tabs.find((tab) => tabKey(tab) === id)
-  })
-
-  return (
-    <>
-      <div data-slot="titlebar-tabs" class="relative min-w-0">
-        <div
-          data-slot="titlebar-tabs-scroll"
-          class="flex min-w-0 flex-row items-center gap-1.5 overflow-x-auto no-scrollbar [app-region:no-drag]"
-          ref={scrollRef}
-        >
-          <div class="flex min-w-0 flex-row items-center" ref={listRef}>
-            <For each={displayTabs()}>
-              {(tab, index) => {
-                const id = tabKey(tab)
-                const first = () => index() === 0
-                let ref!: HTMLDivElement
-                useTabShortcut(index, () => props.onNavigate(tab, ref))
-
-                const dragged = () => drag.active && drag.draggedId === id
-                const serverCtx = createMemo(() => {
-                  if (tab.type !== "session") return
-                  const conn = global.servers.list().find((item) => ServerConnection.key(item) === tab.server)
-                  if (conn) return global.ensureServerCtx(conn)
-                })
-
-                if (tab.type === "session") {
-                  return (
-                    <SessionTabSlot
-                      tab={tab}
-                      id={id}
-                      first={first}
-                      active={() => props.currentTab() === tab}
-                      activeServerKey={props.activeServerKey}
-                      forceTruncate={props.forceTruncate}
-                      dragActive={drag.active}
-                      dragged={dragged}
-                      pressed={() => pressedId() === id}
-                      serverCtx={serverCtx}
-                      suppressNavigation={() => suppressNavigation()}
-                      onPointerDown={(event) => {
-                        if (dragged()) return
-                        onPointerDown(id, event)
-                      }}
-                      onNavigate={(element) => props.onNavigate(tab, element)}
-                      onClose={() => props.onClose(tab)}
-                    />
-                  )
-                }
-
-                return (
-                  <div
-                    data-titlebar-tab-slot
-                    data-tab-key={id}
-                    class="flex shrink-0"
-                    classList={{
-                      "ml-1.5 border-l border-[var(--v2-background-bg-layer-02)] pl-1.5": !first(),
-                      "pointer-events-none": drag.active,
-                    }}
-                    onPointerDown={(event) => {
-                      if (dragged()) return
-                      onPointerDown(id, event)
-                    }}
-                  >
-                    <DraftTabItem
-                      ref={ref}
-                      href={tabHref(tab)}
-                      title={language.t("command.session.new")}
-                      onNavigate={() => props.onNavigate(tab, ref)}
-                      onClose={() => props.onClose(tab)}
-                      suppressNavigation={() => suppressNavigation()}
-                      active={props.currentTab() === tab}
-                      pressed={pressedId() === id}
-                      hidden={dragged()}
-                    />
-                  </div>
-                )
-              }}
-            </For>
-          </div>
-        </div>
-        <div
-          data-slot="titlebar-tabs-fade-left"
-          aria-hidden="true"
-          class="pointer-events-none absolute inset-y-0 left-0 z-10 w-6 bg-[linear-gradient(to_right,var(--v2-background-bg-deep),transparent)]"
-        />
-        <div
-          data-slot="titlebar-tabs-fade-right"
-          aria-hidden="true"
-          class="pointer-events-none absolute inset-y-0 right-0 z-10 w-6 bg-[linear-gradient(to_left,var(--v2-background-bg-deep),transparent)]"
-        />
-      </div>
-      <Show when={drag.active && draggedTab() && dragPreview}>
-        {(_) => (
-          <Portal>
-            <div data-titlebar-tab-preview style={floaterStyle()}>
-              {dragPreview}
-            </div>
-          </Portal>
-        )}
-      </Show>
-    </>
-  )
-}
-
-function useTabShortcut(index: () => number, onSelect: () => void) {
-  const command = useCommand()
-
-  command.register(() => {
-    const number = index() + 1
-    if (number > 9) return []
-    return [
-      {
-        id: `tab.${number}`,
-        category: "tab",
-        title: "",
-        keybind: `mod+${number}`,
-        hidden: true,
-        onSelect,
-      },
-    ]
-  })
-}

packages/app/src/components/titlebar.tsx

@@ -1,4 +1,16 @@
-import { createEffect, createMemo, createResource, createSignal, Match, Show, Switch, untrack } from "solid-js"
+import {
+  createEffect,
+  createMemo,
+  createResource,
+  createRoot,
+  createSignal,
+  For,
+  Match,
+  onMount,
+  Show,
+  Switch,
+  untrack,
+} from "solid-js"
 import { createStore } from "solid-js/store"
 import { useLocation, useNavigate, useParams } from "@solidjs/router"
 import { IconButton } from "@opencode-ai/ui/icon-button"
@@ -18,14 +30,19 @@ import { useLanguage } from "@/context/language"
 import { useSettings } from "@/context/settings"
 import { WindowsAppMenu } from "./windows-app-menu"
 import { applyPath, backPath, forwardPath } from "./titlebar-history"
-import { TitlebarTabStrip } from "@/components/titlebar-tab-strip"
+import { projectForSession } from "@/pages/layout/helpers"
+import { SessionTabAvatar } from "@/pages/layout/session-tab-avatar"
 import { makeEventListener } from "@solid-primitives/event-listener"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { createMediaQuery } from "@solid-primitives/media"
 import { readSessionTabsRemovedDetail, SESSION_TABS_REMOVED_EVENT } from "@/components/titlebar-session-events"
 import { useGlobal } from "@/context/global"
 import { ServerConnection, useServer } from "@/context/server"
-import { tabKey, useTabs } from "@/context/tabs"
+import { tabHref, useTabs } from "@/context/tabs"
 import "./titlebar.css"
+import { Session } from "@opencode-ai/sdk/v2"
+import { base64Encode } from "@opencode-ai/core/util/encode"
+import { createTabPromptState } from "@/context/prompt"
 
 type TauriDesktopWindow = {
   startDragging?: () => Promise<void>
@@ -239,6 +256,7 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
       <Switch>
         <Match when={useV2Titlebar()}>
           {(_) => {
+            const navigate = useNavigate()
             const layout = useLayout()
             const global = useGlobal()
 
@@ -404,6 +422,11 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
             })
 
             const [tabsAreOverflowing, setTabsAreOverflowing] = createSignal(false)
+            let tabScrollRef!: HTMLDivElement
+
+            function refreshTabsAreOverflowing() {
+              setTabsAreOverflowing(tabScrollRef.scrollWidth > tabScrollRef.clientWidth)
+            }
 
             return (
               <div
@@ -442,22 +465,184 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                   />
                 </TooltipV2>
 
-                <TitlebarTabStrip
-                  tabs={tabsStore}
-                  currentTab={currentTab}
-                  activeServerKey={server.key}
-                  forceTruncate={tabsAreOverflowing()}
-                  onOverflowChange={setTabsAreOverflowing}
-                  onNavigate={(tab, el) => {
-                    tabs.select(tab)
-                    el?.scrollIntoView({ behavior: "instant" })
-                  }}
-                  onClose={(tab) => {
-                    const index = tabsStore.findIndex((item) => tabKey(item) === tabKey(tab))
-                    if (index !== -1) tabsStoreActions.removeTab(index)
-                  }}
-                  onReorder={(keys) => tabsStoreActions.reorder(keys)}
-                />
+                <div data-slot="titlebar-tabs" class="relative min-w-0">
+                  <div
+                    data-slot="titlebar-tabs-scroll"
+                    class="flex min-w-0 flex-row items-center gap-1.5 overflow-x-auto no-scrollbar [app-region:no-drag]"
+                    ref={(el) => {
+                      tabScrollRef = el
+                      createResizeObserver(el, refreshTabsAreOverflowing)
+                    }}
+                  >
+                    <div
+                      class="flex min-w-0 flex-row items-center gap-1.5"
+                      ref={(el) => createResizeObserver(el, refreshTabsAreOverflowing)}
+                    >
+                      <For each={tabsStore}>
+                        {(tab, i) => {
+                          let ref!: HTMLDivElement
+                          useTabShortcut(i, () => tabs.select(tab))
+
+                          const divider = () =>
+                            i() !== 0 && (
+                              <div class="w-[1.5px] h-3 shrink-0 rounded-full bg-[var(--v2-background-bg-layer-02)]" />
+                            )
+
+                          if (tab.type === "draft") {
+                            return (
+                              <>
+                                {divider()}
+                                <DraftTabItem
+                                  ref={ref}
+                                  href={tabHref(tab)}
+                                  title={language.t("command.session.new")}
+                                  active={currentTab() === tab}
+                                  onNavigate={() => {
+                                    tabs.select(tab)
+                                    ref.scrollIntoView({ behavior: "instant" })
+                                  }}
+                                  onClose={() => tabsStoreActions.removeTab(i())}
+                                />
+                              </>
+                            )
+                          }
+
+                          const serverCtx = createMemo(() => {
+                            const conn = server.list.find((item) => ServerConnection.key(item) === tab.server)
+                            return conn ? global.ensureServerCtx(conn) : undefined
+                          })
+                          const sdk = createMemo(() => serverCtx()?.sdk ?? null)
+                          const cachedSession = createMemo(() => {
+                            const placement = global.sessionPlacement.get(tab.server, tab.sessionId)
+                            const ctx = serverCtx()
+                            if (!placement || !ctx) return
+                            return ctx.sync
+                              .child(placement.directory, { bootstrap: false })[0]
+                              .session.find((session) => session.id === tab.sessionId)
+                          })
+
+                          const [loadedSession] = createResource(
+                            () => {
+                              if (cachedSession()) return null
+                              const id = tab.sessionId
+                              const ctx = serverCtx()
+                              return ctx ? { id, ctx } : null
+                            },
+                            ({ id, ctx }) =>
+                              ctx.sdk.client.session
+                                .get({ sessionID: id })
+                                .then((x) => {
+                                  const session = x.data
+                                  if (!session) return
+                                  if (!session.parentID)
+                                    global.sessionPlacement.set({
+                                      server: tab.server,
+                                      leafID: session.id,
+                                      rootID: session.id,
+                                      directory: session.directory,
+                                    })
+                                  return session
+                                })
+                                .catch(() => undefined),
+                          )
+                          const session = createMemo(() => cachedSession() ?? loadedSession())
+                          let prefetched = false
+
+                          createEffect(() => {
+                            const ctx = serverCtx()
+                            const sess = session()
+                            if (!ctx || !sess || prefetched) return
+                            prefetched = true
+                            createRoot((dispose) => {
+                              try {
+                                void ctx.sync
+                                  .ensureDirSyncContext(sess.directory)
+                                  .session.sync(sess.id)
+                                  .catch(() => {})
+                                  .finally(dispose)
+                              } catch {
+                                dispose()
+                              }
+                            })
+                          })
+
+                          createEffect(() => {
+                            if (tab.type !== "session") return
+                            const _sdk = sdk()
+                            if (!_sdk) return
+                            const sess = session()
+                            if (!sess) return
+                            createTabPromptState(tabs, tab, _sdk.scope, {
+                              dir: base64Encode(sess.directory),
+                              id: sess.id,
+                            })
+                          })
+
+                          return (
+                            <>
+                              {divider()}
+                              <Show when={session()}>
+                                {(session) => (
+                                  <TabNavItem
+                                    ref={ref}
+                                    href={tabHref(tab)}
+                                    server={tab.server}
+                                    sessionId={tab.sessionId}
+                                    session={session()}
+                                    onNavigate={() => {
+                                      tabs.select(tab)
+
+                                      ref.scrollIntoView({ behavior: "instant" })
+                                    }}
+                                    onClose={() => tabsStoreActions.removeTab(i())}
+                                    active={currentTab() === tab}
+                                    activeServer={tab.server === server.key}
+                                    forceTruncate={tabsAreOverflowing()}
+                                  />
+                                )}
+                              </Show>
+                            </>
+                          )
+                        }}
+                      </For>
+                      <Show when={creating() && params.dir}>
+                        {(_) => {
+                          let ref!: HTMLDivElement
+
+                          onMount(() => {
+                            ref.scrollIntoView({ behavior: "instant" })
+                          })
+
+                          return (
+                            <>
+                              <div class="w-[1.5px] h-3 shrink-0 rounded-full bg-[var(--v2-background-bg-layer-02)]" />
+                              <NewSessionTabItem
+                                ref={ref}
+                                href={`/${params.dir}/session`}
+                                title={language.t("command.session.new")}
+                                onClose={() => {
+                                  const tab = tabsStore.at(-1)
+                                  if (tab) tabs.select(tab)
+                                  else navigate("/")
+                                }}
+                              />
+                            </>
+                          )
+                        }}
+                      </Show>
+                    </div>
+                  </div>
+                  <div
+                    data-slot="titlebar-tabs-fade-left"
+                    aria-hidden="true"
+                    class="pointer-events-none absolute inset-y-0 left-0 z-10 w-6 bg-[linear-gradient(to_right,var(--v2-background-bg-deep),transparent)]"
+                  />
+                  <div
+                    data-slot="titlebar-tabs-fade-right"
+                    aria-hidden="true"
+                    class="pointer-events-none absolute inset-y-0 right-0 z-10 w-6 bg-[linear-gradient(to_left,var(--v2-background-bg-deep),transparent)]"
+                  />
+                </div>
                 <Show when={!(creating() && params.dir)}>
                   <IconButtonV2
                     type="button"
@@ -690,6 +875,206 @@ function TitlebarUpdateIconButton(props: { state: TitlebarUpdatePillState }) {
   )
 }
 
+function useTabShortcut(index: () => number, onSelect: () => void) {
+  const command = useCommand()
+
+  command.register(() => {
+    const number = index() + 1
+    if (number > 9) return []
+
+    return [
+      {
+        id: `tab.${number}`,
+        category: "tab",
+        title: "",
+        keybind: `mod+${number}`,
+        hidden: true,
+        onSelect,
+      },
+    ]
+  })
+}
+
+function TabNavItem(props: {
+  ref?: HTMLDivElement
+  href: string
+  server: ServerConnection.Key
+  sessionId?: string
+  hideClose?: boolean
+  onClose: () => void
+  onNavigate: () => void
+  active?: boolean
+  activeServer: boolean
+  forceTruncate?: boolean
+  session: Session
+}) {
+  const closeTab = (event: MouseEvent) => {
+    event.preventDefault()
+    event.stopPropagation()
+    props.onClose()
+  }
+
+  const global = useGlobal()
+  const serverCtx = createMemo(() => {
+    const conn = global.servers.list().find((item) => ServerConnection.key(item) === props.server)
+    if (conn) return global.ensureServerCtx(conn)
+  })
+
+  return (
+    <div
+      ref={props.ref}
+      class="group relative flex h-7 w-56 shrink-0 flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
+      data-active={props.active}
+      onMouseDown={(event) => {
+        if (event.button !== 1) return
+        closeTab(event)
+      }}
+    >
+      <Show when={props.session}>
+        {(session) => {
+          const project = createMemo(() => projectForSession(session(), serverCtx()?.projects.list() ?? []))
+
+          return (
+            <a
+              href={props.href}
+              onClick={(event) => {
+                event.preventDefault()
+                props.onNavigate()
+              }}
+              class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 text-[13px] font-medium text-v2-text-text-faint group-data-[active='true']:text-v2-text-text-base"
+            >
+              <span data-slot="project-avatar-slot">
+                <SessionTabAvatar
+                  project={project()}
+                  directory={session().directory}
+                  sessionId={session().id}
+                  activeServer={props.activeServer}
+                />
+              </span>
+              <span class="min-w-0 flex-1">{session().title}</span>
+            </a>
+          )
+        }}
+      </Show>
+
+      <div
+        class="absolute not-group-hover:not-group-data-[active=true]:not-data-[truncate=true]:left-52 group-hover:right-0 group-data-[active=true]:right-0 data-[truncate=true]:right-0 inset-y-0 flex flex-row items-center pr-1 py-1 w-8 pl-2"
+        data-truncate={props.forceTruncate}
+      >
+        <div
+          class="absolute inset-0 rounded-r-[6px] bg-(image:--inactive-bg) group-hover:bg-(image:--active-bg) group-data-[active=true]:bg-(image:--active-bg)"
+          style={{
+            "--inactive-bg": "linear-gradient(to right, transparent 0%, var(--tab-bg) 80%)",
+            "--active-bg": "linear-gradient(90deg, transparent 0%, var(--tab-bg) 25%)",
+          }}
+        />
+        <IconButtonV2
+          size="small"
+          variant="ghost-muted"
+          class="opacity-0 group-hover:opacity-100 group-data-[active='true']:opacity-100 z-10"
+          onClick={closeTab}
+          icon={<IconV2 name="xmark-small" />}
+        />
+      </div>
+    </div>
+  )
+}
+
+function DraftTabItem(props: {
+  ref?: HTMLDivElement
+  href: string
+  title: string
+  active?: boolean
+  onNavigate: () => void
+  onClose: () => void
+}) {
+  const closeTab = (event: MouseEvent) => {
+    event.preventDefault()
+    event.stopPropagation()
+    props.onClose()
+  }
+  return (
+    <div
+      ref={props.ref}
+      data-active={props.active}
+      class="group relative flex h-7 w-56 shrink-0 flex-row items-center gap-1.5 overflow-hidden rounded-[6px] bg-[var(--tab-bg)] pl-1.5 pr-8 whitespace-nowrap [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-overlay-simple-overlay-pressed)] focus-within:outline focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-[var(--v2-border-border-focus)]"
+      onMouseDown={(event) => {
+        if (event.button !== 1) return
+        closeTab(event)
+      }}
+    >
+      <a
+        href={props.href}
+        onClick={(event) => {
+          event.preventDefault()
+          props.onNavigate()
+        }}
+        class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 overflow-hidden text-[13px] font-medium leading-5 text-v2-text-text-faint group-data-[active='true']:text-[var(--v2-text-text-base)]"
+      >
+        <span class="flex size-4 shrink-0 rotate-90 items-center justify-center">
+          <IconV2 name="edit" />
+        </span>
+        <span class="truncate leading-5">{props.title}</span>
+      </a>
+      <div class="absolute right-0 inset-y-0 flex w-7 items-center justify-center">
+        <IconButtonV2
+          size="small"
+          variant="ghost-muted"
+          onMouseDown={(event) => {
+            event.preventDefault()
+            event.stopPropagation()
+          }}
+          onClick={closeTab}
+          icon={<IconV2 name="xmark-small" />}
+          aria-label="Close tab"
+        />
+      </div>
+    </div>
+  )
+}
+
+function NewSessionTabItem(props: { ref?: HTMLDivElement; href: string; title: string; onClose: () => void }) {
+  const closeTab = (event: MouseEvent) => {
+    event.preventDefault()
+    event.stopPropagation()
+    props.onClose()
+  }
+  return (
+    <div
+      ref={props.ref}
+      class="group relative flex h-7 w-56 shrink-0 flex-row items-center gap-1.5 overflow-hidden rounded-[6px] bg-[var(--v2-overlay-simple-overlay-pressed)] pl-1.5 pr-8 whitespace-nowrap focus-within:outline focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-[var(--v2-border-border-focus)]"
+      onMouseDown={(event) => {
+        if (event.button !== 1) return
+        closeTab(event)
+      }}
+    >
+      <a
+        href={props.href}
+        aria-current="page"
+        class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 overflow-hidden text-[13px] font-medium leading-5 text-[var(--v2-text-text-base)]"
+      >
+        <span class="flex size-4 shrink-0 rotate-90 items-center justify-center">
+          <IconV2 name="edit" />
+        </span>
+        <span class="truncate leading-5">{props.title}</span>
+      </a>
+      <div class="absolute right-0 inset-y-0 flex w-7 items-center justify-center">
+        <IconButtonV2
+          size="small"
+          variant="ghost-muted"
+          onMouseDown={(event) => {
+            event.preventDefault()
+            event.stopPropagation()
+          }}
+          onClick={closeTab}
+          icon={<IconV2 name="xmark-small" />}
+          aria-label="Close tab"
+        />
+      </div>
+    </div>
+  )
+}
+
 function ChannelIndicator() {
   return (
     <>

packages/app/src/context/directory-sync.ts

@@ -1,23 +1,175 @@
+import { batch, createMemo } from "solid-js"
+import { createStore, produce, reconcile } from "solid-js/store"
 import { Binary } from "@opencode-ai/core/util/binary"
-import type { Message, Part, Session } from "@opencode-ai/sdk/v2/client"
-import { createMemo } from "solid-js"
-import { produce, reconcile, type SetStoreFunction } from "solid-js/store"
-import type { createServerSdkContext } from "./server-sdk"
-import type { createServerSyncContextInner } from "./server-sync"
-import type { State } from "./global-sync/types"
+import { retry } from "@opencode-ai/core/util/retry"
+import {
+  clearSessionPrefetch,
+  getSessionPrefetch,
+  getSessionPrefetchPromise,
+  setSessionPrefetch,
+} from "./global-sync/session-prefetch"
+import type { Message, Part } from "@opencode-ai/sdk/v2/client"
+import { SESSION_CACHE_LIMIT, dropSessionCaches, pickSessionCacheEvictions } from "./global-sync/session-cache"
+import { diffs as list, message as clean } from "@/utils/diffs"
+import { type createServerSdkContext } from "./server-sdk"
+import { type createServerSyncContextInner } from "./server-sync"
+
+const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
+
+function sortParts(parts: Part[]) {
+  return parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id))
+}
+
+function runInflight(map: Map<string, Promise<void>>, key: string, task: () => Promise<void>) {
+  const pending = map.get(key)
+  if (pending) return pending
+  const promise = task().finally(() => {
+    map.delete(key)
+  })
+  map.set(key, promise)
+  return promise
+}
+
+const keyFor = (directory: string, id: string) => `${directory}\n${id}`
 
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
-const sessionFields = new Set([
-  "session_status",
-  "session_working",
-  "session_diff",
-  "todo",
-  "permission",
-  "question",
-  "message",
-  "part",
-  "part_text_accum_delta",
-])
+
+const isNotFound = (error: unknown) =>
+  error instanceof Error &&
+  typeof error.cause === "object" &&
+  error.cause !== null &&
+  (error.cause as { status?: unknown }).status === 404
+
+function merge<T extends { id: string }>(a: readonly T[], b: readonly T[]) {
+  const map = new Map(a.map((item) => [item.id, item] as const))
+  for (const item of b) map.set(item.id, item)
+  return [...map.values()].sort((x, y) => cmp(x.id, y.id))
+}
+
+type OptimisticStore = {
+  message: Record<string, Message[] | undefined>
+  part: Record<string, Part[] | undefined>
+}
+
+type OptimisticAddInput = {
+  sessionID: string
+  message: Message
+  parts: Part[]
+}
+
+type OptimisticRemoveInput = {
+  sessionID: string
+  messageID: string
+}
+
+type OptimisticItem = {
+  message: Message
+  parts: Part[]
+}
+
+type MessagePage = {
+  session: Message[]
+  part: { id: string; part: Part[] }[]
+  cursor?: string
+  complete: boolean
+}
+
+const hasParts = (parts: Part[] | undefined, want: Part[]) => {
+  if (!parts) return want.length === 0
+  return want.every((part) => Binary.search(parts, part.id, (item) => item.id).found)
+}
+
+const mergeParts = (parts: Part[] | undefined, want: Part[]) => {
+  if (!parts) return sortParts(want)
+  const next = [...parts]
+  let changed = false
+  for (const part of want) {
+    const result = Binary.search(next, part.id, (item) => item.id)
+    if (result.found) continue
+    next.splice(result.index, 0, part)
+    changed = true
+  }
+  if (!changed) return parts
+  return next
+}
+
+export function mergeOptimisticPage(page: MessagePage, items: OptimisticItem[]) {
+  if (items.length === 0) return { ...page, confirmed: [] as string[] }
+
+  const session = [...page.session]
+  const part = new Map(page.part.map((item) => [item.id, sortParts(item.part)]))
+  const confirmed: string[] = []
+
+  for (const item of items) {
+    const result = Binary.search(session, item.message.id, (message) => message.id)
+    const found = result.found
+    if (!found) session.splice(result.index, 0, item.message)
+
+    const current = part.get(item.message.id)
+    if (found && hasParts(current, item.parts)) {
+      confirmed.push(item.message.id)
+      continue
+    }
+
+    part.set(item.message.id, mergeParts(current, item.parts))
+  }
+
+  return {
+    cursor: page.cursor,
+    complete: page.complete,
+    session,
+    part: [...part.entries()].sort((a, b) => cmp(a[0], b[0])).map(([id, part]) => ({ id, part })),
+    confirmed,
+  }
+}
+
+export function applyOptimisticAdd(draft: OptimisticStore, input: OptimisticAddInput) {
+  const messages = draft.message[input.sessionID]
+  if (messages) {
+    const result = Binary.search(messages, input.message.id, (m) => m.id)
+    messages.splice(result.index, 0, input.message)
+  } else {
+    draft.message[input.sessionID] = [input.message]
+  }
+  draft.part[input.message.id] = sortParts(input.parts)
+}
+
+export function applyOptimisticRemove(draft: OptimisticStore, input: OptimisticRemoveInput) {
+  const messages = draft.message[input.sessionID]
+  if (messages) {
+    const result = Binary.search(messages, input.messageID, (m) => m.id)
+    if (result.found) messages.splice(result.index, 1)
+  }
+  delete draft.part[input.messageID]
+}
+
+function setOptimisticAdd(setStore: (...args: unknown[]) => void, input: OptimisticAddInput) {
+  setStore("message", input.sessionID, (messages: Message[] | undefined) => {
+    if (!messages) return [input.message]
+    const result = Binary.search(messages, input.message.id, (m) => m.id)
+    const next = [...messages]
+    next.splice(result.index, 0, input.message)
+    return next
+  })
+  setStore("part", input.message.id, sortParts(input.parts))
+}
+
+function setOptimisticRemove(setStore: (...args: unknown[]) => void, input: OptimisticRemoveInput) {
+  setStore("message", input.sessionID, (messages: Message[] | undefined) => {
+    if (!messages) return messages
+    const result = Binary.search(messages, input.messageID, (m) => m.id)
+    if (!result.found) return messages
+    const next = [...messages]
+    next.splice(result.index, 1)
+    return next
+  })
+  setStore("part", (part: Record<string, Part[] | undefined>) => {
+    if (!(input.messageID in part)) return part
+    const next = { ...part }
+    delete next[input.messageID]
+    return next
+  })
+}
 
 export const createDirSyncContext = (
   directory: string,
@@ -25,42 +177,210 @@ export const createDirSyncContext = (
   serverSDK: ReturnType<typeof createServerSdkContext>,
 ) => {
   const client = serverSDK.createClient({ directory, throwOnError: true })
-  const current = createMemo(() => serverSync.child(directory, { mcp: true }))
-  const absolute = (path: string) => (current()[0].path.directory + "/" + path).replace("//", "/")
-  const data = new Proxy({} as State, {
-    get(_, property: keyof State) {
-      if (property === "session_working") return serverSync.session.data.session_working.bind(serverSync.session.data)
-      if (sessionFields.has(property)) return serverSync.session.data[property as keyof typeof serverSync.session.data]
-      return current()[0][property]
-    },
-  })
-  const set = ((...input: unknown[]) => {
-    if (typeof input[0] === "string" && sessionFields.has(input[0])) {
-      return (serverSync.session.set as (...args: unknown[]) => unknown)(...input)
-    }
-    const result = (current()[1] as (...args: unknown[]) => unknown)(...input)
-    if (input[0] === "session") current()[0].session.forEach(serverSync.session.remember)
-    return result
-  }) as SetStoreFunction<State>
 
-  const index = (sessionID: string) => {
-    const session = serverSync.session.get(sessionID)
-    if (!session || session.directory !== directory) return
-    const [store, setStore] = current()
-    const result = Binary.search(store.session, session.id, (item) => item.id)
-    if (result.found) {
-      setStore("session", result.index, reconcile(session))
+  type Child = ReturnType<(typeof serverSync)["child"]>
+  type Setter = Child[1]
+
+  const current = createMemo(() => serverSync.child(directory, { mcp: true }))
+  const target = (directory?: string) => {
+    if (!directory || directory === directory) return current()
+    return serverSync.child(directory)
+  }
+  const absolute = (path: string) => (current()[0].path.directory + "/" + path).replace("//", "/")
+  const initialMessagePageSize = 2
+  const historyMessagePageSize = 200
+  const inflight = new Map<string, Promise<void>>()
+  const inflightDiff = new Map<string, Promise<void>>()
+  const inflightTodo = new Map<string, Promise<void>>()
+  const optimistic = new Map<string, Map<string, OptimisticItem>>()
+  const maxDirs = 30
+  const seen = new Map<string, Set<string>>()
+  const [meta, setMeta] = createStore({
+    limit: {} as Record<string, number>,
+    cursor: {} as Record<string, string | undefined>,
+    complete: {} as Record<string, boolean>,
+    loading: {} as Record<string, boolean>,
+  })
+
+  const getSession = (sessionID: string) => {
+    const store = current()[0]
+    const match = Binary.search(store.session, sessionID, (s) => s.id)
+    if (match.found) return store.session[match.index]
+    return undefined
+  }
+
+  const setOptimistic = (directory: string, sessionID: string, item: OptimisticItem) => {
+    const key = keyFor(directory, sessionID)
+    const list = optimistic.get(key)
+    if (list) {
+      list.set(item.message.id, { message: item.message, parts: sortParts(item.parts) })
       return
     }
-    setStore(
-      "session",
-      produce((draft) => void draft.splice(result.index, 0, session)),
+    optimistic.set(key, new Map([[item.message.id, { message: item.message, parts: sortParts(item.parts) }]]))
+  }
+
+  const clearOptimistic = (directory: string, sessionID: string, messageID?: string) => {
+    const key = keyFor(directory, sessionID)
+    if (!messageID) {
+      optimistic.delete(key)
+      return
+    }
+
+    const list = optimistic.get(key)
+    if (!list) return
+    list.delete(messageID)
+    if (list.size === 0) optimistic.delete(key)
+  }
+
+  const getOptimistic = (directory: string, sessionID: string) => [
+    ...(optimistic.get(keyFor(directory, sessionID))?.values() ?? []),
+  ]
+
+  const seenFor = (directory: string) => {
+    const existing = seen.get(directory)
+    if (existing) {
+      seen.delete(directory)
+      seen.set(directory, existing)
+      return existing
+    }
+    const created = new Set<string>()
+    seen.set(directory, created)
+    while (seen.size > maxDirs) {
+      const first = seen.keys().next().value
+      if (!first) break
+      const stale = [...(seen.get(first) ?? [])]
+      seen.delete(first)
+      const [, setStore] = serverSync.child(first, { bootstrap: false })
+      evict(first, setStore, stale)
+    }
+    return created
+  }
+
+  const clearMeta = (directory: string, sessionIDs: string[]) => {
+    if (sessionIDs.length === 0) return
+    for (const sessionID of sessionIDs) {
+      clearOptimistic(directory, sessionID)
+    }
+    setMeta(
+      produce((draft) => {
+        for (const sessionID of sessionIDs) {
+          const key = keyFor(directory, sessionID)
+          delete draft.limit[key]
+          delete draft.cursor[key]
+          delete draft.complete[key]
+          delete draft.loading[key]
+        }
+      }),
     )
   }
 
+  const evict = (directory: string, setStore: Setter, sessionIDs: string[]) => {
+    if (sessionIDs.length === 0) return
+    clearSessionPrefetch(serverSDK.scope, directory, sessionIDs)
+    for (const sessionID of sessionIDs) {
+      serverSync.todo.set(sessionID, undefined)
+    }
+    setStore(
+      produce((draft) => {
+        dropSessionCaches(draft, sessionIDs)
+      }),
+    )
+    clearMeta(directory, sessionIDs)
+  }
+
+  const touch = (directory: string, setStore: Setter, sessionID: string) => {
+    const stale = pickSessionCacheEvictions({
+      seen: seenFor(directory),
+      keep: sessionID,
+      limit: SESSION_CACHE_LIMIT,
+    })
+    evict(directory, setStore, stale)
+  }
+
+  const fetchMessages = async (input: { client: typeof client; sessionID: string; limit: number; before?: string }) => {
+    const messages = await retry(() =>
+      input.client.session.messages({ sessionID: input.sessionID, limit: input.limit, before: input.before }),
+    )
+    const items = (messages.data ?? []).filter((x) => !!x?.info?.id)
+    const session = items.map((x) => clean(x.info)).sort((a, b) => cmp(a.id, b.id))
+    const part = items.map((message) => ({ id: message.info.id, part: sortParts(message.parts) }))
+    const cursor = messages.response.headers.get("x-next-cursor") ?? undefined
+    return {
+      session,
+      part,
+      cursor,
+      complete: !cursor,
+    }
+  }
+
+  const tracked = (directory: string, sessionID: string) => seen.get(directory)?.has(sessionID) ?? false
+
+  const loadMessages = async (input: {
+    directory: string
+    client: typeof client
+    setStore: Setter
+    sessionID: string
+    limit: number
+    before?: string
+    mode?: "replace" | "prepend"
+  }) => {
+    const key = keyFor(input.directory, input.sessionID)
+    if (meta.loading[key]) return
+
+    setMeta("loading", key, true)
+    await fetchMessages(input)
+      .then((page) => {
+        if (!tracked(input.directory, input.sessionID)) return
+        const next = mergeOptimisticPage(page, getOptimistic(input.directory, input.sessionID))
+        for (const messageID of next.confirmed) {
+          clearOptimistic(input.directory, input.sessionID, messageID)
+        }
+        const [store] = serverSync.child(input.directory, { bootstrap: false })
+        const cached = input.mode === "prepend" ? (store.message[input.sessionID] ?? []) : []
+        const message = input.mode === "prepend" ? merge(cached, next.session) : next.session
+        batch(() => {
+          input.setStore("message", input.sessionID, reconcile(message, { key: "id" }))
+          for (const p of next.part) {
+            const filtered = p.part.filter((x) => !SKIP_PARTS.has(x.type))
+            if (filtered.length) input.setStore("part", p.id, filtered)
+          }
+          setMeta("limit", key, message.length)
+          setMeta("cursor", key, next.cursor)
+          setMeta("complete", key, next.complete)
+          setSessionPrefetch({
+            scope: serverSDK.scope,
+            directory: input.directory,
+            sessionID: input.sessionID,
+            limit: message.length,
+            cursor: next.cursor,
+            complete: next.complete,
+          })
+        })
+      })
+      .catch((error) => {
+        if (isNotFound(error) && !tracked(input.directory, input.sessionID)) return
+        throw error
+      })
+      .finally(() => {
+        setMeta(
+          produce((draft) => {
+            if (!tracked(input.directory, input.sessionID)) {
+              delete draft.loading[key]
+              return
+            }
+            draft.loading[key] = false
+          }),
+        )
+      })
+  }
+
   return {
-    data,
-    set,
+    get data() {
+      return current()[0]
+    },
+    get set(): Setter {
+      return current()[1]
+    },
     get status() {
       return current()[0].status
     },
@@ -69,24 +389,24 @@ export const createDirSyncContext = (
     },
     get project() {
       const store = current()[0]
-      const match = Binary.search(serverSync.data.project, store.project, (project) => project.id)
+      const match = Binary.search(serverSync.data.project, store.project, (p) => p.id)
       if (match.found) return serverSync.data.project[match.index]
+      return undefined
     },
     session: {
-      remember(session: Session) {
-        serverSync.session.remember(session)
-        index(session.id)
-      },
-      get(sessionID: string) {
-        const session = serverSync.session.get(sessionID)
-        if (session?.directory === directory) return session
-      },
+      get: getSession,
       optimistic: {
         add(input: { directory?: string; sessionID: string; message: Message; parts: Part[] }) {
-          serverSync.session.optimistic.add(input)
+          const _directory = input.directory ?? directory
+          const [, setStore] = target(input.directory)
+          setOptimistic(_directory, input.sessionID, { message: input.message, parts: input.parts })
+          setOptimisticAdd(setStore as (...args: unknown[]) => void, input)
         },
         remove(input: { directory?: string; sessionID: string; messageID: string }) {
-          serverSync.session.optimistic.remove(input)
+          const _directory = input.directory ?? directory
+          const [, setStore] = target(input.directory)
+          clearOptimistic(_directory, input.sessionID, input.messageID)
+          setOptimisticRemove(setStore as (...args: unknown[]) => void, input)
         },
       },
       addOptimisticMessage(input: {
@@ -97,48 +417,194 @@ export const createDirSyncContext = (
         model: { providerID: string; modelID: string }
         variant?: string
       }) {
-        serverSync.session.optimistic.add({
+        const message: Message = {
+          id: input.messageID,
           sessionID: input.sessionID,
-          message: {
-            id: input.messageID,
-            sessionID: input.sessionID,
-            role: "user",
-            time: { created: Date.now() },
-            agent: input.agent,
-            model: { ...input.model, variant: input.variant },
-          },
+          role: "user",
+          time: { created: Date.now() },
+          agent: input.agent,
+          model: { ...input.model, variant: input.variant },
+        }
+        const [, setStore] = target()
+        setOptimistic(directory, input.sessionID, { message, parts: input.parts })
+        setOptimisticAdd(setStore as (...args: unknown[]) => void, {
+          sessionID: input.sessionID,
+          message,
           parts: input.parts,
         })
       },
-      async sync(sessionID: string, options?: { force?: boolean }) {
-        await serverSync.session.sync(sessionID, options)
-        index(sessionID)
+      async sync(sessionID: string, opts?: { force?: boolean }) {
+        const [store, setStore] = serverSync.child(directory)
+        const key = keyFor(directory, sessionID)
+
+        touch(directory, setStore, sessionID)
+
+        const seeded = getSessionPrefetch(serverSDK.scope, directory, sessionID)
+        if (seeded && store.message[sessionID] !== undefined && meta.limit[key] === undefined) {
+          batch(() => {
+            setMeta("limit", key, seeded.limit)
+            setMeta("cursor", key, seeded.cursor)
+            setMeta("complete", key, seeded.complete)
+            setMeta("loading", key, false)
+          })
+        }
+
+        return runInflight(inflight, key, async () => {
+          const pending = getSessionPrefetchPromise(serverSDK.scope, directory, sessionID)
+          if (pending) {
+            await pending
+            const seeded = getSessionPrefetch(serverSDK.scope, directory, sessionID)
+            if (seeded && store.message[sessionID] !== undefined && meta.limit[key] === undefined) {
+              batch(() => {
+                setMeta("limit", key, seeded.limit)
+                setMeta("cursor", key, seeded.cursor)
+                setMeta("complete", key, seeded.complete)
+                setMeta("loading", key, false)
+              })
+            }
+          }
+
+          const hasSession = Binary.search(store.session, sessionID, (s) => s.id).found
+          const cached = store.message[sessionID] !== undefined && meta.limit[key] !== undefined
+          if (cached && hasSession && !opts?.force) return
+
+          const limit = meta.limit[key] ?? initialMessagePageSize
+          const sessionReq =
+            hasSession && !opts?.force
+              ? Promise.resolve()
+              : retry(() => client.session.get({ sessionID }))
+                  .then((session) => {
+                    if (!tracked(directory, sessionID)) return
+                    const data = session.data
+                    if (!data) return
+                    setStore(
+                      "session",
+                      produce((draft) => {
+                        const match = Binary.search(draft, sessionID, (s) => s.id)
+                        if (match.found) {
+                          draft[match.index] = data
+                          return
+                        }
+                        draft.splice(match.index, 0, data)
+                      }),
+                    )
+                  })
+                  .catch((error) => {
+                    if (isNotFound(error) && !tracked(directory, sessionID)) return
+                    throw error
+                  })
+
+          const messagesReq =
+            cached && !opts?.force
+              ? Promise.resolve()
+              : loadMessages({
+                  directory,
+                  client,
+                  setStore,
+                  sessionID,
+                  limit,
+                })
+
+          await Promise.all([sessionReq, messagesReq])
+        })
       },
-      diff: serverSync.session.diff,
-      todo: serverSync.session.todo,
-      history: serverSync.session.history,
-      evict(sessionID: string) {
-        serverSync.session.evict(sessionID)
+      async diff(sessionID: string, opts?: { force?: boolean }) {
+        const [store, setStore] = serverSync.child(directory)
+        touch(directory, setStore, sessionID)
+        if (store.session_diff[sessionID] !== undefined && !opts?.force) return
+
+        const key = keyFor(directory, sessionID)
+        return runInflight(inflightDiff, key, () =>
+          retry(() => client.session.diff({ sessionID })).then((diff) => {
+            if (!tracked(directory, sessionID)) return
+            setStore("session_diff", sessionID, reconcile(list(diff.data), { key: "file" }))
+          }),
+        )
+      },
+      async todo(sessionID: string, opts?: { force?: boolean }) {
+        const [store, setStore] = serverSync.child(directory)
+        touch(directory, setStore, sessionID)
+        const existing = store.todo[sessionID]
+        const cached = serverSync.data.session_todo[sessionID]
+        if (existing !== undefined) {
+          if (cached === undefined) {
+            serverSync.todo.set(sessionID, existing)
+          }
+          if (!opts?.force) return
+        }
+
+        if (cached !== undefined) {
+          setStore("todo", sessionID, reconcile(cached, { key: "id" }))
+        }
+
+        const key = keyFor(directory, sessionID)
+        return runInflight(inflightTodo, key, () =>
+          retry(() => client.session.todo({ sessionID })).then((todo) => {
+            if (!tracked(directory, sessionID)) return
+            const list = todo.data ?? []
+            setStore("todo", sessionID, reconcile(list, { key: "id" }))
+            serverSync.todo.set(sessionID, list)
+          }),
+        )
+      },
+      history: {
+        more(sessionID: string) {
+          const store = current()[0]
+          const key = keyFor(directory, sessionID)
+          if (store.message[sessionID] === undefined) return false
+          if (meta.limit[key] === undefined) return false
+          if (meta.complete[key]) return false
+          return !!meta.cursor[key]
+        },
+        loading(sessionID: string) {
+          const key = keyFor(directory, sessionID)
+          return meta.loading[key] ?? false
+        },
+        async loadMore(sessionID: string, count?: number) {
+          const [, setStore] = serverSync.child(directory)
+          touch(directory, setStore, sessionID)
+          const key = keyFor(directory, sessionID)
+          const step = count ?? historyMessagePageSize
+          if (meta.loading[key]) return
+          if (meta.complete[key]) return
+          const before = meta.cursor[key]
+          if (!before) return
+
+          await loadMessages({
+            directory,
+            client,
+            setStore,
+            sessionID,
+            limit: step,
+            before,
+            mode: "prepend",
+          })
+        },
+      },
+      evict(sessionID: string, _directory = directory) {
+        const [, setStore] = serverSync.child(_directory)
+        seenFor(_directory).delete(sessionID)
+        evict(_directory, setStore, [sessionID])
       },
       fetch: async (count = 10) => {
-        const [store, setStore] = current()
-        setStore("limit", (value) => value + count)
-        const response = await client.session.list()
-        const sessions = (response.data ?? [])
-          .filter((session) => !!session?.id)
-          .sort((a, b) => cmp(a.id, b.id))
-          .slice(0, store.limit)
-        sessions.forEach(serverSync.session.remember)
-        setStore("session", reconcile(sessions, { key: "id" }))
+        const [store, setStore] = serverSync.child(directory)
+        setStore("limit", (x) => x + count)
+        await client.session.list().then((x) => {
+          const sessions = (x.data ?? [])
+            .filter((s) => !!s?.id)
+            .sort((a, b) => cmp(a.id, b.id))
+            .slice(0, store.limit)
+          setStore("session", reconcile(sessions, { key: "id" }))
+        })
       },
       more: createMemo(() => current()[0].session.length >= current()[0].limit),
       archive: async (sessionID: string) => {
-        await serverSDK.client.session.update({ sessionID, time: { archived: Date.now() } })
-        current()[1](
-          "session",
+        const [, setStore] = serverSync.child(directory)
+        await client.session.update({ sessionID, time: { archived: Date.now() } })
+        setStore(
           produce((draft) => {
-            const match = Binary.search(draft, sessionID, (session) => session.id)
-            if (match.found) draft.splice(match.index, 1)
+            const match = Binary.search(draft.session, sessionID, (s) => s.id)
+            if (match.found) draft.session.splice(match.index, 1)
           }),
         )
       },

packages/app/src/context/global-sync/bootstrap.ts

@@ -7,14 +7,14 @@ import type {
   ProviderAuthResponse,
   QuestionRequest,
   Session,
+  Todo,
 } from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@/utils/toast"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { retry } from "@opencode-ai/core/util/retry"
 import { batch } from "solid-js"
-import { produce, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
+import { reconcile, type SetStoreFunction, type Store } from "solid-js/store"
 import type { State, VcsCache } from "./types"
-import type { ServerSession } from "../server-session"
 import { cmp, normalizeAgentList, normalizeProviderList } from "./utils"
 import { formatServerError } from "@/utils/server-errors"
 import { QueryClient, queryOptions } from "@tanstack/solid-query"
@@ -26,6 +26,9 @@ type GlobalStore = {
   ready: boolean
   path: Path
   project: Project[]
+  session_todo: {
+    [sessionID: string]: Todo[]
+  }
   provider: NormalizedProviderListResponse
   provider_auth: ProviderAuthResponse
   config: Config
@@ -212,7 +215,6 @@ export async function bootstrapDirectory(input: {
     provider: NormalizedProviderListResponse
   }
   queryClient: QueryClient
-  session?: ServerSession
 }) {
   const loading = input.store.status !== "complete"
   const seededProject = projectID(input.directory, input.global.project)
@@ -236,30 +238,7 @@ export async function bootstrapDirectory(input: {
           .then((data) => input.setStore("agent", data)),
       () =>
         retry(() => input.sdk.config.get().then((x) => input.setStore("config", reconcile(x.data!, { merge: false })))),
-      () =>
-        retry(() =>
-          input.sdk.session.status().then(async (x) => {
-            if (input.session) {
-              const statuses = x.data ?? {}
-              await Promise.all(
-                Object.keys(statuses).map((sessionID) => input.session!.resolve(sessionID).catch(() => undefined)),
-              )
-              input.session.set(
-                "session_status",
-                produce((draft) => {
-                  for (const sessionID of Object.keys(draft)) {
-                    if (statuses[sessionID]) continue
-                    if (input.session?.get(sessionID)?.directory === input.directory) delete draft[sessionID]
-                  }
-                }),
-              )
-              for (const [sessionID, status] of Object.entries(statuses)) {
-                input.session.set("session_status", sessionID, reconcile(status))
-              }
-            }
-            if (!input.session) input.setStore("session_status", x.data!)
-          }),
-        ),
+      () => retry(() => input.sdk.session.status().then((x) => input.setStore("session_status", x.data!))),
       !seededProject &&
         (() => retry(() => input.sdk.project.current()).then((x) => input.setStore("project", x.data!.id))),
       !seededPath &&
@@ -284,25 +263,21 @@ export async function bootstrapDirectory(input: {
             const grouped = groupBySession(
               (x.data ?? []).filter((perm): perm is PermissionRequest => !!perm?.id && !!perm.sessionID),
             )
-            const warm = input.session
-              ? Promise.all(ids.map((sessionID) => input.session!.resolve(sessionID))).then(() => undefined)
-              : warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk })
-            return warm.then(() =>
+            return warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk }).then(() =>
               batch(() => {
-                const current = input.session?.data.permission ?? input.store.permission
-                for (const sessionID of Object.keys(current)) {
+                for (const sessionID of Object.keys(input.store.permission)) {
                   if (grouped[sessionID]) continue
-                  if (input.session?.get(sessionID)?.directory !== input.directory) continue
-                  if (input.session) input.session.set("permission", sessionID, [])
-                  if (!input.session) input.setStore("permission", sessionID, [])
+                  input.setStore("permission", sessionID, [])
                 }
                 for (const [sessionID, permissions] of Object.entries(grouped)) {
-                  const value = reconcile(
-                    permissions.filter((p) => !!p?.id).sort((a, b) => cmp(a.id, b.id)),
-                    { key: "id" },
+                  input.setStore(
+                    "permission",
+                    sessionID,
+                    reconcile(
+                      permissions.filter((p) => !!p?.id).sort((a, b) => cmp(a.id, b.id)),
+                      { key: "id" },
+                    ),
                   )
-                  if (input.session) input.session.set("permission", sessionID, value)
-                  if (!input.session) input.setStore("permission", sessionID, value)
                 }
               }),
             )
@@ -313,25 +288,21 @@ export async function bootstrapDirectory(input: {
           input.sdk.question.list().then((x) => {
             const ids = (x.data ?? []).map((question) => question?.sessionID).filter((id): id is string => !!id)
             const grouped = groupBySession((x.data ?? []).filter((q): q is QuestionRequest => !!q?.id && !!q.sessionID))
-            const warm = input.session
-              ? Promise.all(ids.map((sessionID) => input.session!.resolve(sessionID))).then(() => undefined)
-              : warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk })
-            return warm.then(() =>
+            return warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk }).then(() =>
               batch(() => {
-                const current = input.session?.data.question ?? input.store.question
-                for (const sessionID of Object.keys(current)) {
+                for (const sessionID of Object.keys(input.store.question)) {
                   if (grouped[sessionID]) continue
-                  if (input.session?.get(sessionID)?.directory !== input.directory) continue
-                  if (input.session) input.session.set("question", sessionID, [])
-                  if (!input.session) input.setStore("question", sessionID, [])
+                  input.setStore("question", sessionID, [])
                 }
                 for (const [sessionID, questions] of Object.entries(grouped)) {
-                  const value = reconcile(
-                    questions.filter((q) => !!q?.id).sort((a, b) => cmp(a.id, b.id)),
-                    { key: "id" },
+                  input.setStore(
+                    "question",
+                    sessionID,
+                    reconcile(
+                      questions.filter((q) => !!q?.id).sort((a, b) => cmp(a.id, b.id)),
+                      { key: "id" },
+                    ),
                   )
-                  if (input.session) input.session.set("question", sessionID, value)
-                  if (!input.session) input.setStore("question", sessionID, value)
                 }
               }),
             )

packages/app/src/context/global-sync/event-reducer.ts

@@ -17,21 +17,6 @@ import { dropSessionCaches } from "./session-cache"
 import { diffs as list, message as clean } from "@/utils/diffs"
 
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
-const SESSION_CONTENT_EVENTS = new Set([
-  "session.diff",
-  "todo.updated",
-  "session.status",
-  "message.updated",
-  "message.removed",
-  "message.part.updated",
-  "message.part.removed",
-  "message.part.delta",
-  "permission.asked",
-  "permission.replied",
-  "question.asked",
-  "question.replied",
-  "question.rejected",
-])
 
 export function applyGlobalEvent(input: {
   event: { type: string; properties?: unknown }
@@ -115,11 +100,8 @@ export function applyDirectoryEvent(input: {
   vcsCache?: VcsCache
   setSessionTodo?: (sessionID: string, todos: Todo[] | undefined) => void
   retainedLimit?: number
-  sessionContent?: boolean
-  permission?: State["permission"]
 }) {
   const event = input.event
-  if (input.sessionContent === false && SESSION_CONTENT_EVENTS.has(event.type)) return
   const limit = Math.max(input.store.limit, input.retainedLimit ?? 0)
   switch (event.type) {
     case "server.instance.disposed": {
@@ -135,7 +117,7 @@ export function applyDirectoryEvent(input: {
       }
       const next = input.store.session.slice()
       next.splice(result.index, 0, info)
-      const trimmed = trimSessions(next, { limit, permission: input.permission ?? input.store.permission })
+      const trimmed = trimSessions(next, { limit, permission: input.store.permission })
       input.setStore("session", reconcile(trimmed, { key: "id" }))
       cleanupDroppedSessionCaches(input.store, input.setStore, trimmed, input.setSessionTodo)
       if (!info.parentID) input.setStore("sessionTotal", (value) => value + 1)
@@ -165,7 +147,7 @@ export function applyDirectoryEvent(input: {
       }
       const next = input.store.session.slice()
       next.splice(result.index, 0, info)
-      const trimmed = trimSessions(next, { limit, permission: input.permission ?? input.store.permission })
+      const trimmed = trimSessions(next, { limit, permission: input.store.permission })
       input.setStore("session", reconcile(trimmed, { key: "id" }))
       cleanupDroppedSessionCaches(input.store, input.setStore, trimmed, input.setSessionTodo)
       break

packages/app/src/context/global-sync/session-prefetch.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test } from "bun:test"
+import {
+  clearSessionPrefetch,
+  clearSessionPrefetchDirectory,
+  getSessionPrefetch,
+  runSessionPrefetch,
+  setSessionPrefetch,
+  shouldSkipSessionPrefetch,
+} from "./session-prefetch"
+import { ServerScope } from "@/utils/server-scope"
+
+const scope = ServerScope.local
+
+describe("session prefetch", () => {
+  test("stores and clears message metadata by directory", () => {
+    clearSessionPrefetch(scope, "/tmp/a", ["ses_1"])
+    clearSessionPrefetch(scope, "/tmp/b", ["ses_1"])
+
+    setSessionPrefetch({
+      directory: "/tmp/a",
+      scope,
+      sessionID: "ses_1",
+      limit: 200,
+      cursor: "abc",
+      complete: false,
+      at: 123,
+    })
+
+    expect(getSessionPrefetch(scope, "/tmp/a", "ses_1")).toEqual({
+      limit: 200,
+      cursor: "abc",
+      complete: false,
+      at: 123,
+    })
+    expect(getSessionPrefetch(scope, "/tmp/b", "ses_1")).toBeUndefined()
+
+    clearSessionPrefetch(scope, "/tmp/a", ["ses_1"])
+
+    expect(getSessionPrefetch(scope, "/tmp/a", "ses_1")).toBeUndefined()
+  })
+
+  test("dedupes inflight work", async () => {
+    clearSessionPrefetch(scope, "/tmp/c", ["ses_2"])
+
+    let calls = 0
+    const run = () =>
+      runSessionPrefetch({
+        directory: "/tmp/c",
+        scope,
+        sessionID: "ses_2",
+        task: async () => {
+          calls += 1
+          return { limit: 100, cursor: "next", complete: true, at: 456 }
+        },
+      })
+
+    const [a, b] = await Promise.all([run(), run()])
+
+    expect(calls).toBe(1)
+    expect(a).toEqual({ limit: 100, cursor: "next", complete: true, at: 456 })
+    expect(b).toEqual({ limit: 100, cursor: "next", complete: true, at: 456 })
+  })
+
+  test("clears a whole directory", () => {
+    setSessionPrefetch({
+      scope,
+      directory: "/tmp/d",
+      sessionID: "ses_1",
+      limit: 10,
+      cursor: "a",
+      complete: true,
+      at: 1,
+    })
+    setSessionPrefetch({
+      scope,
+      directory: "/tmp/d",
+      sessionID: "ses_2",
+      limit: 20,
+      cursor: "b",
+      complete: false,
+      at: 2,
+    })
+    setSessionPrefetch({
+      scope,
+      directory: "/tmp/e",
+      sessionID: "ses_1",
+      limit: 30,
+      cursor: "c",
+      complete: true,
+      at: 3,
+    })
+
+    clearSessionPrefetchDirectory(scope, "/tmp/d")
+
+    expect(getSessionPrefetch(scope, "/tmp/d", "ses_1")).toBeUndefined()
+    expect(getSessionPrefetch(scope, "/tmp/d", "ses_2")).toBeUndefined()
+    expect(getSessionPrefetch(scope, "/tmp/e", "ses_1")).toEqual({ limit: 30, cursor: "c", complete: true, at: 3 })
+  })
+
+  test("isolates identical directories and sessions by server scope", () => {
+    const remote = "https://debian.example" as ServerScope
+    setSessionPrefetch({ scope, directory: "/repo", sessionID: "ses_1", limit: 10, complete: true, at: 1 })
+    setSessionPrefetch({ scope: remote, directory: "/repo", sessionID: "ses_1", limit: 20, complete: true, at: 2 })
+
+    expect(getSessionPrefetch(scope, "/repo", "ses_1")?.limit).toBe(10)
+    expect(getSessionPrefetch(remote, "/repo", "ses_1")?.limit).toBe(20)
+  })
+
+  test("refreshes stale first-page prefetched history", () => {
+    expect(
+      shouldSkipSessionPrefetch({
+        message: true,
+        info: { limit: 200, cursor: "x", complete: false, at: 1 },
+        chunk: 200,
+        now: 1 + 15_001,
+      }),
+    ).toBe(false)
+  })
+
+  test("keeps deeper or complete history cached", () => {
+    expect(
+      shouldSkipSessionPrefetch({
+        message: true,
+        info: { limit: 400, cursor: "x", complete: false, at: 1 },
+        chunk: 200,
+        now: 1 + 15_001,
+      }),
+    ).toBe(true)
+
+    expect(
+      shouldSkipSessionPrefetch({
+        message: true,
+        info: { limit: 120, complete: true, at: 1 },
+        chunk: 200,
+        now: 1 + 15_001,
+      }),
+    ).toBe(true)
+  })
+})

packages/app/src/context/global-sync/session-prefetch.ts

@@ -0,0 +1,107 @@
+import { ScopedKey, type ServerScope } from "@/utils/server-scope"
+
+const key = (scope: ServerScope, directory: string, sessionID: string) => ScopedKey.from(scope, directory, sessionID)
+
+export const SESSION_PREFETCH_TTL = 15_000
+
+type Meta = {
+  limit: number
+  cursor?: string
+  complete: boolean
+  at: number
+}
+
+export function shouldSkipSessionPrefetch(input: { message: boolean; info?: Meta; chunk: number; now?: number }) {
+  if (input.message) {
+    if (!input.info) return true
+    if (input.info.complete) return true
+    if (input.info.limit > input.chunk) return true
+  } else {
+    if (!input.info) return false
+  }
+
+  return (input.now ?? Date.now()) - input.info.at < SESSION_PREFETCH_TTL
+}
+
+const cache = new Map<string, Meta>()
+const inflight = new Map<string, Promise<Meta | undefined>>()
+const rev = new Map<string, number>()
+
+const version = (id: string) => rev.get(id) ?? 0
+
+export function getSessionPrefetch(scope: ServerScope, directory: string, sessionID: string) {
+  return cache.get(key(scope, directory, sessionID))
+}
+
+export function getSessionPrefetchPromise(scope: ServerScope, directory: string, sessionID: string) {
+  return inflight.get(key(scope, directory, sessionID))
+}
+
+export function clearSessionPrefetchInflight(scope: ServerScope) {
+  const prefix = ScopedKey.prefix(scope)
+  for (const id of inflight.keys()) {
+    if (id.startsWith(prefix)) inflight.delete(id)
+  }
+}
+
+export function isSessionPrefetchCurrent(scope: ServerScope, directory: string, sessionID: string, value: number) {
+  return version(key(scope, directory, sessionID)) === value
+}
+
+export function runSessionPrefetch(input: {
+  directory: string
+  scope: ServerScope
+  sessionID: string
+  task: (value: number) => Promise<Meta | undefined>
+}) {
+  const id = key(input.scope, input.directory, input.sessionID)
+  const pending = inflight.get(id)
+  if (pending) return pending
+
+  const value = version(id)
+
+  const promise = input.task(value).finally(() => {
+    if (inflight.get(id) === promise) inflight.delete(id)
+  })
+
+  inflight.set(id, promise)
+  return promise
+}
+
+export function setSessionPrefetch(input: {
+  directory: string
+  scope: ServerScope
+  sessionID: string
+  limit: number
+  cursor?: string
+  complete: boolean
+  at?: number
+}) {
+  cache.set(key(input.scope, input.directory, input.sessionID), {
+    limit: input.limit,
+    cursor: input.cursor,
+    complete: input.complete,
+    at: input.at ?? Date.now(),
+  })
+}
+
+export function clearSessionPrefetch(scope: ServerScope, directory: string, sessionIDs: Iterable<string>) {
+  for (const sessionID of sessionIDs) {
+    if (!sessionID) continue
+    const id = key(scope, directory, sessionID)
+    rev.set(id, version(id) + 1)
+    cache.delete(id)
+    inflight.delete(id)
+  }
+}
+
+export function clearSessionPrefetchDirectory(scope: ServerScope, directory: string) {
+  const prefix = ScopedKey.prefix(scope, directory)
+  const keys = new Set([...cache.keys(), ...inflight.keys()])
+  for (const id of keys) {
+    if (!id.startsWith(prefix)) continue
+    rev.set(id, version(id) + 1)
+    cache.delete(id)
+    inflight.delete(id)
+  }
+}

packages/app/src/context/global.tsx

@@ -8,11 +8,13 @@ import { createServerSyncContext } from "./server-sync"
 import { getOwner } from "solid-js/web"
 import { QueryClient } from "@tanstack/solid-query"
 import type { ServerScope } from "@/utils/server-scope"
+import { createSessionPlacementStore } from "@/utils/session-placement"
 
 export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext({
   name: "Global",
   init: () => {
     const server = useServer()
+    const sessionPlacement = createSessionPlacementStore()
     const serverHealth = useServerHealth(
       () => server.list,
       () => true,
@@ -85,6 +87,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
           },
         },
       },
+      sessionPlacement,
       ensureServerCtx(conn: ServerConnection.Any) {
         return ensureServerCtx(conn)
       },

packages/app/src/context/local.tsx

@@ -60,7 +60,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     const sdk = useSDK()
     const sync = useSync()
     const serverSDK = useServerSDK()
-    const providers = useProviders(() => sdk().directory)
+    const providers = useProviders()
     const models = useModels()
 
     const id = createMemo(() => params.id || undefined)

packages/app/src/context/models.tsx

@@ -1,4 +1,4 @@
-import { type Accessor, createMemo } from "solid-js"
+import { createMemo } from "solid-js"
 import { createStore } from "solid-js/store"
 import { DateTime } from "luxon"
 import { filter, firstBy, flat, groupBy, mapValues, pipe, uniqueBy, values } from "remeda"
@@ -25,8 +25,8 @@ function modelKey(model: ModelKey) {
 export const { use: useModels, provider: ModelsProvider } = createSimpleContext({
   name: "Models",
   gate: false,
-  init: (props: { directory?: Accessor<string | undefined> } = {}) => {
-    const providers = useProviders(props.directory)
+  init: () => {
+    const providers = useProviders()
 
     const [store, setStore, _, ready] = persisted(
       Persist.global("model", ["model.v1"]),

packages/app/src/context/prompt.tsx

@@ -9,7 +9,7 @@ import { useServerSDK } from "./server-sdk"
 import type { ServerScope } from "@/utils/server-scope"
 import { useSDK } from "./sdk"
 import { useTabs, type Tab } from "./tabs"
-import { ServerConnection, useServer } from "./server"
+import { useServer } from "./server"
 import { requireServerKey } from "@/utils/session-route"
 import { useSettings } from "./settings"
 
@@ -169,15 +169,6 @@ type PromptStore = {
 
 type Scope = { draftID: string } | { dir: string; id?: string }
 
-export function selectPromptTab(tabs: Tab[], scope: Scope, server: ServerConnection.Key) {
-  if ("draftID" in scope) return tabs.find((tab) => tab.type === "draft" && tab.draftID === scope.draftID)
-  if (!scope.id) return
-  return (
-    tabs.find((tab) => tab.type === "session" && tab.server === server && tab.sessionId === scope.id) ??
-    ({ type: "session", server, sessionId: scope.id } satisfies Tab)
-  )
-}
-
 function scopeKey(scope: Scope) {
   if ("draftID" in scope) return `draft:${scope.draftID}`
   return `${scope.dir}:${scope.id ?? WORKSPACE_KEY}`
@@ -222,7 +213,7 @@ function promptStore(): PromptStore {
 function createPromptStateValue(store: PromptStore, setStore: SetStoreFunction<PromptStore>) {
   const actions = createPromptActions(setStore)
 
-  const value = {
+  return {
     current: () => store.prompt,
     cursor: createMemo(() => store.cursor),
     dirty: () => !isPromptEqual(store.prompt, DEFAULT_PROMPT),
@@ -259,9 +250,7 @@ function createPromptStateValue(store: PromptStore, setStore: SetStoreFunction<P
     },
     set: actions.set,
     reset: actions.reset,
-    capture: () => value,
   }
-  return value
 }
 
 export function createPromptState() {
@@ -312,11 +301,21 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
     }
 
     const owner = getOwner()
-    const serverKey = () => (params.serverKey ? requireServerKey(params.serverKey) : server.key)
-    const scope = () =>
-      search.draftId ? { draftID: search.draftId } : { dir: base64Encode(sdk().directory), id: params.id }
+    const tab = createMemo<Tab | undefined>(() => {
+      if (!settings.general.newLayoutDesigns()) return
+      if (search.draftId) {
+        return tabs.store.find((item) => item.type === "draft" && item.draftID === search.draftId)
+      }
+      if (!params.id) return
+      const serverKey = params.serverKey ? requireServerKey(params.serverKey) : server.key
+      return (
+        tabs.store.find(
+          (item) => item.type === "session" && item.server === serverKey && item.sessionId === params.id,
+        ) ?? { type: "session", server: serverKey, sessionId: params.id }
+      )
+    })
     const load = (scope: Scope) => {
-      const current = settings.general.newLayoutDesigns() ? selectPromptTab(tabs.store, scope, serverKey()) : undefined
+      const current = tab()
       if (current) {
         return createTabPromptState(tabs, current, serverSDK().scope, scope)
       }
@@ -342,13 +341,14 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
       return entry.value
     }
 
-    const session = createMemo(() => load(scope()))
+    const session = createMemo(() =>
+      load(search.draftId ? { draftID: search.draftId } : { dir: base64Encode(sdk().directory), id: params.id }),
+    )
     const pick = (scope?: Scope) => (scope ? load(scope) : session())
     const ready = createPromptReady(session)
 
     return {
       ready,
-      capture: (scope?: Scope) => pick(scope).capture(),
       current: () => session().current(),
       cursor: () => session().cursor(),
       dirty: () => session().dirty(),

packages/app/src/context/server-session.test.ts

@@ -1,98 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { OpencodeClient, Session } from "@opencode-ai/sdk/v2/client"
-import { createServerSession } from "./server-session"
-
-const session = (id: string, parentID?: string): Session => ({
-  id,
-  slug: id,
-  projectID: "project",
-  directory: "/repo",
-  title: id,
-  version: "1",
-  parentID,
-  time: { created: 1, updated: 1 },
-})
-
-function setup(sessions: Record<string, Session>) {
-  const get: unknown[] = []
-  const messages: unknown[] = []
-  const client = {
-    session: {
-      get: async (input: unknown) => {
-        get.push(input)
-        const id = (input as { sessionID: string }).sessionID
-        return { data: sessions[id] }
-      },
-      messages: async (input: unknown) => {
-        messages.push(input)
-        return { data: [], response: { headers: new Headers() } }
-      },
-      diff: async () => ({ data: [] }),
-      todo: async () => ({ data: [] }),
-    },
-  } as unknown as OpencodeClient
-  return { get, messages, store: createServerSession(client) }
-}
-
-describe("server session", () => {
-  test("resolves lineage by session ID without directory", async () => {
-    const ctx = setup({ child: session("child", "root"), root: session("root") })
-
-    const result = await ctx.store.lineage.resolve("child")
-
-    expect(result.root.id).toBe("root")
-    expect(ctx.get).toEqual([{ sessionID: "child" }, { sessionID: "root" }])
-    expect(ctx.store.lineage.peek("child")).toEqual(result)
-  })
-
-  test("loads session content through the server client", async () => {
-    const ctx = setup({ root: session("root") })
-
-    await ctx.store.sync("root")
-
-    expect(ctx.get).toEqual([{ sessionID: "root" }])
-    expect(ctx.messages).toEqual([{ sessionID: "root", limit: 2, before: undefined }])
-    expect(ctx.store.data.message.root).toEqual([])
-  })
-
-  test("applies events without a directory store", () => {
-    const ctx = setup({})
-    ctx.store.apply({ type: "session.created", properties: { info: session("root") } })
-    ctx.store.apply({ type: "session.status", properties: { sessionID: "root", status: { type: "busy" } } })
-
-    expect(ctx.store.get("root")?.directory).toBe("/repo")
-    expect(ctx.store.data.session_working("root")).toBe(true)
-  })
-
-  test("preserves pinned session content under server-wide cache pressure", () => {
-    const ctx = setup({})
-    ctx.store.pin("active")
-    ctx.store.optimistic.add({
-      sessionID: "active",
-      message: {
-        id: "message",
-        sessionID: "active",
-        role: "assistant",
-        time: { created: 1 },
-        parentID: "parent",
-        modelID: "model",
-        providerID: "provider",
-        mode: "build",
-        agent: "agent",
-        path: { cwd: "/repo", root: "/repo" },
-        cost: 0,
-        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-      },
-      parts: [],
-    })
-
-    for (let index = 0; index < 50; index++) {
-      ctx.store.apply({
-        type: "session.status",
-        properties: { sessionID: `session-${index}`, status: { type: "busy" } },
-      })
-    }
-
-    expect(ctx.store.data.message.active?.map((message) => message.id)).toEqual(["message"])
-  })
-})

packages/app/src/context/server-session.ts

@@ -1,626 +0,0 @@
-import { Binary } from "@opencode-ai/core/util/binary"
-import { retry } from "@opencode-ai/core/util/retry"
-import type {
-  Message,
-  OpencodeClient,
-  Part,
-  PermissionRequest,
-  QuestionRequest,
-  Session,
-  SessionStatus,
-  SnapshotFileDiff,
-  Todo,
-} from "@opencode-ai/sdk/v2/client"
-import { batch } from "solid-js"
-import { createStore, produce, reconcile } from "solid-js/store"
-import { diffs as cleanDiffs, message as cleanMessage } from "@/utils/diffs"
-import { rootSession } from "@/utils/session-route"
-import { dropSessionCaches, pickSessionCacheEvictions, SESSION_CACHE_LIMIT } from "./global-sync/session-cache"
-
-const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
-const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
-const initialMessagePageSize = 2
-const historyMessagePageSize = 200
-const sessionInfoLimit = 2_048
-
-type OptimisticItem = {
-  message: Message
-  parts: Part[]
-}
-
-const hasParts = (parts: Part[] | undefined, want: Part[]) => {
-  if (!parts) return want.length === 0
-  return want.every((part) => Binary.search(parts, part.id, (item) => item.id).found)
-}
-
-function mergeOptimisticPage(
-  page: { session: Message[]; part: { id: string; part: Part[] }[]; cursor?: string; complete: boolean },
-  items: OptimisticItem[],
-) {
-  if (items.length === 0) return { ...page, confirmed: [] as string[] }
-  const session = [...page.session]
-  const part = new Map(page.part.map((item) => [item.id, item.part]))
-  const confirmed: string[] = []
-  for (const item of items) {
-    const result = Binary.search(session, item.message.id, (message) => message.id)
-    if (!result.found) session.splice(result.index, 0, item.message)
-    const current = part.get(item.message.id)
-    if (result.found && hasParts(current, item.parts)) {
-      confirmed.push(item.message.id)
-      continue
-    }
-    part.set(item.message.id, merge(current ?? [], item.parts))
-  }
-  return {
-    ...page,
-    session,
-    part: [...part.entries()].sort((a, b) => cmp(a[0], b[0])).map(([id, parts]) => ({ id, part: parts })),
-    confirmed,
-  }
-}
-
-function runInflight(map: Map<string, Promise<void>>, key: string, task: () => Promise<void>) {
-  const pending = map.get(key)
-  if (pending) return pending
-  const promise = task().finally(() => {
-    if (map.get(key) === promise) map.delete(key)
-  })
-  map.set(key, promise)
-  return promise
-}
-
-function merge<T extends { id: string }>(a: readonly T[], b: readonly T[]) {
-  const items = new Map(a.map((item) => [item.id, item] as const))
-  for (const item of b) items.set(item.id, item)
-  return [...items.values()].sort((x, y) => cmp(x.id, y.id))
-}
-
-export function createServerSession(client: OpencodeClient) {
-  const [data, setData] = createStore({
-    info: {} as Record<string, Session | undefined>,
-    session_status: {} as Record<string, SessionStatus>,
-    session_diff: {} as Record<string, SnapshotFileDiff[]>,
-    todo: {} as Record<string, Todo[]>,
-    permission: {} as Record<string, PermissionRequest[]>,
-    question: {} as Record<string, QuestionRequest[]>,
-    message: {} as Record<string, Message[]>,
-    part: {} as Record<string, Part[]>,
-    part_text_accum_delta: {} as Record<string, string>,
-    session_working(id: string) {
-      return (this.session_status[id]?.type ?? "idle") !== "idle"
-    },
-  })
-  const requests = new Map<string, Promise<Session>>()
-  const inflight = new Map<string, Promise<void>>()
-  const inflightDiff = new Map<string, Promise<void>>()
-  const inflightTodo = new Map<string, Promise<void>>()
-  const optimistic = new Map<string, Map<string, OptimisticItem>>()
-  const seen = new Set<string>()
-  const infoSeen = new Set<string>()
-  const pinned = new Map<string, number>()
-  const generations = new Map<string, number>()
-  const [meta, setMeta] = createStore({
-    limit: {} as Record<string, number | undefined>,
-    cursor: {} as Record<string, string | undefined>,
-    complete: {} as Record<string, boolean | undefined>,
-    loading: {} as Record<string, boolean | undefined>,
-    at: {} as Record<string, number | undefined>,
-  })
-
-  const remember = (session: Session) => {
-    setData("info", session.id, reconcile(session))
-    infoSeen.delete(session.id)
-    infoSeen.add(session.id)
-    if (infoSeen.size > sessionInfoLimit) {
-      const preserve = new Set([
-        ...pinned.keys(),
-        ...requests.keys(),
-        ...Object.entries(data.permission)
-          .filter(([, items]) => items.length > 0)
-          .map(([sessionID]) => sessionID),
-        ...Object.entries(data.question)
-          .filter(([, items]) => items.length > 0)
-          .map(([sessionID]) => sessionID),
-        ...Object.entries(data.session_status)
-          .filter(([, status]) => status.type !== "idle")
-          .map(([sessionID]) => sessionID),
-      ])
-      for (const sessionID of preserve) {
-        let current = data.info[sessionID]
-        while (current) {
-          preserve.add(current.id)
-          current = current.parentID ? data.info[current.parentID] : undefined
-        }
-      }
-      const stale: string[] = []
-      for (const sessionID of infoSeen) {
-        if (infoSeen.size - stale.length <= sessionInfoLimit) break
-        if (!preserve.has(sessionID)) stale.push(sessionID)
-      }
-      stale.forEach((sessionID) => infoSeen.delete(sessionID))
-      setData(
-        "info",
-        produce((draft) => stale.forEach((sessionID) => delete draft[sessionID])),
-      )
-    }
-    return session
-  }
-
-  const resolve = (sessionID: string, options?: { force?: boolean }) => {
-    const cached = data.info[sessionID]
-    if (cached && !options?.force) return Promise.resolve(cached)
-    const pending = requests.get(sessionID)
-    if (pending) return pending
-    const generation = generations.get(sessionID) ?? 0
-    const request = client.session.get({ sessionID }).then((result) => {
-      if (!result.data) throw new Error(`Session not found: ${sessionID}`)
-      if ((generations.get(sessionID) ?? 0) !== generation) return result.data
-      return remember(result.data)
-    })
-    requests.set(sessionID, request)
-    void request.then(
-      () => {
-        if (requests.get(sessionID) === request) requests.delete(sessionID)
-      },
-      () => {
-        if (requests.get(sessionID) === request) requests.delete(sessionID)
-      },
-    )
-    return request
-  }
-
-  const peekLineage = (sessionID: string) => {
-    const session = data.info[sessionID]
-    if (!session) return
-    const seen = new Set([session.id])
-    let root = session
-    while (root.parentID) {
-      if (seen.has(root.parentID)) throw new Error(`Session parent cycle: ${root.parentID}`)
-      seen.add(root.parentID)
-      const parent = data.info[root.parentID]
-      if (!parent) return
-      root = parent
-    }
-    return { session, root }
-  }
-
-  const clearOptimistic = (sessionID: string, messageID?: string) => {
-    if (!messageID) {
-      optimistic.delete(sessionID)
-      return
-    }
-    const items = optimistic.get(sessionID)
-    if (!items) return
-    items.delete(messageID)
-    if (items.size === 0) optimistic.delete(sessionID)
-  }
-
-  const evict = (sessionIDs: string[]) => {
-    if (sessionIDs.length === 0) return
-    sessionIDs.forEach((sessionID) => {
-      generations.set(sessionID, (generations.get(sessionID) ?? 0) + 1)
-      clearOptimistic(sessionID)
-      requests.delete(sessionID)
-      inflight.delete(sessionID)
-      inflightDiff.delete(sessionID)
-      inflightTodo.delete(sessionID)
-    })
-    setData(
-      produce((draft) => {
-        dropSessionCaches(draft, sessionIDs)
-      }),
-    )
-    setMeta(
-      produce((draft) => {
-        for (const sessionID of sessionIDs) {
-          delete draft.limit[sessionID]
-          delete draft.cursor[sessionID]
-          delete draft.complete[sessionID]
-          delete draft.loading[sessionID]
-          delete draft.at[sessionID]
-        }
-      }),
-    )
-  }
-
-  const protectedSessions = () =>
-    new Set([
-      ...pinned.keys(),
-      ...requests.keys(),
-      ...inflight.keys(),
-      ...inflightDiff.keys(),
-      ...inflightTodo.keys(),
-      ...optimistic.keys(),
-      ...Object.entries(data.permission)
-        .filter(([, items]) => items.length > 0)
-        .map(([sessionID]) => sessionID),
-      ...Object.entries(data.question)
-        .filter(([, items]) => items.length > 0)
-        .map(([sessionID]) => sessionID),
-      ...Object.entries(data.session_status)
-        .filter(([, status]) => status.type !== "idle")
-        .map(([sessionID]) => sessionID),
-    ])
-
-  const touch = (sessionID: string) =>
-    evict(
-      pickSessionCacheEvictions({ seen, keep: sessionID, limit: SESSION_CACHE_LIMIT, preserve: protectedSessions() }),
-    )
-
-  const fetchMessages = async (sessionID: string, limit: number, before?: string) => {
-    const response = await retry(() => client.session.messages({ sessionID, limit, before }))
-    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)),
-      part: items.map((item) => ({
-        id: item.info.id,
-        part: item.parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id)),
-      })),
-      cursor: response.response.headers.get("x-next-cursor") ?? undefined,
-      complete: !response.response.headers.get("x-next-cursor"),
-    }
-  }
-
-  const loadMessages = async (sessionID: string, limit: number, before?: string, mode?: "replace" | "prepend") => {
-    if (meta.loading[sessionID]) return
-    const generation = generations.get(sessionID) ?? 0
-    setMeta("loading", sessionID, true)
-    await fetchMessages(sessionID, limit, before)
-      .then((page) => {
-        if ((generations.get(sessionID) ?? 0) !== generation) return
-        const next = mergeOptimisticPage(page, [...(optimistic.get(sessionID)?.values() ?? [])])
-        next.confirmed.forEach((messageID) => clearOptimistic(sessionID, messageID))
-        const messages = mode === "prepend" ? merge(data.message[sessionID] ?? [], next.session) : next.session
-        batch(() => {
-          setData("message", sessionID, reconcile(messages, { key: "id" }))
-          for (const item of next.part) {
-            const parts = item.part.filter((part) => !SKIP_PARTS.has(part.type))
-            if (parts.length) setData("part", item.id, reconcile(parts, { key: "id" }))
-          }
-          setMeta("limit", sessionID, messages.length)
-          setMeta("cursor", sessionID, next.cursor)
-          setMeta("complete", sessionID, next.complete)
-          setMeta("at", sessionID, Date.now())
-        })
-      })
-      .finally(() => {
-        if ((generations.get(sessionID) ?? 0) === generation) setMeta("loading", sessionID, false)
-      })
-  }
-
-  const sync = (sessionID: string, options?: { force?: boolean; messageLimit?: number }) => {
-    touch(sessionID)
-    return runInflight(inflight, sessionID, async () => {
-      const cached = data.message[sessionID] !== undefined && meta.limit[sessionID] !== undefined
-      if (cached && data.info[sessionID] && !options?.force) return
-      await Promise.all([
-        resolve(sessionID, options),
-        cached && !options?.force
-          ? Promise.resolve()
-          : loadMessages(sessionID, options?.messageLimit ?? meta.limit[sessionID] ?? initialMessagePageSize),
-      ])
-    })
-  }
-
-  const prefetch = async (sessionID: string, limit: number) => {
-    touch(sessionID)
-    await inflight.get(sessionID)
-    if (
-      Date.now() - (meta.at[sessionID] ?? 0) <= 15_000 &&
-      (meta.complete[sessionID] || (data.message[sessionID]?.length ?? 0) >= limit)
-    )
-      return
-    await runInflight(inflight, sessionID, () => loadMessages(sessionID, limit))
-  }
-
-  const eventSessionID = (event: { type: string; properties?: unknown }) => {
-    const properties = event.properties
-    if (!properties || typeof properties !== "object") return
-    if ("sessionID" in properties && typeof properties.sessionID === "string") return properties.sessionID
-    if (
-      "info" in properties &&
-      properties.info &&
-      typeof properties.info === "object" &&
-      "sessionID" in properties.info &&
-      typeof properties.info.sessionID === "string"
-    )
-      return properties.info.sessionID
-    if (
-      "part" in properties &&
-      properties.part &&
-      typeof properties.part === "object" &&
-      "sessionID" in properties.part &&
-      typeof properties.part.sessionID === "string"
-    )
-      return properties.part.sessionID
-  }
-
-  const apply = (event: { type: string; properties?: unknown }) => {
-    const eventID = eventSessionID(event)
-    if (eventID) {
-      touch(eventID)
-      if (!data.info[eventID]) void resolve(eventID).catch(() => {})
-    }
-    switch (event.type) {
-      case "session.created":
-        remember((event.properties as { info: Session }).info)
-        return
-      case "session.updated": {
-        const info = (event.properties as { info: Session }).info
-        remember(info)
-        if (info.time.archived) evict([info.id])
-        return
-      }
-      case "session.deleted": {
-        const sessionID = (event.properties as { info: Session }).info.id
-        infoSeen.delete(sessionID)
-        setData(
-          "info",
-          produce((draft) => void delete draft[sessionID]),
-        )
-        evict([sessionID])
-        return
-      }
-      case "session.diff": {
-        const props = event.properties as { sessionID: string; diff: SnapshotFileDiff[] }
-        setData("session_diff", props.sessionID, reconcile(cleanDiffs(props.diff), { key: "file" }))
-        return
-      }
-      case "todo.updated": {
-        const props = event.properties as { sessionID: string; todos: Todo[] }
-        setData("todo", props.sessionID, reconcile(props.todos, { key: "id" }))
-        return
-      }
-      case "session.status": {
-        const props = event.properties as { sessionID: string; status: SessionStatus }
-        setData("session_status", props.sessionID, reconcile(props.status))
-        return
-      }
-      case "message.updated": {
-        const info = cleanMessage((event.properties as { info: Message }).info)
-        const messages = data.message[info.sessionID]
-        if (!messages) {
-          setData("message", info.sessionID, [info])
-          return
-        }
-        const result = Binary.search(messages, info.id, (message) => message.id)
-        if (result.found) setData("message", info.sessionID, result.index, reconcile(info))
-        if (!result.found)
-          setData("message", info.sessionID, (value = []) => {
-            const next = value.slice()
-            next.splice(result.index, 0, info)
-            return next
-          })
-        return
-      }
-      case "message.removed": {
-        const props = event.properties as { sessionID: string; messageID: string }
-        setData(
-          produce((draft) => {
-            const messages = draft.message[props.sessionID]
-            if (messages) {
-              const result = Binary.search(messages, props.messageID, (message) => message.id)
-              if (result.found) messages.splice(result.index, 1)
-            }
-            for (const part of draft.part[props.messageID] ?? []) delete draft.part_text_accum_delta[part.id]
-            delete draft.part[props.messageID]
-          }),
-        )
-        return
-      }
-      case "message.part.updated": {
-        const part = (event.properties as { part: Part }).part
-        if (SKIP_PARTS.has(part.type)) return
-        setData(
-          "part_text_accum_delta",
-          produce((draft) => void delete draft[part.id]),
-        )
-        const parts = data.part[part.messageID]
-        if (!parts) {
-          setData("part", part.messageID, [part])
-          return
-        }
-        const result = Binary.search(parts, part.id, (item) => item.id)
-        if (result.found) setData("part", part.messageID, result.index, reconcile(part))
-        if (!result.found)
-          setData("part", part.messageID, (value = []) => {
-            const next = value.slice()
-            next.splice(result.index, 0, part)
-            return next
-          })
-        return
-      }
-      case "message.part.removed": {
-        const props = event.properties as { messageID: string; partID: string }
-        setData(
-          produce((draft) => {
-            delete draft.part_text_accum_delta[props.partID]
-            const parts = draft.part[props.messageID]
-            if (!parts) return
-            const result = Binary.search(parts, props.partID, (part) => part.id)
-            if (result.found) parts.splice(result.index, 1)
-            if (parts.length === 0) delete draft.part[props.messageID]
-          }),
-        )
-        return
-      }
-      case "message.part.delta": {
-        const props = event.properties as { messageID: string; partID: string; field: string; delta: string }
-        const parts = data.part[props.messageID]
-        if (!parts) return
-        const result = Binary.search(parts, props.partID, (part) => part.id)
-        if (!result.found) return
-        const field = props.field as keyof (typeof parts)[number]
-        const current = parts[result.index]?.[field]
-        setData(
-          "part_text_accum_delta",
-          props.partID,
-          (value) => (value ?? (typeof current === "string" ? current : "")) + props.delta,
-        )
-        setData(
-          "part",
-          props.messageID,
-          produce((draft) => {
-            if (!draft) return
-            const part = draft[result.index]
-            const field = props.field as keyof typeof part
-            ;(part[field] as string) = ((part[field] as string | undefined) ?? "") + props.delta
-          }),
-        )
-        return
-      }
-      case "permission.asked": {
-        const permission = event.properties as PermissionRequest
-        const permissions = data.permission[permission.sessionID] ?? []
-        const result = Binary.search(permissions, permission.id, (item) => item.id)
-        if (result.found) setData("permission", permission.sessionID, result.index, reconcile(permission))
-        if (!result.found)
-          setData(
-            "permission",
-            permission.sessionID,
-            produce((draft = []) => void draft.splice(result.index, 0, permission)),
-          )
-        return
-      }
-      case "permission.replied": {
-        const props = event.properties as { sessionID: string; requestID: string }
-        setData(
-          "permission",
-          props.sessionID,
-          produce((draft) => {
-            if (!draft) return
-            const result = Binary.search(draft, props.requestID, (item) => item.id)
-            if (result.found) draft.splice(result.index, 1)
-          }),
-        )
-        return
-      }
-      case "question.asked": {
-        const question = event.properties as QuestionRequest
-        const questions = data.question[question.sessionID] ?? []
-        const result = Binary.search(questions, question.id, (item) => item.id)
-        if (result.found) setData("question", question.sessionID, result.index, reconcile(question))
-        if (!result.found)
-          setData(
-            "question",
-            question.sessionID,
-            produce((draft = []) => void draft.splice(result.index, 0, question)),
-          )
-        return
-      }
-      case "question.replied":
-      case "question.rejected": {
-        const props = event.properties as { sessionID: string; requestID: string }
-        setData(
-          "question",
-          props.sessionID,
-          produce((draft) => {
-            if (!draft) return
-            const result = Binary.search(draft, props.requestID, (item) => item.id)
-            if (result.found) draft.splice(result.index, 1)
-          }),
-        )
-      }
-    }
-  }
-
-  return {
-    data,
-    set: setData,
-    get: (sessionID: string) => data.info[sessionID],
-    peek: (sessionID: string) => data.info[sessionID],
-    remember,
-    resolve,
-    lineage: {
-      peek: peekLineage,
-      async resolve(sessionID: string) {
-        const session = await resolve(sessionID)
-        return { session, root: await rootSession(session, resolve) }
-      },
-    },
-    sync,
-    prefetch,
-    shouldPrefetch(sessionID: string, limit: number) {
-      if (data.message[sessionID] === undefined) return true
-      if (Date.now() - (meta.at[sessionID] ?? 0) > 15_000) return true
-      if (meta.complete[sessionID]) return false
-      return (meta.limit[sessionID] ?? 0) <= limit
-    },
-    fresh(sessionID: string, ttl: number) {
-      return Date.now() - (meta.at[sessionID] ?? 0) <= ttl
-    },
-    optimistic: {
-      add(input: { sessionID: string; message: Message; parts: Part[] }) {
-        const items = optimistic.get(input.sessionID)
-        if (items) items.set(input.message.id, input)
-        if (!items) optimistic.set(input.sessionID, new Map([[input.message.id, input]]))
-        setData("message", input.sessionID, (messages = []) => merge(messages, [input.message]))
-        setData(
-          "part",
-          input.message.id,
-          input.parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id)),
-        )
-      },
-      remove(input: { sessionID: string; messageID: string }) {
-        clearOptimistic(input.sessionID, input.messageID)
-        setData("message", input.sessionID, (messages) => messages?.filter((message) => message.id !== input.messageID))
-        setData(
-          "part",
-          produce((draft) => void delete draft[input.messageID]),
-        )
-      },
-    },
-    diff(sessionID: string, options?: { force?: boolean }) {
-      touch(sessionID)
-      if (data.session_diff[sessionID] !== undefined && !options?.force) return Promise.resolve()
-      return runInflight(inflightDiff, sessionID, () => {
-        const generation = generations.get(sessionID) ?? 0
-        return retry(() => client.session.diff({ sessionID })).then((result) => {
-          if ((generations.get(sessionID) ?? 0) !== generation) return
-          setData("session_diff", sessionID, reconcile(cleanDiffs(result.data), { key: "file" }))
-        })
-      })
-    },
-    todo(sessionID: string, options?: { force?: boolean }) {
-      touch(sessionID)
-      if (data.todo[sessionID] !== undefined && !options?.force) return Promise.resolve()
-      return runInflight(inflightTodo, sessionID, () => {
-        const generation = generations.get(sessionID) ?? 0
-        return retry(() => client.session.todo({ sessionID })).then((result) => {
-          if ((generations.get(sessionID) ?? 0) !== generation) return
-          setData("todo", sessionID, reconcile(result.data ?? [], { key: "id" }))
-        })
-      })
-    },
-    history: {
-      more: (sessionID: string) =>
-        data.message[sessionID] !== undefined &&
-        meta.limit[sessionID] !== undefined &&
-        !meta.complete[sessionID] &&
-        !!meta.cursor[sessionID],
-      loading: (sessionID: string) => meta.loading[sessionID] ?? false,
-      async loadMore(sessionID: string, count = historyMessagePageSize) {
-        touch(sessionID)
-        if (meta.loading[sessionID] || meta.complete[sessionID] || !meta.cursor[sessionID]) return
-        await loadMessages(sessionID, count, meta.cursor[sessionID], "prepend")
-      },
-    },
-    evict(sessionID: string) {
-      if (protectedSessions().has(sessionID)) return
-      seen.delete(sessionID)
-      evict([sessionID])
-    },
-    pin(sessionID: string) {
-      pinned.set(sessionID, (pinned.get(sessionID) ?? 0) + 1)
-      touch(sessionID)
-    },
-    unpin(sessionID: string) {
-      const count = pinned.get(sessionID)
-      if (!count || count === 1) pinned.delete(sessionID)
-      if (count && count > 1) pinned.set(sessionID, count - 1)
-    },
-    apply,
-  }
-}
-
-export type ServerSession = ReturnType<typeof createServerSession>

packages/app/src/context/server-sync.tsx

@@ -1,4 +1,4 @@
-import type { Config, OpencodeClient, Path, Project, ProviderAuthResponse } from "@opencode-ai/sdk/v2/client"
+import type { Config, OpencodeClient, Path, Project, ProviderAuthResponse, Todo } from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@/utils/toast"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { type Accessor, batch, createMemo, getOwner, onCleanup, onMount, untrack } from "solid-js"
@@ -17,7 +17,8 @@ import {
   loadProvidersQuery,
 } from "./global-sync/bootstrap"
 import { createChildStoreManager } from "./global-sync/child-store"
-import { applyDirectoryEvent, applyGlobalEvent } from "./global-sync/event-reducer"
+import { applyDirectoryEvent, applyGlobalEvent, cleanupDroppedSessionCaches } from "./global-sync/event-reducer"
+import { clearSessionPrefetchDirectory } from "./global-sync/session-prefetch"
 import { estimateRootSessionTotal, loadRootSessionsWithFallback } from "./global-sync/session-load"
 import { trimSessions } from "./global-sync/session-trim"
 import type { ProjectMeta } from "./global-sync/types"
@@ -37,13 +38,15 @@ import { retry } from "@opencode-ai/core/util/retry"
 import type { ServerScope } from "@/utils/server-scope"
 import { persisted } from "@/utils/persist"
 import { toggleMcp } from "./global-sync/mcp"
-import { createServerSession } from "./server-session"
 
 type GlobalStore = {
   ready: boolean
   error?: InitError
   path: Path
   project: Project[]
+  session_todo: {
+    [sessionID: string]: Todo[]
+  }
   provider: NormalizedProviderListResponse
   provider_auth: ProviderAuthResponse
   config: Config
@@ -115,6 +118,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       return !bootstrap.isPending
     },
     project: [],
+    session_todo: {},
     provider_auth: {},
     get path() {
       const EMPTY = { state: "", config: "", worktree: "", directory: "", home: "" }
@@ -184,6 +188,20 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     return (setGlobalStore as (...args: unknown[]) => unknown)(...input)
   }) as typeof setGlobalStore
 
+  const setSessionTodo = (sessionID: string, todos: Todo[] | undefined) => {
+    if (!sessionID) return
+    if (!todos) {
+      setGlobalStore(
+        "session_todo",
+        produce((draft) => {
+          delete draft[sessionID]
+        }),
+      )
+      return
+    }
+    setGlobalStore("session_todo", sessionID, reconcile(todos, { key: "id" }))
+  }
+
   const paused = () => untrack(() => globalStore.reload) !== undefined
 
   const queue = createRefreshQueue({
@@ -193,8 +211,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     bootstrapInstance,
   })
 
-  const session = createServerSession(serverSDK.client)
-
   const children = createChildStoreManager({
     owner,
     scope: serverSDK.scope,
@@ -223,6 +239,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       sessionMeta.delete(key)
       sdkCache.delete(key)
       clearProviderRev(serverSDK.scope, key)
+      clearSessionPrefetchDirectory(serverSDK.scope, key)
     },
     translate: language.t,
     queryOptions: queryOptionsApi,
@@ -246,10 +263,11 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     if (meta && meta.limit >= retainedLimit) {
       const next = trimSessions(store.session, {
         limit: retainedLimit,
-        permission: session.data.permission,
+        permission: store.permission,
       })
       if (next.length !== store.session.length) {
         setStore("session", reconcile(next, { key: "id" }))
+        cleanupDroppedSessionCaches(store, setStore, next, setSessionTodo)
       }
       children.unpin(key)
       return
@@ -272,12 +290,11 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
                 .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
               const limit = Math.max(store.limit, options?.limit ?? 0, sessionMeta.get(key)?.limit ?? 0)
               const childSessions = store.session.filter((s) => !!s.parentID)
-              const next = trimSessions([...nonArchived, ...childSessions], {
+              const sessions = trimSessions([...nonArchived, ...childSessions], {
                 limit,
-                permission: session.data.permission,
+                permission: store.permission,
               })
               batch(() => {
-                next.forEach(session.remember)
                 setStore(
                   "sessionTotal",
                   estimateRootSessionTotal({
@@ -286,7 +303,8 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
                     limited: x.limited,
                   }),
                 )
-                setStore("session", reconcile(next, { key: "id" }))
+                setStore("session", reconcile(sessions, { key: "id" }))
+                cleanupDroppedSessionCaches(store, setStore, sessions, setSessionTodo)
               })
               sessionMeta.set(key, { limit })
             })
@@ -340,7 +358,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
         loadSessions,
         translate: language.t,
         queryClient,
-        session,
       })
     })
 
@@ -358,8 +375,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     const event = e.details
     const recent = bootingRoot || Date.now() - bootedAt < 1500
 
-    session.apply(event)
-
     if (directory === "global") {
       applyGlobalEvent({
         event,
@@ -389,9 +404,8 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       store,
       setStore,
       push: queue.push,
+      setSessionTodo,
       retainedLimit: sessionMeta.get(key)?.limit,
-      sessionContent: false,
-      permission: session.data.permission,
       vcsCache: children.vcsCache.get(key),
       loadLsp: () => {
         void queryClient.fetchQuery(queryOptionsApi.lsp(key))
@@ -465,7 +479,9 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     // bootstrap,
     updateConfig: updateConfigMutation.mutateAsync,
     project: projectApi,
-    session,
+    todo: {
+      set: setSessionTodo,
+    },
     mcp: {
       toggle: async (directory: string, name: string) => {
         const key = directoryKey(directory)

packages/app/src/context/settings.tsx

@@ -31,6 +31,7 @@ export interface Settings {
     showReasoningSummaries: boolean
     shellToolPartsExpanded: boolean
     editToolPartsExpanded: boolean
+    showSessionProgressBar: boolean
     showCustomAgents: boolean
     mobileTitlebarPosition: "top" | "bottom"
     newLayoutDesigns?: boolean
@@ -116,6 +117,7 @@ const defaultSettings: Settings = {
     showReasoningSummaries: false,
     shellToolPartsExpanded: false,
     editToolPartsExpanded: false,
+    showSessionProgressBar: true,
     showCustomAgents: false,
     mobileTitlebarPosition: "top",
   },
@@ -237,6 +239,13 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
         setEditToolPartsExpanded(value: boolean) {
           setStore("general", "editToolPartsExpanded", value)
         },
+        showSessionProgressBar: withFallback(
+          () => store.general?.showSessionProgressBar,
+          defaultSettings.general.showSessionProgressBar,
+        ),
+        setShowSessionProgressBar(value: boolean) {
+          setStore("general", "showSessionProgressBar", value)
+        },
         showCustomAgents,
         setShowCustomAgents(value: boolean) {
           setStore("general", "showCustomAgents", value)

packages/app/src/context/tabs.tsx

@@ -125,16 +125,6 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
         )
         return next
       },
-      reorder(keys: string[]) {
-        setStore(
-          produce((tabs) => {
-            const byKey = new Map(tabs.map((tab) => [tabKey(tab), tab]))
-            const next = keys.map((key) => byKey.get(key)).filter((tab): tab is Tab => !!tab)
-            if (next.length !== tabs.length) return
-            tabs.splice(0, tabs.length, ...next)
-          }),
-        )
-      },
       draft(draftID: string) {
         const tab = store.find((item) => item.type === "draft" && item.draftID === draftID)
         if (!tab || tab.type !== "draft") throw new Error(`Draft not found: ${draftID}`)

packages/app/src/hooks/provider-catalog.test.ts

@@ -1,59 +0,0 @@
-import { expect, test } from "bun:test"
-import type { NormalizedProviderListResponse } from "@opencode-ai/session-ui/context"
-import { selectProviderCatalog } from "./provider-catalog"
-
-const catalog = (id: string): NormalizedProviderListResponse => ({
-  all: new Map([[id, { id, name: id, source: "api", env: [], options: {}, models: {} }]]),
-  connected: [id],
-  default: { [id]: `${id}-model` },
-})
-
-test("selects the ready catalog for an explicit directory", () => {
-  const directory = catalog("directory")
-
-  expect(
-    selectProviderCatalog({
-      explicit: true,
-      directory: "/repo",
-      catalog: { ready: true, providers: directory },
-    }),
-  ).toBe(directory)
-})
-
-test("returns an empty catalog while an explicit directory is unresolved", () => {
-  expect(selectProviderCatalog({ explicit: true })).toEqual({ all: new Map(), connected: [], default: {} })
-  expect(
-    selectProviderCatalog({
-      explicit: true,
-      directory: "/repo",
-      catalog: { ready: false, providers: catalog("directory") },
-    }),
-  ).toEqual({ all: new Map(), connected: [], default: {} })
-})
-
-test("uses the route catalog when it is ready", () => {
-  const directory = catalog("directory")
-
-  expect(
-    selectProviderCatalog({
-      explicit: false,
-      directory: "/repo",
-      catalog: { ready: true, providers: directory },
-      global: catalog("global"),
-    }),
-  ).toBe(directory)
-})
-
-test("falls back to the global catalog for route consumers", () => {
-  const global = catalog("global")
-
-  expect(selectProviderCatalog({ explicit: false, global })).toBe(global)
-  expect(
-    selectProviderCatalog({
-      explicit: false,
-      directory: "/repo",
-      catalog: { ready: false, providers: catalog("directory") },
-      global,
-    }),
-  ).toBe(global)
-})

packages/app/src/hooks/provider-catalog.ts

@@ -1,27 +0,0 @@
-import type { NormalizedProviderListResponse } from "@opencode-ai/session-ui/context"
-
-const emptyProviderCatalog: NormalizedProviderListResponse = { all: new Map(), connected: [], default: {} }
-
-type DirectoryCatalog = {
-  ready: boolean
-  providers: NormalizedProviderListResponse
-}
-
-type ProviderCatalogInput =
-  | {
-      explicit: true
-      directory?: string
-      catalog?: DirectoryCatalog
-    }
-  | {
-      explicit: false
-      directory?: string
-      catalog?: DirectoryCatalog
-      global: NormalizedProviderListResponse
-    }
-
-export function selectProviderCatalog(input: ProviderCatalogInput) {
-  if (input.directory && input.catalog?.ready) return input.catalog.providers
-  if (input.explicit) return emptyProviderCatalog
-  return input.global
-}

packages/app/src/hooks/use-providers.ts

@@ -2,8 +2,7 @@ import { useServerSync } from "@/context/server-sync"
 import { decode64 } from "@/utils/base64"
 import { useParams } from "@solidjs/router"
 import { Iterable, pipe } from "effect"
-import type { Accessor } from "solid-js"
-import { selectProviderCatalog } from "./provider-catalog"
+import { createMemo } from "solid-js"
 
 export const popularProviders = [
   "opencode",
@@ -17,25 +16,16 @@ export const popularProviders = [
 ]
 const popularProviderSet = new Set(popularProviders)
 
-export function useProviders(directory?: Accessor<string | undefined>) {
+export function useProviders() {
   const serverSync = useServerSync()
   const params = useParams()
-  const dir = () => (directory ? directory() : decode64(params.dir))
+  const dir = createMemo(() => decode64(params.dir) ?? "")
   const providers = () => {
-    const value = dir()
-    const projectStore = value ? serverSync().child(value)[0] : undefined
-    if (directory)
-      return selectProviderCatalog({
-        explicit: true,
-        directory: value,
-        catalog: projectStore && { ready: projectStore.provider_ready, providers: projectStore.provider },
-      })
-    return selectProviderCatalog({
-      explicit: false,
-      directory: value,
-      catalog: projectStore && { ready: projectStore.provider_ready, providers: projectStore.provider },
-      global: serverSync().data.provider,
-    })
+    if (dir()) {
+      const [projectStore] = serverSync().child(dir())
+      if (projectStore.provider_ready) return projectStore.provider
+    }
+    return serverSync().data.provider
   }
   return {
     all: () => providers().all,

packages/app/src/i18n/ar.ts

@@ -590,6 +590,8 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "توسيع أجزاء أداة edit",
   "settings.general.row.editToolPartsExpanded.description":
     "إظهار أجزاء أدوات edit و write و patch موسعة بشكل افتراضي في الشريط الزمني",
+  "settings.general.row.showSessionProgressBar.title": "إظهار شريط تقدم الجلسة",
+  "settings.general.row.showSessionProgressBar.description": "عرض شريط التقدم المتحرك أعلى الجلسة أثناء عمل الوكيل",
   "settings.general.row.wayland.title": "استخدام Wayland الأصلي",
   "settings.general.row.wayland.description": "تعطيل التراجع إلى X11 على Wayland. يتطلب إعادة التشغيل.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/br.ts

@@ -598,6 +598,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Expandir partes da ferramenta de edição",
   "settings.general.row.editToolPartsExpanded.description":
     "Mostrar partes das ferramentas de edição, escrita e patch expandidas por padrão na linha do tempo",
+  "settings.general.row.showSessionProgressBar.title": "Mostrar barra de progresso da sessão",
+  "settings.general.row.showSessionProgressBar.description":
+    "Exibir a barra de progresso animada no topo da sessão quando o agente estiver trabalhando",
   "settings.general.row.wayland.title": "Usar Wayland nativo",
   "settings.general.row.wayland.description": "Desabilitar fallback X11 no Wayland. Requer reinicialização.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/bs.ts

@@ -663,6 +663,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Proširi dijelove alata za uređivanje",
   "settings.general.row.editToolPartsExpanded.description":
     "Prikaži dijelove alata za uređivanje, pisanje i patch podrazumijevano proširene na vremenskoj traci",
+  "settings.general.row.showSessionProgressBar.title": "Prikaži traku napretka sesije",
+  "settings.general.row.showSessionProgressBar.description":
+    "Prikaži animiranu traku napretka na vrhu sesije kada agent radi",
   "settings.general.row.wayland.title": "Koristi nativni Wayland",
   "settings.general.row.wayland.description": "Onemogući X11 fallback na Waylandu. Zahtijeva restart.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/da.ts

@@ -657,6 +657,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Udvid edit-værktøjsdele",
   "settings.general.row.editToolPartsExpanded.description":
     "Vis edit-, write- og patch-værktøjsdele udvidet som standard i tidslinjen",
+  "settings.general.row.showSessionProgressBar.title": "Vis sessionens fremdriftslinje",
+  "settings.general.row.showSessionProgressBar.description":
+    "Vis den animerede fremdriftslinje øverst i sessionen, når agenten arbejder",
   "settings.general.row.wayland.title": "Brug native Wayland",
   "settings.general.row.wayland.description": "Deaktiver X11-fallback på Wayland. Kræver genstart.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/de.ts

@@ -609,6 +609,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Edit-Tool-Abschnitte ausklappen",
   "settings.general.row.editToolPartsExpanded.description":
     "Edit-, Write- und Patch-Tool-Abschnitte standardmäßig in der Timeline ausgeklappt anzeigen",
+  "settings.general.row.showSessionProgressBar.title": "Sitzungsfortschrittsleiste anzeigen",
+  "settings.general.row.showSessionProgressBar.description":
+    "Die animierte Fortschrittsleiste oben in der Sitzung anzeigen, wenn der Agent arbeitet",
   "settings.general.row.wayland.title": "Natives Wayland verwenden",
   "settings.general.row.wayland.description": "X11-Fallback unter Wayland deaktivieren. Erfordert Neustart.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/en.ts

@@ -854,6 +854,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Expand edit tool parts",
   "settings.general.row.editToolPartsExpanded.description":
     "Show edit, write, and patch tool parts expanded by default in the timeline",
+  "settings.general.row.showSessionProgressBar.title": "Show session progress bar",
+  "settings.general.row.showSessionProgressBar.description":
+    "Display the animated progress bar at the top of the session when the agent is working",
   "settings.general.row.newLayoutDesigns.title": "New layout and designs",
   "settings.general.row.newLayoutDesigns.description": "Enable the redesigned layout, home, composer, and session UI",
   "settings.general.row.pinchZoom.title": "Pinch to zoom",

packages/app/src/i18n/es.ts

@@ -667,6 +667,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Expandir partes de la herramienta de edición",
   "settings.general.row.editToolPartsExpanded.description":
     "Mostrar las partes de las herramientas de edición, escritura y parcheado expandidas por defecto en la línea de tiempo",
+  "settings.general.row.showSessionProgressBar.title": "Mostrar barra de progreso de la sesión",
+  "settings.general.row.showSessionProgressBar.description":
+    "Mostrar la barra de progreso animada en la parte superior de la sesión cuando el agente esté trabajando",
   "settings.general.row.wayland.title": "Usar Wayland nativo",
   "settings.general.row.wayland.description": "Deshabilitar fallback a X11 en Wayland. Requiere reinicio.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/fr.ts

@@ -606,6 +606,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Développer les parties de l'outil edit",
   "settings.general.row.editToolPartsExpanded.description":
     "Afficher les parties des outils edit, write et patch développées par défaut dans la chronologie",
+  "settings.general.row.showSessionProgressBar.title": "Afficher la barre de progression de la session",
+  "settings.general.row.showSessionProgressBar.description":
+    "Afficher la barre de progression animée en haut de la session lorsque l'agent travaille",
   "settings.general.row.wayland.title": "Utiliser Wayland natif",
   "settings.general.row.wayland.description": "Désactiver le repli X11 sur Wayland. Nécessite un redémarrage.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/ja.ts

@@ -595,6 +595,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "edit ツールパーツを展開",
   "settings.general.row.editToolPartsExpanded.description":
     "タイムラインで edit、write、patch ツールパーツをデフォルトで展開して表示します",
+  "settings.general.row.showSessionProgressBar.title": "セッション進行状況バーを表示",
+  "settings.general.row.showSessionProgressBar.description":
+    "エージェントの作業中に、セッション上部にアニメーション付きの進行状況バーを表示します",
   "settings.general.row.wayland.title": "ネイティブWaylandを使用",
   "settings.general.row.wayland.description": "WaylandでのX11フォールバックを無効にします。再起動が必要です。",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/ko.ts

@@ -591,6 +591,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "edit 도구 파트 펼치기",
   "settings.general.row.editToolPartsExpanded.description":
     "타임라인에서 기본적으로 edit, write, patch 도구 파트를 펼친 상태로 표시합니다",
+  "settings.general.row.showSessionProgressBar.title": "세션 진행 표시줄 표시",
+  "settings.general.row.showSessionProgressBar.description":
+    "에이전트가 작업 중일 때 세션 상단에 애니메이션 진행 표시줄을 표시합니다",
   "settings.general.row.wayland.title": "네이티브 Wayland 사용",
   "settings.general.row.wayland.description": "Wayland에서 X11 폴백을 비활성화합니다. 다시 시작해야 합니다.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/no.ts

@@ -664,6 +664,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Utvid edit-verktøydeler",
   "settings.general.row.editToolPartsExpanded.description":
     "Vis edit-, write- og patch-verktøydeler utvidet som standard i tidslinjen",
+  "settings.general.row.showSessionProgressBar.title": "Vis fremdriftslinje for sesjonen",
+  "settings.general.row.showSessionProgressBar.description":
+    "Vis den animerte fremdriftslinjen øverst i sesjonen når agenten jobber",
   "settings.general.row.wayland.title": "Bruk innebygd Wayland",
   "settings.general.row.wayland.description": "Deaktiver X11-fallback på Wayland. Krever omstart.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/pl.ts

@@ -596,6 +596,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Rozwijaj elementy narzędzia edit",
   "settings.general.row.editToolPartsExpanded.description":
     "Domyślnie pokazuj rozwinięte elementy narzędzi edit, write i patch na osi czasu",
+  "settings.general.row.showSessionProgressBar.title": "Pokazuj pasek postępu sesji",
+  "settings.general.row.showSessionProgressBar.description":
+    "Wyświetlaj animowany pasek postępu u góry sesji, gdy agent pracuje",
   "settings.general.row.wayland.title": "Użyj natywnego Wayland",
   "settings.general.row.wayland.description": "Wyłącz fallback X11 na Wayland. Wymaga restartu.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/ru.ts

@@ -664,6 +664,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Разворачивать элементы инструмента edit",
   "settings.general.row.editToolPartsExpanded.description":
     "Показывать элементы инструментов edit, write и patch в ленте развернутыми по умолчанию",
+  "settings.general.row.showSessionProgressBar.title": "Показывать индикатор прогресса сессии",
+  "settings.general.row.showSessionProgressBar.description":
+    "Показывать анимированный индикатор прогресса вверху сессии, когда агент работает",
   "settings.general.row.wayland.title": "Использовать нативный Wayland",
   "settings.general.row.wayland.description": "Отключить X11 fallback на Wayland. Требуется перезапуск.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/th.ts

@@ -655,6 +655,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "ขยายส่วนเครื่องมือ edit",
   "settings.general.row.editToolPartsExpanded.description":
     "แสดงส่วนเครื่องมือ edit, write และ patch แบบขยายตามค่าเริ่มต้นในไทม์ไลน์",
+  "settings.general.row.showSessionProgressBar.title": "แสดงแถบความคืบหน้าของเซสชัน",
+  "settings.general.row.showSessionProgressBar.description":
+    "แสดงแถบความคืบหน้าแบบเคลื่อนไหวที่ด้านบนของเซสชันเมื่อเอเจนต์กำลังทำงาน",
   "settings.general.row.wayland.title": "ใช้ Wayland แบบเนทีฟ",
   "settings.general.row.wayland.description": "ปิดใช้งาน X11 fallback บน Wayland ต้องรีสตาร์ท",
   "settings.general.row.wayland.tooltip": "บน Linux ที่มีจอภาพรีเฟรชเรตแบบผสม Wayland แบบเนทีฟอาจเสถียรกว่า",

packages/app/src/i18n/tr.ts

@@ -671,6 +671,10 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.description":
     "Zaman çizelgesinde düzenleme, yazma ve yama araç bileşenlerini varsayılan olarak genişletilmiş göster",
 
+  "settings.general.row.showSessionProgressBar.title": "Oturum ilerleme çubuğunu göster",
+  "settings.general.row.showSessionProgressBar.description":
+    "Ajan çalışırken oturumun üst kısmında animasyonlu ilerleme çubuğunu göster",
+
   "settings.general.row.wayland.title": "Yerel Wayland kullan",
   "settings.general.row.wayland.description":
     "Wayland'da X11 geri dönüşünü devre dışı bırak. Yeniden başlatma gerektirir.",

packages/app/src/i18n/uk.ts

@@ -781,6 +781,9 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Розгортати частини інструменту редагування",
   "settings.general.row.editToolPartsExpanded.description":
     "Показувати частини інструментів редагування, запису та патчів розгорнутими за замовчуванням на часовій шкалі",
+  "settings.general.row.showSessionProgressBar.title": "Показувати індикатор прогресу сесії",
+  "settings.general.row.showSessionProgressBar.description":
+    "Відображати анімований індикатор прогресу вгорі сесії, коли агент працює",
 
   "settings.general.row.wayland.title": "Використовувати нативний Wayland",
   "settings.general.row.wayland.description": "Вимкнути резервний X11 на Wayland. Потребує перезапуску.",

packages/app/src/i18n/zh.ts

@@ -664,6 +664,8 @@ export const dict = {
   "settings.general.row.shellToolPartsExpanded.description": "默认在时间线中展开 shell 工具部分",
   "settings.general.row.editToolPartsExpanded.title": "展开编辑工具部分",
   "settings.general.row.editToolPartsExpanded.description": "默认在时间线中展开 edit、write 和 patch 工具部分",
+  "settings.general.row.showSessionProgressBar.title": "显示会话进度条",
+  "settings.general.row.showSessionProgressBar.description": "当智能体正在工作时，在会话顶部显示动画进度条",
   "settings.general.row.wayland.title": "使用原生 Wayland",
   "settings.general.row.wayland.description": "在 Wayland 上禁用 X11 回退。需要重启。",
   "settings.general.row.wayland.tooltip": "在混合刷新率显示器的 Linux 系统上，原生 Wayland 可能更稳定。",

packages/app/src/i18n/zht.ts

@@ -650,6 +650,8 @@ export const dict = {
   "settings.general.row.shellToolPartsExpanded.description": "在時間軸中預設展開 shell 工具區塊",
   "settings.general.row.editToolPartsExpanded.title": "展開 edit 工具區塊",
   "settings.general.row.editToolPartsExpanded.description": "在時間軸中預設展開 edit、write 和 patch 工具區塊",
+  "settings.general.row.showSessionProgressBar.title": "顯示工作階段進度列",
+  "settings.general.row.showSessionProgressBar.description": "當代理程式正在運作時，在工作階段頂部顯示動畫進度列",
   "settings.general.row.wayland.title": "使用原生 Wayland",
   "settings.general.row.wayland.description": "在 Wayland 上停用 X11 後備模式。需要重新啟動。",
   "settings.general.row.wayland.tooltip": "在混合更新率螢幕的 Linux 系統上，原生 Wayland 可能更穩定。",

packages/app/src/index.css

@@ -24,6 +24,44 @@
 }
 
 @layer components {
+  @keyframes session-progress-whip {
+    0% {
+      clip-path: inset(0 100% 0 0 round 999px);
+      animation-timing-function: cubic-bezier(0.2, 0.8, 0.2, 1);
+    }
+
+    48% {
+      clip-path: inset(0 0 0 0 round 999px);
+      animation-timing-function: cubic-bezier(0.65, 0, 0.35, 1);
+    }
+
+    100% {
+      clip-path: inset(0 0 0 100% round 999px);
+    }
+  }
+
+  [data-component="session-progress"] {
+    position: absolute;
+    inset: 0 0 auto;
+    height: 2px;
+    overflow: hidden;
+    pointer-events: none;
+    opacity: 1;
+    transition: opacity 220ms ease-out;
+  }
+
+  [data-component="session-progress"][data-state="hiding"] {
+    opacity: 0;
+  }
+
+  [data-component="session-progress-bar"] {
+    width: 100%;
+    height: 100%;
+    border-radius: 999px;
+    clip-path: inset(0 100% 0 0 round 999px);
+    will-change: clip-path;
+  }
+
   [data-component="getting-started"] {
     container-type: inline-size;
     container-name: getting-started;

packages/app/src/pages/directory-layout.tsx

@@ -2,7 +2,7 @@ import { DataProvider } from "@opencode-ai/session-ui/context"
 import { showToast } from "@/utils/toast"
 import { base64Encode } from "@opencode-ai/core/util/encode"
 import { useLocation, useNavigate, useParams } from "@solidjs/router"
-import { type Accessor, createEffect, createMemo, createResource, onCleanup, type ParentProps, Show } from "solid-js"
+import { type Accessor, createEffect, createMemo, createResource, type ParentProps, Show } from "solid-js"
 import { useLanguage } from "@/context/language"
 import { LocalProvider } from "@/context/local"
 import { SDKProvider } from "@/context/sdk"
@@ -11,7 +11,7 @@ import { decode64 } from "@/utils/base64"
 import { Schema } from "effect"
 import type { ServerConnection } from "@/context/server"
 import { sessionHref } from "@/utils/session-route"
-import { useServerSync } from "@/context/server-sync"
+import { useGlobal } from "@/context/global"
 
 export function DirectoryDataProvider(
   props: ParentProps<{
@@ -24,7 +24,7 @@ export function DirectoryDataProvider(
   const navigate = useNavigate()
   const params = useParams()
   const sync = useSync()
-  const serverSync = useServerSync()
+  const global = useGlobal()
   const directory = () => (typeof props.directory === "function" ? props.directory() : props.directory)
   const slug = createMemo(() => base64Encode(directory()))
   const href = (sessionID: string) => {
@@ -50,26 +50,19 @@ export function DirectoryDataProvider(
         .catch(() => {}),
   )
 
-  createEffect(() => {
-    const sessionID = params.id
-    if (!sessionID) return
-    serverSync().session.pin(sessionID)
-    onCleanup(() => serverSync().session.unpin(sessionID))
-  })
-
   return (
-    <Show when={directory()} keyed>
-      {(directory) => (
-        <DataProvider
-          data={sync().data}
-          directory={directory}
-          onNavigateToSession={(sessionID: string) => navigate(href(sessionID))}
-          onSessionHref={href}
-        >
-          <LocalProvider>{props.children}</LocalProvider>
-        </DataProvider>
-      )}
-    </Show>
+    <DataProvider
+      data={sync().data}
+      directory={directory()}
+      onNavigateToSession={(sessionID: string) => {
+        const server = props.server?.()
+        if (server && params.id) global.sessionPlacement.inherit(server, params.id, sessionID)
+        navigate(href(sessionID))
+      }}
+      onSessionHref={href}
+    >
+      <LocalProvider>{props.children}</LocalProvider>
+    </DataProvider>
   )
 }
 

packages/app/src/pages/home.tsx

@@ -220,9 +220,10 @@ export function NewHome() {
             void directory.session
               .sync(record.session.id)
               .then(() => {
+                const store = ctx.sync.child(record.session.directory)[0]
                 return Promise.all(
-                  (ctx.sync.session.data.message[record.session.id] ?? []).flatMap((message) =>
-                    (ctx.sync.session.data.part[message.id] ?? []).flatMap((part) => {
+                  (store.message[record.session.id] ?? []).flatMap((message) =>
+                    (store.part[message.id] ?? []).flatMap((part) => {
                       if (part.type !== "text" || !part.text) return []
                       return preloadMarkdown(part.text, part.id, marked)
                     }),
@@ -342,6 +343,12 @@ export function NewHome() {
     if (!conn) return
     const directory = project?.worktree ?? session.directory
     const ctx = global.ensureServerCtx(conn)
+    global.sessionPlacement.set({
+      server: ServerConnection.key(conn),
+      leafID: session.id,
+      rootID: session.id,
+      directory: session.directory,
+    })
     ctx.projects.open(directory)
     ctx.projects.touch(directory)
     startTransition(() => {

packages/app/src/pages/layout-new.tsx

@@ -18,7 +18,6 @@ export default function NewLayout(props: ParentProps) {
   createEffect(() => setV2Toast(true))
   createEffect(() => {
     if (!notification.ready() || !params.id) return
-    if (notification.session.unseenCount(params.id) === 0) return
     notification.session.markViewed(params.id)
   })
 

packages/app/src/pages/layout.tsx

@@ -1,4 +1,5 @@
 import {
+  batch,
   createEffect,
   createMemo,
   createResource,
@@ -25,7 +26,7 @@ import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { DropdownMenu } from "@opencode-ai/ui/dropdown-menu"
 import { Dialog } from "@opencode-ai/ui/dialog"
 import { getFilename } from "@opencode-ai/core/util/path"
-import { Session } from "@opencode-ai/sdk/v2/client"
+import { Session, type Message } from "@opencode-ai/sdk/v2/client"
 import { usePlatform } from "@/context/platform"
 import { useSettings } from "@/context/settings"
 import { createStore, produce, reconcile } from "solid-js/store"
@@ -36,7 +37,16 @@ import { toaster } from "@opencode-ai/ui/toast"
 import { setV2Toast, showToast, ToastRegion } from "@/utils/toast"
 import { useServerSDK } from "@/context/server-sdk"
 import { clearWorkspaceTerminals } from "@/context/terminal"
-import { pickSessionCacheEvictions } from "@/context/global-sync/session-cache"
+import { dropSessionCaches, pickSessionCacheEvictions } from "@/context/global-sync/session-cache"
+import {
+  clearSessionPrefetchInflight,
+  clearSessionPrefetch,
+  getSessionPrefetch,
+  isSessionPrefetchCurrent,
+  runSessionPrefetch,
+  setSessionPrefetch,
+  shouldSkipSessionPrefetch,
+} from "@/context/global-sync/session-prefetch"
 import { useNotification } from "@/context/notification"
 import { usePermission } from "@/context/permission"
 import { Binary } from "@opencode-ai/core/util/binary"
@@ -674,6 +684,7 @@ export default function LegacyLayout(props: ParentProps) {
     serverSDK().url
 
     prefetchToken.value += 1
+    clearSessionPrefetchInflight(serverSDK().scope)
     prefetchQueues.clear()
   })
 
@@ -701,12 +712,88 @@ export default function LegacyLayout(props: ParentProps) {
     return created
   }
 
+  const mergeByID = <T extends { id: string }>(current: T[], incoming: T[]) => {
+    if (current.length === 0) {
+      return incoming.slice().sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+    }
+
+    const map = new Map<string, T>()
+    for (const item of current) {
+      map.set(item.id, item)
+    }
+    for (const item of incoming) {
+      map.set(item.id, item)
+    }
+    return [...map.values()].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+  }
+
   async function prefetchMessages(directory: string, sessionID: string, token: number) {
-    await serverSync()
-      .session.prefetch(sessionID, prefetchChunk)
-      .catch(() => {})
-    if (prefetchToken.value !== token) return
-    for (const stale of markPrefetched(directory, sessionID)) serverSync().session.evict(stale)
+    const [store, setStore] = serverSync().child(directory, { bootstrap: false })
+
+    return runSessionPrefetch({
+      scope: serverSDK().scope,
+      directory,
+      sessionID,
+      task: (rev) =>
+        retry(() => serverSDK().client.session.messages({ directory, sessionID, limit: prefetchChunk }))
+          .then((messages) => {
+            if (prefetchToken.value !== token) return
+            if (!isSessionPrefetchCurrent(serverSDK().scope, directory, sessionID, rev)) return
+
+            const items = (messages.data ?? []).filter((x) => !!x?.info?.id)
+            const next = items.map((x) => x.info).filter((m): m is Message => !!m?.id)
+            const sorted = mergeByID([], next)
+            const stale = markPrefetched(directory, sessionID)
+            const cursor = messages.response.headers.get("x-next-cursor") ?? undefined
+            const meta = {
+              limit: sorted.length,
+              cursor,
+              complete: !cursor,
+              at: Date.now(),
+            }
+
+            if (stale.length > 0) {
+              clearSessionPrefetch(serverSDK().scope, directory, stale)
+              for (const id of stale) {
+                serverSync().todo.set(id, undefined)
+              }
+            }
+
+            const current = store.message[sessionID] ?? []
+            const merged = mergeByID(
+              current.filter((item): item is Message => !!item?.id),
+              sorted,
+            )
+
+            if (!isSessionPrefetchCurrent(serverSDK().scope, directory, sessionID, rev)) return
+
+            batch(() => {
+              if (stale.length > 0) {
+                setStore(
+                  produce((draft) => {
+                    dropSessionCaches(draft, stale)
+                  }),
+                )
+              }
+
+              setStore("message", sessionID, reconcile(merged, { key: "id" }))
+              setSessionPrefetch({ scope: serverSDK().scope, directory, sessionID, ...meta })
+
+              for (const message of items) {
+                const currentParts = store.part[message.info.id] ?? []
+                const mergedParts = mergeByID(
+                  currentParts.filter((item): item is (typeof currentParts)[number] & { id: string } => !!item?.id),
+                  message.parts.filter((item): item is (typeof message.parts)[number] & { id: string } => !!item?.id),
+                )
+
+                setStore("part", message.info.id, reconcile(mergedParts, { key: "id" }))
+              }
+            })
+
+            return meta
+          })
+          .catch(() => undefined),
+    })
   }
 
   const pumpPrefetch = (directory: string) => {
@@ -733,7 +820,15 @@ export default function LegacyLayout(props: ParentProps) {
     const directory = session.directory
     if (!directory) return
 
-    const cached = untrack(() => !serverSync().session.shouldPrefetch(session.id, prefetchChunk))
+    const [store] = serverSync().child(directory, { bootstrap: false })
+    const cached = untrack(() => {
+      const info = getSessionPrefetch(serverSDK().scope, directory, session.id)
+      return shouldSkipSessionPrefetch({
+        message: store.message[session.id] !== undefined,
+        info,
+        chunk: prefetchChunk,
+      })
+    })
     if (cached) return
 
     const q = queueFor(directory)

packages/app/src/pages/layout/project-avatar-state.ts

@@ -15,7 +15,7 @@ export function useSessionTabAvatarState(
   const hasPermissions = createMemo(() => {
     if (!active()) return false
     const [store] = globalSync().child(directory(), { bootstrap: false })
-    return !!sessionPermissionRequest(store.session, globalSync().session.data.permission, sessionId(), (item) => {
+    return !!sessionPermissionRequest(store.session, store.permission, sessionId(), (item) => {
       return !permission.autoResponds(item, directory())
     })
   })
@@ -23,7 +23,8 @@ export function useSessionTabAvatarState(
   const loading = createMemo(() => {
     if (!active()) return false
     if (hasPermissions()) return false
-    return globalSync().session.data.session_working(sessionId())
+    const [store] = globalSync().child(directory(), { bootstrap: false })
+    return store.session_working(sessionId())
   })
   return { unread, loading }
 }

packages/app/src/pages/layout/sidebar-items.tsx

@@ -33,10 +33,8 @@ export const ProjectIcon = (props: {
   const hasError = createMemo(() => dirs().some((directory) => notification.project.unseenHasError(directory)))
   const hasPermissions = createMemo(() =>
     dirs().some((directory) => {
-      return hasProjectPermissions(serverSync().session.data.permission, (item) => {
-        if (serverSync().session.get(item.sessionID)?.directory !== directory) return false
-        return !permission.autoResponds(item, directory)
-      })
+      const [store] = serverSync().child(directory, { bootstrap: false })
+      return hasProjectPermissions(store.permission, (item) => !permission.autoResponds(item, directory))
     }),
   )
   const notify = createMemo(() => props.notify && (hasPermissions() || unseenCount() > 0))
@@ -153,23 +151,16 @@ export const SessionItem = (props: SessionItemProps): JSX.Element => {
   const hasError = createMemo(() => notification.session.unseenHasError(props.session.id))
   const [sessionStore] = serverSync().child(props.session.directory)
   const hasPermissions = createMemo(() => {
-    return !!sessionPermissionRequest(
-      sessionStore.session,
-      serverSync().session.data.permission,
-      props.session.id,
-      (item) => {
-        return !permission.autoResponds(item, props.session.directory)
-      },
-    )
+    return !!sessionPermissionRequest(sessionStore.session, sessionStore.permission, props.session.id, (item) => {
+      return !permission.autoResponds(item, props.session.directory)
+    })
   })
   const isWorking = createMemo(() => {
     if (hasPermissions()) return false
-    return serverSync().session.data.session_working(props.session.id)
+    return sessionStore.session_working(props.session.id)
   })
 
-  const tint = createMemo(() =>
-    messageAgentColor(serverSync().session.data.message[props.session.id], sessionStore.agent),
-  )
+  const tint = createMemo(() => messageAgentColor(sessionStore.message[props.session.id], sessionStore.agent))
   const tooltip = createMemo(() => props.showTooltip ?? (props.mobile || !props.sidebarExpanded()))
   const currentChild = createMemo(() => {
     if (!props.showChild) return

packages/app/src/pages/layout/sidebar-project.tsx

@@ -304,10 +304,8 @@ export const SortableProject = (props: {
   const projectStore = createMemo(() => serverSync().child(props.project.worktree, { bootstrap: false })[0])
   const isWorking = createMemo(() =>
     dirs().some((directory) => {
-      return Object.keys(serverSync().session.data.session_status).some((id) => {
-        if (serverSync().session.get(id)?.directory !== directory) return false
-        return serverSync().session.data.session_working(id)
-      })
+      const [store] = serverSync().child(directory, { bootstrap: false })
+      return Object.keys(store.session_status).some((id) => store.session_working(id))
     }),
   )
   const projectSessions = createMemo(() => sortedRootSessions(projectStore(), props.sortNow()))

packages/app/src/pages/new-session.tsx

@@ -6,13 +6,7 @@ import { useComments } from "@/context/comments"
 import { usePrompt } from "@/context/prompt"
 import { useSDK } from "@/context/sdk"
 import { useSync } from "@/context/sync"
-import { useServerSync } from "@/context/server-sync"
-import {
-  createSessionComposerControls,
-  createSessionComposerState,
-  SessionComposerRegion,
-} from "@/pages/session/composer"
-import { useSessionKey } from "@/pages/session/session-layout"
+import { createSessionComposerState, SessionComposerRegion } from "@/pages/session/composer"
 
 /**
  * The `/new-session` draft page. Unlike `session.tsx`, this only renders the prompt
@@ -23,19 +17,12 @@ export default function NewSessionPage() {
   const prompt = usePrompt()
   const sdk = useSDK()
   const sync = useSync()
-  const serverSync = useServerSync()
   const comments = useComments()
-  const route = useSessionKey()
   const [searchParams, setSearchParams] = useSearchParams<{ prompt?: string }>()
 
   let inputRef: HTMLDivElement | undefined
 
   const composer = createSessionComposerState()
-  const composerControls = createSessionComposerControls({
-    sessionKey: route.sessionKey,
-    sessionID: () => route.params.id,
-    queryOptions: serverSync().queryOptions,
-  })
 
   const [store, setStore] = createStore({
     worktree: "main",
@@ -70,21 +57,15 @@ export default function NewSessionPage() {
             <NewSessionDesignView>
               <SessionComposerRegion
                 state={composer}
-                sessionKey={route.sessionKey()}
-                sessionID={route.params.id}
-                controls={composerControls()}
-                promptInput={{
-                  ref: (el) => {
-                    inputRef = el
-                  },
-                  newSessionWorktree: newSessionWorktree(),
-                  onNewSessionWorktreeReset: () => setStore("worktree", "main"),
-                  onSubmit: () => comments.clear(),
-                }}
-                todo={{ collapsed: false, onToggle: () => {} }}
                 ready
                 centered={false}
                 placement="inline"
+                inputRef={(el) => {
+                  inputRef = el
+                }}
+                newSessionWorktree={newSessionWorktree()}
+                onNewSessionWorktreeReset={() => setStore("worktree", "main")}
+                onSubmit={() => comments.clear()}
                 onResponseSubmit={() => {}}
                 setPromptDockRef={() => {}}
               />

packages/app/src/pages/session.tsx

@@ -29,7 +29,7 @@ import { previewSelectedLines } from "@opencode-ai/session-ui/pierre/selection-b
 import { Button } from "@opencode-ai/ui/button"
 import { showToast } from "@/utils/toast"
 import { base64Encode, checksum } from "@opencode-ai/core/util/encode"
-import { useLocation, useNavigate, useSearchParams } from "@solidjs/router"
+import { useLocation, useSearchParams } from "@solidjs/router"
 import { NewSessionView, SessionHeader } from "@/components/session"
 import { useComments } from "@/context/comments"
 import { useServerSync } from "@/context/server-sync"
@@ -43,11 +43,7 @@ import { useSettings } from "@/context/settings"
 import { useSync } from "@/context/sync"
 import { useTerminal } from "@/context/terminal"
 import { type FollowupDraft, sendFollowupDraft } from "@/components/prompt-input/submit"
-import {
-  createSessionComposerControls,
-  createSessionComposerState,
-  SessionComposerRegion,
-} from "@/pages/session/composer"
+import { createSessionComposerState, SessionComposerRegion } from "@/pages/session/composer"
 import {
   createOpenReviewFile,
   createSessionTabs,
@@ -70,9 +66,7 @@ import { diffs as list } from "@/utils/diffs"
 import { Persist, persisted } from "@/utils/persist"
 import { extractPromptFromParts } from "@/utils/prompt"
 import { formatServerError } from "@/utils/server-errors"
-import { legacySessionHref, requireServerKey, sessionHref } from "@/utils/session-route"
 import { useUsageExceededDialogs } from "./session/usage-exceeded-dialogs"
-import { createSessionOwnership } from "./session/session-ownership"
 
 type FollowupItem = FollowupDraft & { id: string }
 type FollowupEdit = Pick<FollowupItem, "id" | "prompt" | "context">
@@ -81,35 +75,6 @@ const emptyFollowups: FollowupItem[] = []
 type ChangeMode = "git" | "branch" | "turn"
 type VcsMode = "git" | "branch"
 
-const sessionViewState = () => ({
-  messageId: undefined as string | undefined,
-  mobileTab: "session" as "session" | "changes",
-  changes: "git" as ChangeMode,
-})
-
-async function runPromptRollbackMutation<T, R>(input: {
-  capturePrompt: () => { current: () => T[]; set: (value: T[]) => void; reset: () => void }
-  optimistic: (prompt: { set: (value: T[]) => void; reset: () => void }) => void
-  request: () => Promise<R>
-  complete: (result: R) => void
-  rollback: () => void
-  fail: (error: unknown) => void
-}) {
-  const prompt = input.capturePrompt()
-  const previous = prompt.current().slice()
-  batch(() => input.optimistic(prompt))
-  await input
-    .request()
-    .then(input.complete)
-    .catch((error) => {
-      batch(() => {
-        input.rollback()
-        prompt.set(previous)
-      })
-      input.fail(error)
-    })
-}
-
 export default function Page() {
   const serverSync = useServerSync()
   const layout = useLayout()
@@ -128,9 +93,7 @@ export default function Page() {
   const terminal = useTerminal()
   const [searchParams, setSearchParams] = useSearchParams<{ prompt?: string }>()
   const location = useLocation()
-  const navigate = useNavigate()
   const { params, sessionKey, workspaceKey, tabs, view } = useSessionLayout()
-  const sessionOwnership = createSessionOwnership(sessionKey)
   const newSessionDesign = createMemo(() => settings.general.newLayoutDesigns())
 
   createEffect(() => {
@@ -156,11 +119,6 @@ export default function Page() {
   })
 
   const composer = createSessionComposerState()
-  const composerControls = createSessionComposerControls({
-    sessionKey,
-    sessionID: () => params.id,
-    queryOptions: serverSync().queryOptions,
-  })
 
   const workspaceTabs = createMemo(() => layout.tabs(workspaceKey))
 
@@ -298,7 +256,9 @@ export default function Page() {
   )
 
   const [store, setStore] = createStore({
-    ...sessionViewState(),
+    messageId: undefined as string | undefined,
+    mobileTab: "session" as "session" | "changes",
+    changes: "git" as ChangeMode,
     newSessionWorktree: "main",
     deferRender: false,
   })
@@ -322,9 +282,8 @@ export default function Page() {
     const key = sessionKey()
     if (key !== prev) {
       setStore("deferRender", true)
-      const owner = sessionOwnership.capture()
       requestAnimationFrame(() => {
-        setTimeout(() => owner.run(() => setStore("deferRender", false)), 0)
+        setTimeout(() => setStore("deferRender", false), 0)
       })
     }
     return key
@@ -557,7 +516,9 @@ export default function Page() {
         todoTimer = undefined
         if (!id) return
         if (status === "idle" && !blocked) return
-        const cached = untrack(() => sync().data.todo[id] !== undefined)
+        const cached = untrack(
+          () => sync().data.todo[id] !== undefined || serverSync().data.session_todo[id] !== undefined,
+        )
 
         todoFrame = requestAnimationFrame(() => {
           todoFrame = undefined
@@ -590,7 +551,8 @@ export default function Page() {
     on(
       sessionKey,
       () => {
-        setStore(sessionViewState())
+        setStore("messageId", undefined)
+        setStore("changes", "git")
         setUi("pendingMessage", undefined)
       },
       { defer: true },
@@ -1167,37 +1129,27 @@ export default function Page() {
 
   let captureHistoryAnchor = () => {}
   let restoreHistoryAnchor = (_done: boolean) => {}
-  const historyRequests = new Set<string>()
+  let historyRequest = false
   let historyContinuationFrame: number | undefined
   const loadOlder = async () => {
-    const owner = sessionOwnership.capture()
-    if (historyLoading() || historyRequests.has(owner.key)) return
-    historyRequests.add(owner.key)
+    if (historyRequest || historyLoading()) return
+    historyRequest = true
     const before = timeline.messages().length
     try {
-      await timeline.history.loadOlder({
-        before: () => owner.run(captureHistoryAnchor),
-        after: (done) => owner.run(() => restoreHistoryAnchor(done)),
-      })
+      await timeline.history.loadOlder({ before: () => captureHistoryAnchor(), after: restoreHistoryAnchor })
     } finally {
-      historyRequests.delete(owner.key)
+      historyRequest = false
     }
-    if (!owner.current() || timeline.messages().length <= before) return
+    if (timeline.messages().length <= before) return
     if (!autoScroll.userScrolled() || !scroller || scroller.scrollTop >= 200 || !historyMore()) return
     if (historyContinuationFrame !== undefined) cancelAnimationFrame(historyContinuationFrame)
     historyContinuationFrame = requestAnimationFrame(() => {
       historyContinuationFrame = undefined
-      owner.run(onHistoryScroll)
+      onHistoryScroll()
     })
   }
   const onHistoryScroll = () => {
-    if (
-      historyRequests.has(sessionOwnership.key()) ||
-      historyLoading() ||
-      !autoScroll.userScrolled() ||
-      !scroller ||
-      scroller.scrollTop >= 200
-    )
+    if (historyRequest || historyLoading() || !autoScroll.userScrolled() || !scroller || scroller.scrollTop >= 200)
       return
     void loadOlder()
   }
@@ -1268,13 +1220,23 @@ export default function Page() {
     })
   }
 
-  const merge = (next: NonNullable<ReturnType<typeof info>>, target = sync()) => target.session.remember(next)
+  const merge = (next: NonNullable<ReturnType<typeof info>>) =>
+    sync().set("session", (list) => {
+      const idx = list.findIndex((item) => item.id === next.id)
+      if (idx < 0) return list
+      const out = list.slice()
+      out[idx] = next
+      return out
+    })
 
-  const roll = (sessionID: string, next: NonNullable<ReturnType<typeof info>>["revert"], target = sync()) => {
-    const session = target.session.get(sessionID)
-    if (!session) return
-    target.session.remember({ ...session, revert: next })
-  }
+  const roll = (sessionID: string, next: NonNullable<ReturnType<typeof info>>["revert"]) =>
+    sync().set("session", (list) => {
+      const idx = list.findIndex((item) => item.id === sessionID)
+      if (idx < 0) return list
+      const out = list.slice()
+      out[idx] = { ...out[idx], revert: next }
+      return out
+    })
 
   const busy = (sessionID: string) => sync().data.session_working(sessionID)
 
@@ -1292,7 +1254,6 @@ export default function Page() {
 
   const followupMutation = useMutation(() => ({
     mutationFn: async (input: { sessionID: string; id: string; manual?: boolean }) => {
-      const owner = sessionOwnership.capture()
       const item = (followup.items[input.sessionID] ?? []).find((entry) => entry.id === input.id)
       if (!item) return
 
@@ -1313,7 +1274,7 @@ export default function Page() {
       if (!ok) return
 
       setFollowup("items", input.sessionID, (items) => (items ?? []).filter((entry) => entry.id !== input.id))
-      if (input.manual) owner.run(resumeScroll)
+      if (input.manual) resumeScroll()
     },
   }))
 
@@ -1402,23 +1363,25 @@ export default function Page() {
 
   const revertMutation = useMutation(() => ({
     mutationFn: async (input: { sessionID: string; messageID: string }) => {
-      const client = sdk().client
-      const target = sync()
-      const last = target.session.get(input.sessionID)?.revert
+      const prev = prompt.current().slice()
+      const last = info()?.revert
       const value = draft(input.messageID)
-      await runPromptRollbackMutation({
-        capturePrompt: prompt.capture,
-        optimistic: (prompt) => {
-          roll(input.sessionID, { messageID: input.messageID }, target)
-          prompt.set(value)
-        },
-        request: () => halt(input.sessionID).then(() => client.session.revert(input)),
-        complete: (result) => {
-          if (result.data) merge(result.data, target)
-        },
-        rollback: () => roll(input.sessionID, last, target),
-        fail,
+      batch(() => {
+        roll(input.sessionID, { messageID: input.messageID })
+        prompt.set(value)
       })
+      await halt(input.sessionID)
+        .then(() => sdk().client.session.revert(input))
+        .then((result) => {
+          if (result.data) merge(result.data)
+        })
+        .catch((err) => {
+          batch(() => {
+            roll(input.sessionID, last)
+            prompt.set(prev)
+          })
+          fail(err)
+        })
     },
   }))
 
@@ -1427,31 +1390,39 @@ export default function Page() {
       const sessionID = params.id
       if (!sessionID) return
 
-      const client = sdk().client
-      const target = sync()
       const next = userMessages().find((item) => item.id > id)
-      const last = target.session.get(sessionID)?.revert
+      const prev = prompt.current().slice()
+      const last = info()?.revert
 
-      await runPromptRollbackMutation({
-        capturePrompt: prompt.capture,
-        optimistic: (promptSession) => {
-          roll(sessionID, next ? { messageID: next.id } : undefined, target)
-          if (next) {
-            promptSession.set(draft(next.id))
-            return
-          }
-          promptSession.reset()
-        },
-        request: () =>
-          !next
-            ? halt(sessionID).then(() => client.session.unrevert({ sessionID }))
-            : halt(sessionID).then(() => client.session.revert({ sessionID, messageID: next.id })),
-        complete: (result) => {
-          if (result.data) merge(result.data, target)
-        },
-        rollback: () => roll(sessionID, last, target),
-        fail,
+      batch(() => {
+        roll(sessionID, next ? { messageID: next.id } : undefined)
+        if (next) {
+          prompt.set(draft(next.id))
+          return
+        }
+        prompt.reset()
       })
+
+      const task = !next
+        ? halt(sessionID).then(() => sdk().client.session.unrevert({ sessionID }))
+        : halt(sessionID).then(() =>
+            sdk().client.session.revert({
+              sessionID,
+              messageID: next.id,
+            }),
+          )
+
+      await task
+        .then((result) => {
+          if (result.data) merge(result.data)
+        })
+        .catch((err) => {
+          batch(() => {
+            roll(sessionID, last)
+            prompt.set(prev)
+          })
+          fail(err)
+        })
     },
   }))
 
@@ -1570,35 +1541,17 @@ export default function Page() {
   const composerRegion = (placement: "dock" | "inline") => (
     <SessionComposerRegion
       state={composer}
-      sessionKey={sessionKey()}
-      sessionID={params.id}
-      controls={composerControls()}
-      promptInput={{
-        ref: (el) => {
-          inputRef = el
-        },
-        newSessionWorktree: newSessionWorktree(),
-        onNewSessionWorktreeReset: () => setStore("newSessionWorktree", "main"),
-        onSubmit: () => {
-          comments.clear()
-          resumeScroll()
-        },
-      }}
-      todo={{
-        collapsed: view().todoCollapsed.get(),
-        onToggle: () => view().todoCollapsed.set(!view().todoCollapsed.get()),
-      }}
       ready={!store.deferRender && messagesReady()}
       centered={placement === "dock" && centered()}
       placement={placement}
-      openParent={() => {
-        const id = info()?.parentID
-        if (!id) return
-        navigate(
-          params.serverKey
-            ? sessionHref(requireServerKey(params.serverKey), id)
-            : legacySessionHref(sdk().directory, id),
-        )
+      inputRef={(el) => {
+        inputRef = el
+      }}
+      newSessionWorktree={newSessionWorktree()}
+      onNewSessionWorktreeReset={() => setStore("newSessionWorktree", "main")}
+      onSubmit={() => {
+        comments.clear()
+        resumeScroll()
       }}
       onResponseSubmit={resumeScroll}
       followup={

packages/app/src/pages/session/composer/index.ts

@@ -1,3 +1,2 @@
 export { SessionComposerRegion } from "./session-composer-region"
-export { createSessionComposerControls } from "./session-composer-controls"
 export { createSessionComposerState } from "./session-composer-state"

packages/app/src/pages/session/composer/session-composer-controls.ts

@@ -1,115 +0,0 @@
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import { createQuery } from "@tanstack/solid-query"
-import { useNavigate, useSearchParams } from "@solidjs/router"
-import { type Accessor, createMemo } from "solid-js"
-import type { PromptInputControls } from "@/components/prompt-input"
-import { useDirectoryPicker } from "@/components/directory-picker"
-import { useGlobal } from "@/context/global"
-import { useLayout } from "@/context/layout"
-import { useLocal } from "@/context/local"
-import type { QueryOptionsApi } from "@/context/server-sync"
-import { ServerConnection, useServer } from "@/context/server"
-import { useSDK } from "@/context/sdk"
-import { useSettings } from "@/context/settings"
-import { useSync } from "@/context/sync"
-import { type DraftTab, useTabs } from "@/context/tabs"
-import { useProviders } from "@/hooks/use-providers"
-import { pathKey } from "@/utils/path-key"
-
-export function createSessionComposerControls(input: {
-  sessionKey: Accessor<string>
-  sessionID: Accessor<string | undefined>
-  queryOptions: Pick<QueryOptionsApi, "agents" | "providers">
-}) {
-  const navigate = useNavigate()
-  const layout = useLayout()
-  const local = useLocal()
-  const providers = useProviders()
-  const settings = useSettings()
-  const server = useServer()
-  const sync = useSync()
-  const sdk = useSDK()
-  const tabs = useTabs()
-  const global = useGlobal()
-  const pickDirectory = useDirectoryPicker()
-  const [search] = useSearchParams<{ draftId?: string }>()
-  const view = layout.view(input.sessionKey)
-
-  const draft = createMemo(() => {
-    if (!search.draftId) return
-    return tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)
-  })
-  const projectServer = createMemo(() => {
-    if (!search.draftId) return server.current
-    const target = draft()?.server
-    if (!target) return
-    return server.list.find((conn) => ServerConnection.key(conn) === target)
-  })
-  const projectServerCtx = createMemo(() => {
-    const conn = projectServer()
-    if (conn) return global.ensureServerCtx(conn)
-  })
-  const projects = createMemo(() =>
-    search.draftId ? (projectServerCtx()?.projects.list() ?? []) : layout.projects.list(),
-  )
-  const agentsQuery = createQuery(() => input.queryOptions.agents(pathKey(sdk().directory)))
-  const globalProvidersQuery = createQuery(() => input.queryOptions.providers(null))
-  const providersQuery = createQuery(() => input.queryOptions.providers(pathKey(sdk().directory)))
-
-  const selectProject = (worktree: string) => {
-    const conn = projectServer()
-    const target = projectServerCtx()
-    if (search.draftId) {
-      if (!conn || !target) return
-      target.projects.open(worktree)
-      target.projects.touch(worktree)
-      tabs.updateDraft(search.draftId, { server: ServerConnection.key(conn), directory: worktree })
-      return
-    }
-
-    layout.projects.open(worktree)
-    server.projects.touch(worktree)
-    navigate(`/${base64Encode(worktree)}/session`)
-  }
-
-  const addProject = (title: string) => {
-    const conn = projectServer()
-    if (!conn) return
-    pickDirectory({
-      server: conn,
-      title,
-      onSelect: (result) => {
-        const directory = Array.isArray(result) ? result[0] : result
-        if (directory) selectProject(directory)
-      },
-    })
-  }
-
-  return createMemo<PromptInputControls>(() => ({
-    agents: {
-      available: sync().data.agent,
-      options: local.agent.list().map((agent) => agent.name),
-      current: local.agent.current()?.name ?? "",
-      loading: agentsQuery.isLoading,
-      visible: settings.visibility.customAgents(),
-      select: local.agent.set,
-    },
-    model: {
-      selection: local.model,
-      paid: providers.paid().length > 0,
-      loading: agentsQuery.isLoading || providersQuery.isLoading || globalProvidersQuery.isLoading,
-    },
-    projects: {
-      available: projects(),
-      directory: sdk().directory,
-      select: selectProject,
-      add: addProject,
-    },
-    session: {
-      id: input.sessionID(),
-      tabs: layout.tabs(input.sessionKey),
-      reviewPanel: view.reviewPanel,
-    },
-    newLayoutDesigns: settings.general.newLayoutDesigns(),
-  }))
-}

packages/app/src/pages/session/composer/session-composer-region.tsx

@@ -1,11 +1,14 @@
 import { Show, createEffect, createMemo, createResource, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
+import { useNavigate, useSearchParams } from "@solidjs/router"
 import { useSpring } from "@opencode-ai/ui/motion-spring"
-import { PromptInput, type PromptInputControls, type PromptInputProps } from "@/components/prompt-input"
+import { useLayout } from "@/context/layout"
+import { PromptInput } from "@/components/prompt-input"
 import { useLanguage } from "@/context/language"
 import { usePrompt } from "@/context/prompt"
 import { useSync } from "@/context/sync"
 import { getSessionHandoff, setSessionHandoff } from "@/pages/session/handoff"
+import { useSessionKey } from "@/pages/session/session-layout"
 import { SessionPermissionDock } from "@/pages/session/composer/session-permission-dock"
 import { SessionQuestionDock } from "@/pages/session/composer/session-question-dock"
 import { SessionFollowupDock } from "@/pages/session/composer/session-followup-dock"
@@ -15,21 +18,29 @@ import { SessionTodoDock } from "@/pages/session/composer/session-todo-dock"
 import type { FollowupDraft } from "@/components/prompt-input/submit"
 import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { NEW_SESSION_CONTENT_WIDTH } from "@/pages/session/new-session-layout"
+import { createQuery } from "@tanstack/solid-query"
+import { useQueryOptions } from "@/context/server-sync"
+import { useSDK } from "@/context/sdk"
+import { pathKey } from "@/utils/path-key"
+import { useLocal } from "@/context/local"
+import { useProviders } from "@/hooks/use-providers"
+import { useSettings } from "@/context/settings"
+import { ServerConnection, useServer } from "@/context/server"
+import { type DraftTab, useTabs } from "@/context/tabs"
+import { useDirectoryPicker } from "@/components/directory-picker"
+import { base64Encode } from "@opencode-ai/core/util/encode"
+import { legacySessionHref, requireServerKey, sessionHref } from "@/utils/session-route"
+import { useGlobal } from "@/context/global"
 
 export function SessionComposerRegion(props: {
   state: SessionComposerState
-  sessionKey: string
-  sessionID?: string
-  controls: PromptInputControls
-  promptInput: Omit<PromptInputProps, "controls" | "variant">
-  todo: {
-    collapsed: boolean
-    onToggle: () => void
-  }
   ready: boolean
   centered: boolean
   placement?: "dock" | "inline"
-  openParent?: () => void
+  inputRef: (el: HTMLDivElement) => void
+  newSessionWorktree: string
+  onNewSessionWorktreeReset: () => void
+  onSubmit: () => void
   onResponseSubmit: () => void
   followup?: {
     queue: () => boolean
@@ -50,12 +61,102 @@ export function SessionComposerRegion(props: {
   }
   setPromptDockRef: (el: HTMLDivElement) => void
 }) {
-  const prompt = props.promptInput.state ?? usePrompt()
+  const navigate = useNavigate()
+  const layout = useLayout()
+  const prompt = usePrompt()
   const language = useLanguage()
+  const route = useSessionKey()
   const sync = useSync()
+  const sdk = useSDK()
+  const queryOptions = useQueryOptions()
+  const local = useLocal()
+  const providers = useProviders()
+  const settings = useSettings()
+  const server = useServer()
+  const tabs = useTabs()
+  const global = useGlobal()
+  const pickDirectory = useDirectoryPicker()
+  const [search] = useSearchParams<{ draftId?: string }>()
+  const view = layout.view(route.sessionKey)
 
-  const handoffPrompt = createMemo(() => getSessionHandoff(props.sessionKey)?.prompt)
-  const info = createMemo(() => (props.sessionID ? sync().session.get(props.sessionID) : undefined))
+  const draft = createMemo(() => {
+    if (!search.draftId) return
+    return tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)
+  })
+  const projectServer = createMemo(() => {
+    if (!search.draftId) return server.current
+    const target = draft()?.server
+    if (!target) return
+    return server.list.find((conn) => ServerConnection.key(conn) === target)
+  })
+  const projectServerCtx = createMemo(() => {
+    const conn = projectServer()
+    if (conn) return global.ensureServerCtx(conn)
+  })
+  const projects = createMemo(() =>
+    search.draftId ? (projectServerCtx()?.projects.list() ?? []) : layout.projects.list(),
+  )
+
+  const agentsQuery = createQuery(() => queryOptions().agents(pathKey(sdk().directory)))
+  const globalProvidersQuery = createQuery(() => queryOptions().providers(null))
+  const providersQuery = createQuery(() => queryOptions().providers(pathKey(sdk().directory)))
+  const selectProject = (worktree: string) => {
+    const conn = projectServer()
+    const target = projectServerCtx()
+    if (search.draftId) {
+      if (!conn || !target) return
+      target.projects.open(worktree)
+      target.projects.touch(worktree)
+      tabs.updateDraft(search.draftId, { server: ServerConnection.key(conn), directory: worktree })
+      return
+    }
+
+    layout.projects.open(worktree)
+    server.projects.touch(worktree)
+    navigate(`/${base64Encode(worktree)}/session`)
+  }
+  const addProject = (title: string) => {
+    const conn = projectServer()
+    if (!conn) return
+    pickDirectory({
+      server: conn,
+      title,
+      onSelect: (result) => {
+        const directory = Array.isArray(result) ? result[0] : result
+        if (directory) selectProject(directory)
+      },
+    })
+  }
+  const controls = createMemo(() => ({
+    agents: {
+      available: sync().data.agent,
+      options: local.agent.list().map((agent) => agent.name),
+      current: local.agent.current()?.name ?? "",
+      loading: agentsQuery.isLoading,
+      visible: settings.visibility.customAgents(),
+      select: local.agent.set,
+    },
+    model: {
+      selection: local.model,
+      paid: providers.paid().length > 0,
+      loading: agentsQuery.isLoading || providersQuery.isLoading || globalProvidersQuery.isLoading,
+    },
+    projects: {
+      available: projects(),
+      directory: sdk().directory,
+      select: selectProject,
+      add: addProject,
+    },
+    session: {
+      id: route.params.id,
+      tabs: layout.tabs(route.sessionKey),
+      reviewPanel: view.reviewPanel,
+    },
+    newLayoutDesigns: settings.general.newLayoutDesigns(),
+  }))
+
+  const handoffPrompt = createMemo(() => getSessionHandoff(route.sessionKey())?.prompt)
+  const info = createMemo(() => (route.params.id ? sync().session.get(route.params.id) : undefined))
   const parentID = createMemo(() => info()?.parentID)
   const child = createMemo(() => !!parentID())
   const showComposer = createMemo(() => !props.state.blocked() || child())
@@ -74,11 +175,11 @@ export function SessionComposerRegion(props: {
 
   createEffect(() => {
     if (!prompt.ready()) return
-    setSessionHandoff(props.sessionKey, { prompt: previewPrompt() })
+    setSessionHandoff(route.sessionKey(), { prompt: previewPrompt() })
   })
 
   const [store, setStore] = createStore({
-    ready: props.ready || props.state.dock(),
+    ready: false,
     height: 320,
     body: undefined as HTMLDivElement | undefined,
   })
@@ -97,17 +198,13 @@ export function SessionComposerRegion(props: {
   }
 
   createEffect(() => {
-    props.sessionKey
+    route.sessionKey()
     const ready = props.ready
-    const dock = props.state.dock()
     const delay = 140
 
     clear()
-    if (store.ready || (!ready && !dock)) return
-    if (dock) {
-      setStore("ready", true)
-      return
-    }
+    setStore("ready", false)
+    if (!ready) return
 
     frame = requestAnimationFrame(() => {
       frame = undefined
@@ -121,17 +218,23 @@ export function SessionComposerRegion(props: {
   onCleanup(clear)
 
   const open = createMemo(() => store.ready && props.state.dock() && !props.state.closing())
-  const progress = useSpring(
-    () => (open() ? 1 : 0),
-    { visualDuration: 0.3, bounce: 0 },
-    () => `${props.sessionKey}\0${store.ready}`,
-  )
+  const progress = useSpring(() => (open() ? 1 : 0), { visualDuration: 0.3, bounce: 0 })
   const value = createMemo(() => Math.max(0, Math.min(1, progress())))
   const dock = createMemo(() => (store.ready && props.state.dock()) || value() > 0.001)
   const rolled = createMemo(() => (props.revert?.items.length ? props.revert : undefined))
   const lift = createMemo(() => (rolled() ? 18 : 36 * value()))
   const full = createMemo(() => Math.max(78, store.height))
 
+  const openParent = () => {
+    const id = parentID()
+    if (!id) return
+    navigate(
+      route.params.serverKey
+        ? sessionHref(requireServerKey(route.params.serverKey), id)
+        : legacySessionHref(sdk().directory, id),
+    )
+  }
+
   createEffect(() => {
     const el = store.body
     if (!el) return
@@ -187,30 +290,8 @@ export function SessionComposerRegion(props: {
         </Show>
 
         <Show when={showComposer()}>
-          <Show when={dock()}>
-            <div
-              classList={{
-                "overflow-hidden": true,
-                "pointer-events-none": value() < 0.98,
-              }}
-              style={{
-                "max-height": `${full() * value()}px`,
-              }}
-            >
-              <div ref={(el) => setStore("body", el)}>
-                <SessionTodoDock
-                  todos={props.state.todos()}
-                  collapsed={props.todo.collapsed}
-                  onToggle={props.todo.onToggle}
-                  collapseLabel={language.t("session.todo.collapse")}
-                  expandLabel={language.t("session.todo.expand")}
-                  dockProgress={value()}
-                />
-              </div>
-            </div>
-          </Show>
           <Show
-            when={prompt.ready() || promptReadyResource()}
+            when={promptReadyResource()}
             fallback={
               <>
                 <Show when={rolled()} keyed>
@@ -225,15 +306,35 @@ export function SessionComposerRegion(props: {
                     </div>
                   )}
                 </Show>
-                <div
-                  class="w-full min-h-32 md:min-h-40 rounded-md border border-border-weak-base bg-background-base/50 px-4 py-3 text-text-weak whitespace-pre-wrap pointer-events-none"
-                  style={{ "margin-top": `${-36 * value()}px` }}
-                >
+                <div class="w-full min-h-32 md:min-h-40 rounded-md border border-border-weak-base bg-background-base/50 px-4 py-3 text-text-weak whitespace-pre-wrap pointer-events-none">
                   {handoffPrompt() || language.t("prompt.loading")}
                 </div>
               </>
             }
           >
+            <Show when={dock()}>
+              <div
+                classList={{
+                  "overflow-hidden": true,
+                  "pointer-events-none": value() < 0.98,
+                }}
+                style={{
+                  "max-height": `${full() * value()}px`,
+                }}
+              >
+                <div ref={(el) => setStore("body", el)}>
+                  <SessionTodoDock
+                    sessionID={route.params.id}
+                    todos={props.state.todos()}
+                    collapsed={view.todoCollapsed.get()}
+                    onToggle={() => view.todoCollapsed.set(!view.todoCollapsed.get())}
+                    collapseLabel={language.t("session.todo.collapse")}
+                    expandLabel={language.t("session.todo.expand")}
+                    dockProgress={value()}
+                  />
+                </div>
+              </div>
+            </Show>
             <Show when={rolled()} keyed>
               {(revert) => (
                 <div
@@ -271,28 +372,31 @@ export function SessionComposerRegion(props: {
                 fallback={
                   <Show when={!props.state.blocked()}>
                     <PromptInput
-                      {...props.promptInput}
-                      controls={props.controls}
+                      controls={controls()}
                       variant={props.placement === "inline" ? "new-session" : undefined}
+                      ref={props.inputRef}
+                      newSessionWorktree={props.newSessionWorktree}
+                      onNewSessionWorktreeReset={props.onNewSessionWorktreeReset}
                       edit={props.followup?.edit}
                       onEditLoaded={props.followup?.onEditLoaded}
                       shouldQueue={props.followup?.queue}
                       onQueue={props.followup?.onQueue}
                       onAbort={props.followup?.onAbort}
+                      onSubmit={props.onSubmit}
                     />
                   </Show>
                 }
               >
                 <div
-                  ref={props.promptInput.ref}
+                  ref={props.inputRef}
                   class="w-full rounded-[12px] border border-border-weak-base bg-background-base p-3 text-16-regular text-text-weak"
                 >
                   <span>{language.t("session.child.promptDisabled")} </span>
-                  <Show when={parentID() && props.openParent}>
+                  <Show when={parentID()}>
                     <button
                       type="button"
                       class="text-text-base transition-colors hover:text-text-strong"
-                      onClick={props.openParent}
+                      onClick={openParent}
                     >
                       {language.t("session.child.backToParent")}
                     </button>

packages/app/src/pages/session/composer/session-composer-state.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { PermissionRequest, QuestionRequest, Session } from "@opencode-ai/sdk/v2/client"
-import { todoDockAtBoundary, todoState } from "./session-composer-state"
+import { todoState } from "./session-composer-state"
 import { sessionPermissionRequest, sessionQuestionRequest } from "./session-request-tree"
 
 const session = (input: { id: string; parentID?: string }) =>
@@ -126,13 +126,3 @@ describe("todoState", () => {
     expect(todoState({ count: 2, done: true, live: false })).toBe("clear")
   })
 })
-
-describe("todoDockAtBoundary", () => {
-  test("shows active todos when entering a session", () => {
-    expect(todoDockAtBoundary("open")).toBe(true)
-  })
-
-  test("hides completed todos when entering a session", () => {
-    expect(todoDockAtBoundary("close")).toBe(false)
-  })
-})

packages/app/src/pages/session/composer/session-composer-state.ts

@@ -21,8 +21,6 @@ export const todoState = (input: {
   return "close"
 }
 
-export const todoDockAtBoundary = (state: ReturnType<typeof todoState>) => state === "open"
-
 const idle = { type: "idle" as const }
 
 export function createSessionComposerState(options?: { closeMs?: number | (() => number) }) {
@@ -52,7 +50,7 @@ export function createSessionComposerState(options?: { closeMs?: number | (() =>
   const todos = createMemo((): Todo[] => {
     const id = params.id
     if (!id) return []
-    return serverSync().session.data.todo[id] ?? []
+    return serverSync().data.session_todo[id] ?? []
   })
 
   const done = createMemo(
@@ -62,9 +60,8 @@ export function createSessionComposerState(options?: { closeMs?: number | (() =>
   const live = createMemo(() => sync().data.session_working(params.id ?? "") || blocked())
 
   const [store, setStore] = createStore({
-    sessionID: params.id,
     responding: undefined as string | undefined,
-    dock: todos().length > 0 && !done() && live(),
+    dock: todos().length > 0 && live(),
     closing: false,
     opening: false,
   })
@@ -114,13 +111,14 @@ export function createSessionComposerState(options?: { closeMs?: number | (() =>
   const clear = () => {
     const id = params.id
     if (!id) return
+    serverSync().todo.set(id, [])
     sync().set("todo", id, [])
   }
 
   createEffect(
     on(
-      () => [params.id, todos().length, done(), live()] as const,
-      ([id, count, complete, active], previous) => {
+      () => [todos().length, done(), live()] as const,
+      ([count, complete, active]) => {
         if (raf) cancelAnimationFrame(raf)
         raf = undefined
 
@@ -130,14 +128,6 @@ export function createSessionComposerState(options?: { closeMs?: number | (() =>
           live: active,
         })
 
-        if (!previous || previous[0] !== id) {
-          if (timer) window.clearTimeout(timer)
-          timer = undefined
-          setStore({ sessionID: id, dock: todoDockAtBoundary(next), closing: false, opening: false })
-          if (next === "clear") clear()
-          return
-        }
-
         if (next === "hide") {
           if (timer) window.clearTimeout(timer)
           timer = undefined
@@ -192,12 +182,9 @@ export function createSessionComposerState(options?: { closeMs?: number | (() =>
     permissionResponding,
     decide,
     todos,
-    dock: () =>
-      store.sessionID === params.id
-        ? store.dock
-        : todoDockAtBoundary(todoState({ count: todos().length, done: done(), live: live() })),
-    closing: () => store.sessionID === params.id && store.closing,
-    opening: () => store.sessionID === params.id && store.opening,
+    dock: () => store.dock,
+    closing: () => store.closing,
+    opening: () => store.opening,
   }
 }
 

packages/app/src/pages/session/composer/session-todo-dock.tsx

@@ -40,6 +40,7 @@ function dot(status: Todo["status"]) {
 }
 
 export function SessionTodoDock(props: {
+  sessionID?: string
   todos: Todo[]
   collapsed: boolean
   onToggle: () => void
@@ -49,7 +50,7 @@ export function SessionTodoDock(props: {
 }) {
   const language = useLanguage()
   const [store, setStore] = createStore({
-    height: 78,
+    height: 320,
   })
 
   const total = createMemo(() => props.todos.length)
@@ -84,7 +85,7 @@ export function SessionTodoDock(props: {
     const el = contentRef
     if (!el) return
     const update = () => {
-      setStore("height", (height) => Math.max(height, el.scrollHeight))
+      setStore("height", el.getBoundingClientRect().height)
     }
     update()
     createResizeObserver(el, update)

packages/app/src/pages/session/composer/todo-panel-motion.stories.tsx

@@ -50,25 +50,6 @@ const btn = (accent?: boolean) =>
     "font-size": "13px",
   }) as const
 
-const controls = {
-  agents: { available: [], options: ["build"], current: "build", loading: false, visible: true, select: () => {} },
-  model: {
-    selection: {
-      current: () => ({ id: "claude-3-7-sonnet", name: "Claude 3.7 Sonnet", provider: { id: "anthropic" } }),
-      variant: { list: () => [], current: () => undefined, set: () => {} },
-    },
-    paid: true,
-    loading: false,
-  },
-  projects: { available: [], directory: "/tmp/story", select: () => {}, add: () => {} },
-  session: {
-    id: "story-session",
-    tabs: { active: () => undefined, all: () => [], open: () => {}, setActive: () => {} },
-    reviewPanel: { opened: () => false, open: () => {} },
-  },
-  newLayoutDesigns: true,
-}
-
 const css = `
 [data-component="todo-stage"] {
   display: grid;
@@ -151,7 +132,6 @@ export const Playground = {
     const global = useServerSync()
     const [cfg, setCfg] = createStore({
       open: true,
-      collapsed: false,
       step: 1,
       dockOpenDuration: 0.3,
       dockOpenBounce: 0,
@@ -190,6 +170,7 @@ export const Playground = {
     const countWidthDuration = () => cfg.countWidthDuration
     const state = createSessionComposerState({ closeMs: () => Math.round(dockCloseDuration() * 1000) })
     let frame
+    let composerRef
     let scrollRef
 
     const todos = createMemo<Todo[]>(() => {
@@ -215,8 +196,15 @@ export const Playground = {
       scrollRef.scrollTop = scrollRef.scrollHeight
     }
 
-    const collapsed = () => cfg.collapsed
-    const setCollapsed = (value: boolean) => setCfg("collapsed", value)
+    const collapsed = () =>
+      !!composerRef?.querySelector('[data-action="session-todo-toggle-button"][data-collapsed="true"]')
+
+    const setCollapsed = (value: boolean) => {
+      const button = composerRef?.querySelector('[data-action="session-todo-toggle-button"]')
+      if (!(button instanceof HTMLButtonElement)) return
+      if (collapsed() === value) return
+      button.click()
+    }
 
     const openDock = () => {
       clear()
@@ -279,21 +267,14 @@ export const Playground = {
                   </div>
                 </div>
 
-                <div>
+                <div ref={composerRef}>
                   <SessionComposerRegion
                     state={state}
-                    sessionKey="story-session"
-                    sessionID="story-session"
-                    controls={controls}
-                    promptInput={{
-                      submission: { abort: () => {}, handleSubmit: (event) => event.preventDefault() },
-                      ref: () => {},
-                      newSessionWorktree: "",
-                      onNewSessionWorktreeReset: () => {},
-                    }}
-                    todo={{ collapsed: collapsed(), onToggle: () => setCollapsed(!collapsed()) }}
-                    ready
                     centered={false}
+                    inputRef={() => {}}
+                    newSessionWorktree=""
+                    onNewSessionWorktreeReset={() => {}}
+                    onSubmit={() => {}}
                     onResponseSubmit={pin}
                     setPromptDockRef={() => {}}
                     dockOpenVisualDuration={dockOpenDuration()}

packages/app/src/pages/session/session-ownership.ts

@@ -1,37 +0,0 @@
-import { createComputed, onCleanup } from "solid-js"
-
-export function createSessionOwnership(sessionKey: () => string) {
-  let current = sessionKey()
-  let generation = 0
-  const transition = () => {
-    const next = sessionKey()
-    if (next === current) return
-    current = next
-    generation++
-  }
-  createComputed(transition)
-  onCleanup(() => generation++)
-
-  return {
-    key: () => {
-      transition()
-      return `${generation}:${current}`
-    },
-    capture() {
-      transition()
-      const captured = generation
-      return {
-        key: `${captured}:${current}`,
-        current: () => {
-          transition()
-          return generation === captured
-        },
-        run<T>(action: () => T) {
-          transition()
-          if (generation !== captured) return
-          return action()
-        },
-      }
-    },
-  }
-}

packages/app/src/pages/session/timeline/message-timeline.tsx

@@ -56,6 +56,7 @@ import { useFileComponent } from "@opencode-ai/ui/context/file"
 import { shouldMarkBoundaryGesture, normalizeWheelDelta } from "@/pages/session/message-gesture"
 import { SessionContextUsage } from "@/components/session-context-usage"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { useLanguage } from "@/context/language"
 import { useSessionKey } from "@/pages/session/session-layout"
 import { useServerSDK } from "@/context/server-sdk"
@@ -94,6 +95,8 @@ const taskDescription = (part: PartType, sessionID: string) => {
   if (typeof value === "string" && value) return value
 }
 
+const pace = (width: number) => Math.round(Math.max(1200, Math.min(3200, (Math.max(width, 360) * 2000) / 900)))
+
 const boundaryTarget = (root: HTMLElement, target: EventTarget | null) => {
   const current = target instanceof Element ? target : undefined
   const nested = current?.closest("[data-scrollable]")
@@ -564,7 +567,18 @@ export function MessageTimeline(props: {
     open: false,
     dismiss: null as "escape" | "outside" | null,
   })
+  const [bar, setBar] = createStore({
+    ms: pace(640),
+  })
   let more: HTMLButtonElement | undefined
+  let head: HTMLDivElement | undefined
+
+  const updateTitleMetrics = () => {
+    if (!head || head.clientWidth <= 0) return
+    setBar("ms", pace(head.clientWidth))
+  }
+
+  createResizeObserver(() => head, updateTitleMetrics)
 
   const bindListRoot = (root: HTMLDivElement) => {
     if (root === listRoot()) return
@@ -646,14 +660,14 @@ export function MessageTimeline(props: {
   }
 
   const shareMutation = useMutation(() => ({
-    mutationFn: (id: string) => serverSDK().client.session.share({ sessionID: id }),
+    mutationFn: (id: string) => serverSDK().client.session.share({ sessionID: id, directory: sdk().directory }),
     onError: (err) => {
       console.error("Failed to share session", err)
     },
   }))
 
   const unshareMutation = useMutation(() => ({
-    mutationFn: (id: string) => serverSDK().client.session.unshare({ sessionID: id }),
+    mutationFn: (id: string) => serverSDK().client.session.unshare({ sessionID: id, directory: sdk().directory }),
     onError: (err) => {
       console.error("Failed to unshare session", err)
     },
@@ -1277,6 +1291,10 @@ export function MessageTimeline(props: {
       >
         <Show when={showHeader()}>
           <div
+            ref={(el) => {
+              head = el
+              updateTitleMetrics()
+            }}
             data-session-title
             classList={{
               "sticky top-0 z-30 bg-[linear-gradient(to_bottom,var(--background-stronger)_48px,transparent)]": true,
@@ -1288,6 +1306,17 @@ export function MessageTimeline(props: {
               "md:max-w-200 md:mx-auto 2xl:max-w-[1000px]": props.centered,
             }}
           >
+            <Show when={workingStatus() !== "hidden" && settings.general.showSessionProgressBar()}>
+              <div data-component="session-progress" data-state={workingStatus()} aria-hidden="true">
+                <div
+                  data-component="session-progress-bar"
+                  style={{
+                    background: tint() ?? "var(--icon-interactive-base)",
+                    animation: `session-progress-whip ${bar.ms}ms infinite`,
+                  }}
+                />
+              </div>
+            </Show>
             <div class="h-12 w-full flex items-center justify-between gap-2">
               <div class="flex items-center gap-1 min-w-0 flex-1 pr-3">
                 <div class="flex items-center min-w-0 grow-1">

packages/app/src/pages/session/timeline/model.ts

@@ -1,29 +1,37 @@
 import type { Message, UserMessage } from "@opencode-ai/sdk/v2"
 import { createMemo, createResource, onCleanup, untrack, type Accessor } from "solid-js"
-import { useServerSync } from "@/context/server-sync"
+import { getSessionPrefetch, SESSION_PREFETCH_TTL } from "@/context/global-sync/session-prefetch"
+import { useSDK } from "@/context/sdk"
+import { useServerSDK } from "@/context/server-sdk"
 import { useSync } from "@/context/sync"
 import { same } from "@/utils/same"
 
 const emptyUserMessages: UserMessage[] = []
-const sessionFreshness = 15_000
 
 export function createTimelineModel(input: {
   sessionID: Accessor<string | undefined>
   revertMessageID: Accessor<string | undefined>
 }) {
-  const serverSync = useServerSync()
+  const sdk = useSDK()
+  const serverSDK = useServerSDK()
   const sync = useSync()
   let refreshFrame: number | undefined
   let refreshTimer: number | undefined
 
   const [resource] = createResource(
-    () => input.sessionID(),
-    (id) => {
+    () => [sdk().directory, input.sessionID()] as const,
+    ([directory, id]) => {
       clearRefresh()
       if (!id) return
 
       const cached = untrack(() => sync().data.message[id] !== undefined)
-      const stale = cached && !serverSync().session.fresh(id, sessionFreshness)
+      const stale = cached
+        ? (() => {
+            const info = getSessionPrefetch(serverSDK().scope, directory, id)
+            if (!info) return true
+            return Date.now() - info.at > SESSION_PREFETCH_TTL
+          })()
+        : false
 
       refreshFrame = requestAnimationFrame(() => {
         refreshFrame = undefined

packages/app/src/pages/session/use-session-commands.tsx

@@ -20,7 +20,6 @@ import { UserMessage } from "@opencode-ai/sdk/v2"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { useTabs } from "@/context/tabs"
 import { requireServerKey } from "@/utils/session-route"
-import { createSessionOwnership } from "./session-ownership"
 
 export type SessionCommandContext = {
   navigateMessageByOffset: (offset: number) => void
@@ -51,24 +50,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   const sessionTabs = useTabs()
   const layout = useLayout()
   const navigate = useNavigate()
-  const { params, sessionKey, tabs, view } = useSessionLayout()
-  const sessionOwnership = createSessionOwnership(sessionKey)
-  const openDialog = async <T,>(load: () => Promise<T>, show: (value: T) => void) => {
-    const owner = sessionOwnership.capture()
-    const value = await load()
-    owner.run(() => show(value))
-  }
-  const runCommand = async <T,>(input: {
-    owner: ReturnType<ReturnType<typeof createSessionOwnership>["capture"]>
-    prompt: T
-    request: () => Promise<unknown>
-    updatePrompt: (prompt: T) => void
-    updateViewport: () => void
-  }) => {
-    await input.request()
-    input.updatePrompt(input.prompt)
-    input.owner.run(input.updateViewport)
-  }
+  const { params, tabs, view } = useSessionLayout()
 
   const info = () => {
     const id = params.id
@@ -235,10 +217,9 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   }
 
   const openFile = () => {
-    void openDialog(
-      () => import("@/components/dialog-select-file"),
-      (x) => dialog.show(() => <x.DialogSelectFile onOpenFile={showAllFiles} />),
-    )
+    void import("@/components/dialog-select-file").then((x) => {
+      dialog.show(() => <x.DialogSelectFile onOpenFile={showAllFiles} />)
+    })
   }
 
   const closeTab = () => {
@@ -272,17 +253,15 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   }
 
   const chooseModel = () => {
-    void openDialog(
-      () => import("@/components/dialog-select-model"),
-      (x) => dialog.show(() => <x.DialogSelectModel model={local.model} />),
-    )
+    void import("@/components/dialog-select-model").then((x) => {
+      dialog.show(() => <x.DialogSelectModel model={local.model} />)
+    })
   }
 
   const chooseMcp = () => {
-    void openDialog(
-      () => import("@/components/dialog-select-mcp"),
-      (x) => dialog.show(() => <x.DialogSelectMcp />),
-    )
+    void import("@/components/dialog-select-mcp").then((x) => {
+      dialog.show(() => <x.DialogSelectMcp />)
+    })
   }
 
   const toggleAutoAccept = () => {
@@ -306,61 +285,47 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   const undo = async () => {
     const sessionID = params.id
     if (!sessionID) return
-    const owner = sessionOwnership.capture()
-    const client = sdk().client
-    const directory = sdk().directory
-    const promptSession = prompt.capture()
-    const revert = info()?.revert?.messageID
-    const messages = userMessages()
-    const message = findLast(messages, (x) => !revert || x.id < revert)
-    if (!message) return
-    const parts = sync().data.part[message.id]
 
-    if (sync().data.session_working(sessionID)) {
-      await client.session.abort({ sessionID }).catch(() => {})
+    if (sync().data.session_working(params.id ?? "")) {
+      await sdk()
+        .client.session.abort({ sessionID })
+        .catch(() => {})
     }
 
-    await runCommand({
-      owner,
-      prompt: promptSession,
-      request: () => client.session.revert({ sessionID, messageID: message.id }),
-      updatePrompt: (promptSession) => {
-        if (parts) promptSession.set(extractPromptFromParts(parts, { directory }))
-      },
-      updateViewport: () => setActiveMessage(findLast(messages, (x) => x.id < message.id)),
-    })
+    const revert = info()?.revert?.messageID
+    const message = findLast(userMessages(), (x) => !revert || x.id < revert)
+    if (!message) return
+
+    await sdk().client.session.revert({ sessionID, messageID: message.id })
+    const parts = sync().data.part[message.id]
+    if (parts) {
+      const restored = extractPromptFromParts(parts, { directory: sdk().directory })
+      prompt.set(restored)
+    }
+
+    const prev = findLast(userMessages(), (x) => x.id < message.id)
+    setActiveMessage(prev)
   }
 
   const redo = async () => {
     const sessionID = params.id
     if (!sessionID) return
-    const owner = sessionOwnership.capture()
-    const client = sdk().client
-    const messages = userMessages()
-    const promptSession = prompt.capture()
 
     const revertMessageID = info()?.revert?.messageID
     if (!revertMessageID) return
 
-    const next = messages.find((x) => x.id > revertMessageID)
+    const next = userMessages().find((x) => x.id > revertMessageID)
     if (!next) {
-      await runCommand({
-        owner,
-        prompt: promptSession,
-        request: () => client.session.unrevert({ sessionID }),
-        updatePrompt: (promptSession) => promptSession.reset(),
-        updateViewport: () => setActiveMessage(findLast(messages, (x) => x.id >= revertMessageID)),
-      })
+      await sdk().client.session.unrevert({ sessionID })
+      prompt.reset()
+      const last = findLast(userMessages(), (x) => x.id >= revertMessageID)
+      setActiveMessage(last)
       return
     }
 
-    await runCommand({
-      owner,
-      prompt: promptSession,
-      request: () => client.session.revert({ sessionID, messageID: next.id }),
-      updatePrompt: () => undefined,
-      updateViewport: () => setActiveMessage(findLast(messages, (x) => x.id < next.id)),
-    })
+    await sdk().client.session.revert({ sessionID, messageID: next.id })
+    const prev = findLast(userMessages(), (x) => x.id < next.id)
+    setActiveMessage(prev)
   }
 
   const compact = async () => {
@@ -384,10 +349,9 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   }
 
   const fork = () => {
-    void openDialog(
-      () => import("@/components/dialog-fork"),
-      (x) => dialog.show(() => <x.DialogFork />),
-    )
+    void import("@/components/dialog-fork").then((x) => {
+      dialog.show(() => <x.DialogFork />)
+    })
   }
 
   const shareCmds = () => {

packages/app/src/utils/session-placement.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test"
+import { ServerConnection } from "@/context/server"
+import { createSessionPlacementStore } from "./session-placement"
+
+describe("session placement", () => {
+  const local = ServerConnection.Key.make("http://localhost:4096")
+  const remote = ServerConnection.Key.make("https://example.com")
+
+  test("aliases a leaf and root without crossing servers", () => {
+    const store = createSessionPlacementStore()
+    store.set({ server: local, leafID: "child", rootID: "root", directory: "/repo" })
+    store.set({ server: remote, leafID: "child", rootID: "other", directory: "/remote" })
+
+    expect(store.get(local, "child")).toEqual({ rootID: "root", directory: "/repo" })
+    expect(store.get(local, "root")).toEqual({ rootID: "root", directory: "/repo" })
+    expect(store.get(remote, "child")).toEqual({ rootID: "other", directory: "/remote" })
+  })
+
+  test("inherits known placement for in-app child navigation", () => {
+    const store = createSessionPlacementStore()
+    store.set({ server: local, leafID: "parent", rootID: "root", directory: "/repo" })
+
+    expect(store.inherit(local, "parent", "child")).toEqual({ rootID: "root", directory: "/repo" })
+    expect(store.get(local, "child")).toEqual({ rootID: "root", directory: "/repo" })
+    expect(store.inherit(local, "missing", "unknown")).toBeUndefined()
+  })
+
+  test("bounds retained placement aliases", () => {
+    const store = createSessionPlacementStore()
+    for (let index = 0; index < 300; index++) {
+      store.set({ server: local, leafID: `leaf-${index}`, rootID: `root-${index}`, directory: `/repo/${index}` })
+    }
+
+    expect(store.size()).toBeLessThanOrEqual(256)
+    expect(store.get(local, "leaf-0")).toBeUndefined()
+    expect(store.get(local, "leaf-299")).toEqual({ rootID: "root-299", directory: "/repo/299" })
+  })
+})

packages/app/src/utils/session-placement.ts

@@ -0,0 +1,41 @@
+import { ServerConnection } from "@/context/server"
+
+export type SessionPlacement = {
+  rootID: string
+  directory: string
+}
+
+export function createSessionPlacementStore() {
+  const placements = new Map<string, SessionPlacement>()
+  const limit = 256
+  const key = (server: ServerConnection.Key, sessionID: string) => `${server}\0${sessionID}`
+  const write = (id: string, placement: SessionPlacement) => {
+    placements.delete(id)
+    placements.set(id, placement)
+    while (placements.size > limit) placements.delete(placements.keys().next().value!)
+  }
+
+  return {
+    get(server: ServerConnection.Key, sessionID: string) {
+      const id = key(server, sessionID)
+      const placement = placements.get(id)
+      if (placement) write(id, placement)
+      return placement
+    },
+    set(input: SessionPlacement & { server: ServerConnection.Key; leafID: string }) {
+      const placement = { rootID: input.rootID, directory: input.directory }
+      write(key(input.server, input.leafID), placement)
+      write(key(input.server, input.rootID), placement)
+      return placement
+    },
+    inherit(server: ServerConnection.Key, sourceID: string, leafID: string) {
+      const placement = placements.get(key(server, sourceID))
+      if (!placement) return
+      write(key(server, leafID), placement)
+      return placement
+    },
+    size() {
+      return placements.size
+    },
+  }
+}

packages/app/src/utils/session-route.test.ts

@@ -1,38 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { ServerConnection } from "@/context/server"
-import {
-  legacySessionHref,
-  legacySessionServer,
-  requireServerKey,
-  rootSession,
-  selectSessionLineage,
-  sessionHref,
-} from "./session-route"
+import { legacySessionHref, requireServerKey, rootSession, sessionHref } from "./session-route"
 
 describe("session routes", () => {
-  test("uses the unique persisted server for a legacy session route", () => {
-    expect(
-      legacySessionServer(
-        [{ type: "session", server: ServerConnection.Key.make("server-b"), sessionId: "session-1" }],
-        "session-1",
-        ServerConnection.Key.make("server-a"),
-      ),
-    ).toBe(ServerConnection.Key.make("server-b"))
-  })
-
-  test("prefers the active server when a legacy session ID is ambiguous", () => {
-    expect(
-      legacySessionServer(
-        [
-          { type: "session", server: ServerConnection.Key.make("server-a"), sessionId: "session-1" },
-          { type: "session", server: ServerConnection.Key.make("server-b"), sessionId: "session-1" },
-        ],
-        "session-1",
-        ServerConnection.Key.make("server-b"),
-      ),
-    ).toBe(ServerConnection.Key.make("server-b"))
-  })
-
   test("builds and decodes a server-keyed session route", () => {
     const server = ServerConnection.Key.make("https://example.com:4096")
     const href = sessionHref(server, "session-1")
@@ -66,19 +36,4 @@ describe("session routes", () => {
       }),
     ).toBe(sessions.root)
   })
-
-  test("rejects a parent cycle", async () => {
-    const sessions: Record<string, { id: string; parentID?: string }> = {
-      child: { id: "child", parentID: "parent" },
-      parent: { id: "parent", parentID: "child" },
-    }
-
-    expect(rootSession(sessions.child, async (id) => sessions[id]!)).rejects.toThrow("Session parent cycle: child")
-  })
-
-  test("ignores a resolved lineage retained from the previous route", () => {
-    const previous = { session: { id: "A" }, root: { id: "A" } }
-
-    expect(selectSessionLineage("B", undefined, previous)).toBeUndefined()
-  })
 })

packages/app/src/utils/session-route.ts

@@ -16,33 +16,10 @@ export function requireServerKey(segment: string | undefined) {
   return ServerConnection.Key.make(key)
 }
 
-export function legacySessionServer(
-  tabs: readonly { type: "session"; server: ServerConnection.Key; sessionId: string }[],
-  sessionID: string,
-  active: ServerConnection.Key,
-) {
-  const matches = tabs.filter((tab) => tab.sessionId === sessionID)
-  return matches.find((tab) => tab.server === active)?.server ?? (matches.length === 1 ? matches[0]?.server : active)
-}
-
 type SessionParent = { id: string; parentID?: string }
 
-export function selectSessionLineage<T extends { session: { id: string } }>(
-  sessionID: string,
-  cached: T | undefined,
-  resolved: T | undefined,
-) {
-  if (cached?.session.id === sessionID) return cached
-  if (resolved?.session.id === sessionID) return resolved
-}
-
-export async function rootSession<T extends SessionParent>(session: T, get: (sessionID: string) => Promise<T>) {
-  const seen = new Set([session.id])
+export async function rootSession(session: SessionParent, get: (sessionID: string) => Promise<SessionParent>) {
   let current = session
-  while (current.parentID) {
-    if (seen.has(current.parentID)) throw new Error(`Session parent cycle: ${current.parentID}`)
-    seen.add(current.parentID)
-    current = await get(current.parentID)
-  }
+  while (current.parentID) current = await get(current.parentID)
   return current
 }