fix lint

.dockerignore

@@ -1,12 +0,0 @@
-.git
-.opencode
-.sst
-.turbo
-.wrangler
-node_modules
-**/node_modules
-**/.output
-**/dist
-**/.turbo
-**/.vite
-**/coverage

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,5 +1,5 @@
 name: Bug report
-description: Report an issue that should be fixed (avoid pasting giant AI generated summaries or your issue may be closed/ignored)
+description: Report an issue that should be fixed
 body:
   - type: textarea
     id: description

.github/TEAM_MEMBERS

@@ -14,4 +14,3 @@ rekram1-node
 thdxr
 simonklee
 vimtor
-starptech

.github/workflows/deploy.yml

@@ -9,15 +9,9 @@ on:
 
 concurrency: ${{ github.workflow }}-${{ github.ref }}
 
-permissions:
-  contents: read
-  id-token: write
-
 jobs:
   deploy:
-    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'dev' || github.ref_name == 'production')
     runs-on: ubuntu-latest
-    environment: ${{ github.ref_name }}
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
 
@@ -27,11 +21,14 @@ jobs:
         with:
           node-version: "24"
 
-      - uses: aws-actions/configure-aws-credentials@7474bc4690e29a8392af63c5b98e7449536d5c3a # v4.3.1
-        with:
-          role-to-assume: ${{ vars.AWS_DEPLOY_ROLE_ARN }}
-          role-session-name: opencode-${{ github.run_id }}
-          aws-region: us-east-1
+      # Workaround for Pulumi version conflict:
+      # GitHub runners have Pulumi 3.212.0+ pre-installed, which removed the -root flag
+      # from pulumi-language-nodejs (see https://github.com/pulumi/pulumi/pull/21065).
+      # SST 3.17.x uses Pulumi SDK 3.210.0 which still passes -root, causing a conflict.
+      # Removing the system language plugin forces SST to use its bundled compatible version.
+      # TODO: Remove when sst supports Pulumi >3.210.0
+      - name: Fix Pulumi version conflict
+        run: sudo rm -f /usr/local/bin/pulumi-language-nodejs
 
       - run: bun sst deploy --stage=${{ github.ref_name }}
         env:

.opencode/opencode.jsonc

@@ -2,10 +2,12 @@
   "$schema": "https://opencode.ai/config.json",
   "provider": {},
   "permission": {},
-  "reference": {
-    "effect": "github.com/Effect-TS/effect-smol",
+  "mcp": {
+    "opencode": {
+      "type": "remote",
+      "url": "http://127.0.0.1:43110/mcp"
+    }
   },
-  "mcp": {},
   "tools": {
     "github-triage": false,
     "github-pr-search": false,

.opencode/skills/improve-codebase-architecture/DEEPENING.md

@@ -0,0 +1,37 @@
+# Deepening
+
+How to deepen a cluster of shallow modules safely, given its dependencies. Assumes the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**.
+
+## Dependency categories
+
+When assessing a candidate for deepening, classify its dependencies. The category determines how the deepened module is tested across its seam.
+
+### 1. In-process
+
+Pure computation, in-memory state, no I/O. Always deepenable — merge the modules and test through the new interface directly. No adapter needed.
+
+### 2. Local-substitutable
+
+Dependencies that have local test stand-ins (PGLite for Postgres, in-memory filesystem). Deepenable if the stand-in exists. The deepened module is tested with the stand-in running in the test suite. The seam is internal; no port at the module's external interface.
+
+### 3. Remote but owned (Ports & Adapters)
+
+Your own services across a network boundary (microservices, internal APIs). Define a **port** (interface) at the seam. The deep module owns the logic; the transport is injected as an **adapter**. Tests use an in-memory adapter. Production uses an HTTP/gRPC/queue adapter.
+
+Recommendation shape: _"Define a port at the seam, implement an HTTP adapter for production and an in-memory adapter for testing, so the logic sits in one deep module even though it's deployed across a network."_
+
+### 4. True external (Mock)
+
+Third-party services (Stripe, Twilio, etc.) you don't control. The deepened module takes the external dependency as an injected port; tests provide a mock adapter.
+
+## Seam discipline
+
+- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a port unless at least two adapters are justified (typically production + test). A single-adapter seam is just indirection.
+- **Internal seams vs external seams.** A deep module can have internal seams (private to its implementation, used by its own tests) as well as the external seam at its interface. Don't expose internal seams through the interface just because tests use them.
+
+## Testing strategy: replace, don't layer
+
+- Old unit tests on shallow modules become waste once tests at the deepened module's interface exist — delete them.
+- Write new tests at the deepened module's interface. The **interface is the test surface**.
+- Tests assert on observable outcomes through the interface, not internal state.
+- Tests should survive internal refactors — they describe behaviour, not implementation. If a test has to change when the implementation changes, it's testing past the interface.

.opencode/skills/improve-codebase-architecture/INTERFACE-DESIGN.md

@@ -0,0 +1,44 @@
+# Interface Design
+
+When the user wants to explore alternative interfaces for a chosen deepening candidate, use this parallel sub-agent pattern. Based on "Design It Twice" (Ousterhout) — your first idea is unlikely to be the best.
+
+Uses the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**, **leverage**.
+
+## Process
+
+### 1. Frame the problem space
+
+Before spawning sub-agents, write a user-facing explanation of the problem space for the chosen candidate:
+
+- The constraints any new interface would need to satisfy
+- The dependencies it would rely on, and which category they fall into (see [DEEPENING.md](DEEPENING.md))
+- A rough illustrative code sketch to ground the constraints — not a proposal, just a way to make the constraints concrete
+
+Show this to the user, then immediately proceed to Step 2. The user reads and thinks while the sub-agents work in parallel.
+
+### 2. Spawn sub-agents
+
+Spawn 3+ sub-agents in parallel using the Agent tool. Each must produce a **radically different** interface for the deepened module.
+
+Prompt each sub-agent with a separate technical brief (file paths, coupling details, dependency category from [DEEPENING.md](DEEPENING.md), what sits behind the seam). The brief is independent of the user-facing problem-space explanation in Step 1. Give each agent a different design constraint:
+
+- Agent 1: "Minimize the interface — aim for 1–3 entry points max. Maximise leverage per entry point."
+- Agent 2: "Maximise flexibility — support many use cases and extension."
+- Agent 3: "Optimise for the most common caller — make the default case trivial."
+- Agent 4 (if applicable): "Design around ports & adapters for cross-seam dependencies."
+
+Include both [LANGUAGE.md](LANGUAGE.md) vocabulary and CONTEXT.md vocabulary in the brief so each sub-agent names things consistently with the architecture language and the project's domain language.
+
+Each sub-agent outputs:
+
+1. Interface (types, methods, params — plus invariants, ordering, error modes)
+2. Usage example showing how callers use it
+3. What the implementation hides behind the seam
+4. Dependency strategy and adapters (see [DEEPENING.md](DEEPENING.md))
+5. Trade-offs — where leverage is high, where it's thin
+
+### 3. Present and compare
+
+Present designs sequentially so the user can absorb each one, then compare them in prose. Contrast by **depth** (leverage at the interface), **locality** (where change concentrates), and **seam placement**.
+
+After comparing, give your own recommendation: which design you think is strongest and why. If elements from different designs would combine well, propose a hybrid. Be opinionated — the user wants a strong read, not a menu.

.opencode/skills/improve-codebase-architecture/LANGUAGE.md

@@ -0,0 +1,53 @@
+# Language
+
+Shared vocabulary for every suggestion this skill makes. Use these terms exactly — don't substitute "component," "service," "API," or "boundary." Consistent language is the whole point.
+
+## Terms
+
+**Module**
+Anything with an interface and an implementation. Deliberately scale-agnostic — applies equally to a function, class, package, or tier-spanning slice.
+_Avoid_: unit, component, service.
+
+**Interface**
+Everything a caller must know to use the module correctly. Includes the type signature, but also invariants, ordering constraints, error modes, required configuration, and performance characteristics.
+_Avoid_: API, signature (too narrow — those refer only to the type-level surface).
+
+**Implementation**
+What's inside a module — its body of code. Distinct from **Adapter**: a thing can be a small adapter with a large implementation (a Postgres repo) or a large adapter with a small implementation (an in-memory fake). Reach for "adapter" when the seam is the topic; "implementation" otherwise.
+
+**Depth**
+Leverage at the interface — the amount of behaviour a caller (or test) can exercise per unit of interface they have to learn. A module is **deep** when a large amount of behaviour sits behind a small interface. A module is **shallow** when the interface is nearly as complex as the implementation.
+
+**Seam** _(from Michael Feathers)_
+A place where you can alter behaviour without editing in that place. The _location_ at which a module's interface lives. Choosing where to put the seam is its own design decision, distinct from what goes behind it.
+_Avoid_: boundary (overloaded with DDD's bounded context).
+
+**Adapter**
+A concrete thing that satisfies an interface at a seam. Describes _role_ (what slot it fills), not substance (what's inside).
+
+**Leverage**
+What callers get from depth. More capability per unit of interface they have to learn. One implementation pays back across N call sites and M tests.
+
+**Locality**
+What maintainers get from depth. Change, bugs, knowledge, and verification concentrate at one place rather than spreading across callers. Fix once, fixed everywhere.
+
+## Principles
+
+- **Depth is a property of the interface, not the implementation.** A deep module can be internally composed of small, mockable, swappable parts — they just aren't part of the interface. A module can have **internal seams** (private to its implementation, used by its own tests) as well as the **external seam** at its interface.
+- **The deletion test.** Imagine deleting the module. If complexity vanishes, the module wasn't hiding anything (it was a pass-through). If complexity reappears across N callers, the module was earning its keep.
+- **The interface is the test surface.** Callers and tests cross the same seam. If you want to test _past_ the interface, the module is probably the wrong shape.
+- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a seam unless something actually varies across it.
+
+## Relationships
+
+- A **Module** has exactly one **Interface** (the surface it presents to callers and tests).
+- **Depth** is a property of a **Module**, measured against its **Interface**.
+- A **Seam** is where a **Module**'s **Interface** lives.
+- An **Adapter** sits at a **Seam** and satisfies the **Interface**.
+- **Depth** produces **Leverage** for callers and **Locality** for maintainers.
+
+## Rejected framings
+
+- **Depth as ratio of implementation-lines to interface-lines** (Ousterhout): rewards padding the implementation. We use depth-as-leverage instead.
+- **"Interface" as the TypeScript `interface` keyword or a class's public methods**: too narrow — interface here includes every fact a caller must know.
+- **"Boundary"**: overloaded with DDD's bounded context. Say **seam** or **interface**.

.opencode/skills/improve-codebase-architecture/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: improve-codebase-architecture
+description: Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.
+---
+
+# Improve Codebase Architecture
+
+Surface architectural friction and propose **deepening opportunities** — refactors that turn shallow modules into deep ones. The aim is testability and AI-navigability.
+
+## Glossary
+
+Use these terms exactly in every suggestion. Consistent language is the point — don't drift into "component," "service," "API," or "boundary." Full definitions in [LANGUAGE.md](LANGUAGE.md).
+
+- **Module** — anything with an interface and an implementation (function, class, package, slice).
+- **Interface** — everything a caller must know to use the module: types, invariants, error modes, ordering, config. Not just the type signature.
+- **Implementation** — the code inside.
+- **Depth** — leverage at the interface: a lot of behaviour behind a small interface. **Deep** = high leverage. **Shallow** = interface nearly as complex as the implementation.
+- **Seam** — where an interface lives; a place behaviour can be altered without editing in place. (Use this, not "boundary.")
+- **Adapter** — a concrete thing satisfying an interface at a seam.
+- **Leverage** — what callers get from depth.
+- **Locality** — what maintainers get from depth: change, bugs, knowledge concentrated in one place.
+
+Key principles (see [LANGUAGE.md](LANGUAGE.md) for the full list):
+
+- **Deletion test**: imagine deleting the module. If complexity vanishes, it was a pass-through. If complexity reappears across N callers, it was earning its keep.
+- **The interface is the test surface.**
+- **One adapter = hypothetical seam. Two adapters = real seam.**
+
+This skill is _informed_ by the project's domain model. The domain language gives names to good seams; ADRs record decisions the skill should not re-litigate.
+
+## Process
+
+### 1. Explore
+
+Read the project's domain glossary and any ADRs in the area you're touching first.
+
+Then use the Agent tool with `subagent_type=Explore` to walk the codebase. Don't follow rigid heuristics — explore organically and note where you experience friction:
+
+- Where does understanding one concept require bouncing between many small modules?
+- Where are modules **shallow** — interface nearly as complex as the implementation?
+- Where have pure functions been extracted just for testability, but the real bugs hide in how they're called (no **locality**)?
+- Where do tightly-coupled modules leak across their seams?
+- Which parts of the codebase are untested, or hard to test through their current interface?
+
+Apply the **deletion test** to anything you suspect is shallow: would deleting it concentrate complexity, or just move it? A "yes, concentrates" is the signal you want.
+
+### 2. Present candidates
+
+Present a numbered list of deepening opportunities. For each candidate:
+
+- **Files** — which files/modules are involved
+- **Problem** — why the current architecture is causing friction
+- **Solution** — plain English description of what would change
+- **Benefits** — explained in terms of locality and leverage, and also in how tests would improve
+
+**Use CONTEXT.md vocabulary for the domain, and [LANGUAGE.md](LANGUAGE.md) vocabulary for the architecture.** If `CONTEXT.md` defines "Order," talk about "the Order intake module" — not "the FooBarHandler," and not "the Order service."
+
+**ADR conflicts**: if a candidate contradicts an existing ADR, only surface it when the friction is real enough to warrant revisiting the ADR. Mark it clearly (e.g. _"contradicts ADR-0007 — but worth reopening because…"_). Don't list every theoretical refactor an ADR forbids.
+
+Do NOT propose interfaces yet. Ask the user: "Which of these would you like to explore?"
+
+### 3. Grilling loop
+
+Once the user picks a candidate, drop into a grilling conversation. Walk the design tree with them — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive.
+
+Side effects happen inline as decisions crystallize:
+
+- **Naming a deepened module after a concept not in `CONTEXT.md`?** Add the term to `CONTEXT.md` — same discipline as `/grill-with-docs` (see [CONTEXT-FORMAT.md](../grill-with-docs/CONTEXT-FORMAT.md)). Create the file lazily if it doesn't exist.
+- **Sharpening a fuzzy term during the conversation?** Update `CONTEXT.md` right there.
+- **User rejects the candidate with a load-bearing reason?** Offer an ADR, framed as: _"Want me to record this as an ADR so future architecture reviews don't re-suggest it?"_ Only offer when the reason would actually be needed by a future explorer to avoid re-suggesting the same thing — skip ephemeral reasons ("not worth it right now") and self-evident ones. See [ADR-FORMAT.md](../grill-with-docs/ADR-FORMAT.md).
+- **Want to explore alternative interfaces for the deepened module?** See [INTERFACE-DESIGN.md](INTERFACE-DESIGN.md).

.opencode/tool/github-triage.ts

@@ -4,8 +4,8 @@ import { tool } from "@opencode-ai/plugin"
 const TEAM = {
   tui: ["kommander", "simonklee"],
   desktop_web: ["Hona", "Brendonovich"],
-  core: ["jlongster", "rekram1-node", "nexxeln", "kitlangton", "starptech"],
-  inference: ["fwang", "MrMushrooooom", "starptech"],
+  core: ["jlongster", "rekram1-node", "nexxeln", "kitlangton"],
+  inference: ["fwang", "MrMushrooooom"],
   windows: ["Hona"],
 } as const
 

AGENTS.md

@@ -1,14 +1,8 @@
 - To regenerate the JavaScript SDK, run `./packages/sdk/js/script/build.ts`.
+- ALWAYS USE PARALLEL TOOLS WHEN APPLICABLE.
 - The default branch in this repo is `dev`.
 - Local `main` ref may not exist; use `dev` or `origin/dev` for diffs.
-
-## Commits and PR Titles
-
-Use conventional commit-style messages and PR titles: `type(scope): summary`.
-
-Valid types are `feat`, `fix`, `docs`, `chore`, `refactor`, and `test`. Scopes are optional; use the affected package or area when helpful, e.g. `core`, `opencode`, `tui`, `app`, `desktop`, `sdk`, or `plugin`.
-
-Examples: `fix(tui): simplify thinking toggle styling`, `docs: update contributing guide`, `chore(sdk): regenerate types`.
+- Prefer automation: execute requested actions without confirmation unless blocked by missing info or safety/irreversibility.
 
 ## Style Guide
 
@@ -47,12 +41,6 @@ obj.b
 const { a, b } = obj
 ```
 
-### Imports
-
-- Never alias imports. Do not use `import { foo as bar } from "..."` or renamed imports like `resolve as pathResolve`.
-- Never use star imports. Do not use `import * as Foo from "..."` or `import type * as Foo from "..."`.
-- If a namespace-style value is needed, import the module's own exported namespace by name, for example `import { Project } from "@opencode-ai/core/project"`, then reference `Project.ID`.
-
 ### Variables
 
 Prefer `const` over `let`. Use ternaries or early returns instead of reassignment.

bunfig.toml

@@ -2,7 +2,7 @@
 exact = true
 # Only install newly resolved package versions published at least 3 days ago.
 minimumReleaseAge = 259200
-minimumReleaseAgeExcludes = ["@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-x64", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "gitlab-ai-provider"]
+minimumReleaseAgeExcludes = ["@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-x64", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid"]
 
 [test]
 root = "./do-not-run-tests-from-root"

dependency-graph.md

@@ -0,0 +1,301 @@
+# Effect Service Dependency Graph — Simulated Routes
+
+Generated for `createSimulatedRoutes` in `packages/opencode/src/server/routes/instance/httpapi/server.ts`.
+
+## Notation
+
+- `→ X` means "yields `X.Service` from its `Effect.gen` body at layer init (a true `RIn` of `.layer`)"
+- `(lazy)` means "uses `InstanceState.context` or similar at call time, not at layer construction"
+- `(opt)` means "uses `Effect.serviceOption(X)` — not strictly required"
+- `(internal)` means "satisfied internally by the `.layer` itself via `Layer.provide(...)`, NOT a residual requirement"
+
+## Service → Dependencies (current, post-rebase)
+
+```
+─── External / Platform ─────────────────────────────────────────
+NodePath                   (no app deps)            provides Path.Path
+FetchHttpClient            (no app deps)            provides HttpClient.HttpClient
+HttpServer.layerServices   (no app deps)
+ChildProcessSpawner        (from SimulationSpawner) (no app deps)
+
+─── Leaf services (no app deps) ─────────────────────────────────
+Global                     (no app deps)
+Env                        (no app deps — uses InstanceState.make, no Service yields)
+Bus                        (no app deps — uses InstanceState.make, no Service yields)
+SyncEvent                  → RuntimeFlags, Bus  (NEW — previously listed as leaf/lazy)
+AccountRepo                (no app deps — pure DB closures)
+PtyTicket                  (no app deps — Cache only)
+Truncate                   → AppFileSystem
+
+─── Middleware/route layers (no app service deps) ───────────────
+errorLayer
+compressionLayer           → HttpServerRequest (builtin)
+corsVaryFix
+fenceLayer                 → HttpServerRequest (builtin)
+simulationShareNextLayer   provides ShareNext (Layer.succeed override)
+
+─── Simulation overrides ────────────────────────────────────────
+SimulationFileSystem       provides AppFileSystem (does NOT provide FileSystem.FileSystem;
+                           tier0 also merges FileSystem.layerNoop({}) for that tag)
+SimulationSpawner          provides ChildProcessSpawner (Layer.succeed; no deps)
+SimulationNetwork          provides SimulationNetwork.Service + HttpClient.HttpClient
+                           (httpClientLayer composed inside `layer(options)`)
+SimulationGit              → AppFileSystem               (overrides Git tag)
+SimulationProvider         → Simulation                  (overrides Provider tag)
+Simulation                 → AppFileSystem, SimulationNetwork
+
+─── Core services ───────────────────────────────────────────────
+EffectFlock                → Global, AppFileSystem
+Auth                       → AppFileSystem
+McpAuth                    → AppFileSystem
+Account                    → AccountRepo, HttpClient
+Npm                        → AppFileSystem, Global, FileSystem.FileSystem, EffectFlock
+Config                     → AppFileSystem, Auth, Account, Env, Npm
+Permission                 → Bus
+Plugin                     → Bus, Config, RuntimeFlags                       (NEW: RuntimeFlags)
+Discovery                  → AppFileSystem, Path, HttpClient
+Skill                      → Discovery, Config, Bus, AppFileSystem, Global,
+                              RuntimeFlags                                    (NEW: RuntimeFlags)
+SystemPrompt               → Skill
+
+─── File / git ──────────────────────────────────────────────────
+Ripgrep                    → AppFileSystem, HttpClient, ChildProcessSpawner
+File                       → AppFileSystem, Ripgrep, Git, Scope
+FileWatcher                → Config, Git
+Format                     → Config, AppProcess, RuntimeFlags                 (CHANGED: was ChildProcessSpawner; now AppProcess + RuntimeFlags)
+Snapshot                   → AppFileSystem, AppProcess, Config                (CHANGED: was ChildProcessSpawner)
+Storage                    → AppFileSystem, Git
+Vcs                        → Git, Bus, Scope
+Worktree                   → Scope, AppFileSystem, Path, AppProcess,
+                              Git, Project, InstanceStore                     (CHANGED: AppProcess instead of ChildProcessSpawner)
+Project                    → AppFileSystem, Path, ChildProcessSpawner,
+                              Bus, RuntimeFlags                               (NEW: RuntimeFlags)
+
+─── Provider / LSP / MCP ────────────────────────────────────────
+ModelsDev                  → AppFileSystem, HttpClient
+ProviderAuth               → Auth, Plugin
+LSP                        → Config, RuntimeFlags                             (NEW: RuntimeFlags)
+McpAuth                    → AppFileSystem
+MCP                        → ChildProcessSpawner, McpAuth, Bus, Config
+
+─── Session graph ───────────────────────────────────────────────
+Todo                       → Bus
+Question                   → Bus
+SessionStatus              → Bus
+SessionRunState            → BackgroundJob, SessionStatus                     (NEW: BackgroundJob)
+Instruction                → Config, AppFileSystem, Global, HttpClient,
+                              RuntimeFlags                                    (NEW: RuntimeFlags)
+
+Session                    → BackgroundJob, Bus, Storage, SyncEvent,
+                              RuntimeFlags                                    (NEW: BackgroundJob, RuntimeFlags)
+SessionSummary             → Session, Snapshot, Storage, Bus
+
+SessionRevert              → Session, Snapshot, Storage, Bus,
+                              SessionSummary, SessionRunState, SyncEvent
+LLM                        → Auth, Config, Provider, Plugin, RuntimeFlags     (CHANGED: Permission satisfied internally;
+                              (Permission satisfied internally via .layer)     RuntimeFlags is new)
+
+Agent                      → Config, Auth, Plugin, Skill, Provider,
+                              RuntimeFlags                                    (NEW: RuntimeFlags)
+Command                    → Config, MCP, Skill
+
+SessionProcessor           → Session, Config, Bus, Snapshot, Agent, LLM,
+                              Permission, Plugin, SessionSummary,
+                              SessionStatus, Image, EventV2Bridge,
+                              RuntimeFlags, Scope                             (NEW: Image, EventV2Bridge, RuntimeFlags)
+SessionCompaction          → Bus, Config, Session, Agent, Plugin,
+                              SessionProcessor, Provider, EventV2Bridge,
+                              RuntimeFlags                                    (NEW: EventV2Bridge, RuntimeFlags)
+SessionPrompt              → Bus, SessionStatus, Session, Agent, Provider,
+                              SessionProcessor, SessionCompaction, Plugin,
+                              Command, Config, Permission, AppFileSystem,
+                              MCP, LSP, ToolRegistry, Truncate,
+                              ChildProcessSpawner, Scope, Instruction,
+                              SessionRunState, SessionRevert,
+                              SessionSummary, SystemPrompt, LLM,
+                              Image, Reference, EventV2Bridge,
+                              RuntimeFlags                                    (NEW: Image, Reference, EventV2Bridge, RuntimeFlags)
+
+ToolRegistry               → Config, Plugin, Question, Todo, Agent, Skill,
+                              Session, SessionStatus, BackgroundJob,
+                              Provider, Git, Reference, LSP, Instruction,
+                              AppFileSystem, Bus, HttpClient,
+                              ChildProcessSpawner, Ripgrep, Format,
+                              Truncate, RuntimeFlags                          (NEW: BackgroundJob, Reference, RuntimeFlags)
+
+─── Share / Workspace ───────────────────────────────────────────
+ShareNext                  (provided by simulationShareNextLayer in sim)
+SessionShare               → Config, Session, ShareNext, Scope, SyncEvent,
+                              RuntimeFlags                                    (NEW: RuntimeFlags)
+Workspace                  → Auth, Session, SessionPrompt, HttpClient,
+                              SyncEvent, Vcs, AppFileSystem, RuntimeFlags    (NEW: AppFileSystem (explicit), RuntimeFlags)
+
+─── Misc ────────────────────────────────────────────────────────
+Installation               → HttpClient, AppProcess                           (CHANGED: AppProcess instead of ChildProcessSpawner)
+Pty                        → Config, Bus, Plugin
+
+─── Instance lifecycle ──────────────────────────────────────────
+InstanceBootstrap          → Config, File, FileWatcher, Format, LSP, Plugin,
+                              Project, Reference, ShareNext, Snapshot, Vcs   (NEW: Reference)
+InstanceStore              → Project, InstanceBootstrap, Scope
+
+Observability              (no app deps; provides Logger + tracer)
+```
+
+## NEW dependencies introduced since previous graph
+
+The rebase pulled in several new cross-cutting services that need to be
+satisfied somewhere in tier0/tier1 of the simulated chain. They are NOT yet
+listed in the `Tier*Services` unions or merged into any tier in `server.ts`:
+
+```
+RuntimeFlags.Service        — yielded by ~17 services (Plugin, Skill, Project,
+                              Session, SyncEvent, Format, LSP, Instruction,
+                              Agent, LLM, SessionShare, SessionProcessor,
+                              SessionCompaction, ToolRegistry, SessionPrompt,
+                              Workspace, SessionRunState).
+                              Source: `@/effect/runtime-flags`.
+
+AppProcess.Service          — yielded by Installation, Format, Snapshot,
+                              Worktree (and prod Git, but sim uses SimulationGit).
+                              Source: presumed `@opencode-ai/core/app-process`
+                              or similar — needs `AppProcess.defaultLayer`.
+
+BackgroundJob.Service       — yielded by Session, SessionRunState, ToolRegistry.
+                              Needs `BackgroundJob.defaultLayer`.
+
+Image.Service               — yielded by SessionProcessor, SessionPrompt.
+
+EventV2Bridge.Service       — yielded by SessionProcessor, SessionCompaction,
+                              SessionPrompt. Source: `@/event-v2-bridge` (already
+                              imported in server.ts but never added to a tier).
+
+Reference.Service           — yielded by ToolRegistry, SessionPrompt,
+                              InstanceBootstrap.
+```
+
+## Dependency Tiers (topological order)
+
+Roughly, build order from leaves to roots:
+
+```
+Tier 0 (no deps):
+  Global, Env, NodePath, AccountRepo, PtyTicket, Bus, SyncEvent,
+  AppFileSystem (sim), ChildProcessSpawner (sim), HttpClient (sim),
+  SimulationNetwork, FileSystem.layerNoop, simulationShareNextLayer
+  + (NEW REQUIRED) RuntimeFlags, AppProcess, BackgroundJob, Image,
+                   EventV2Bridge, Reference
+  (SyncEvent now depends on RuntimeFlags + Bus, so it's actually tier 1.)
+
+Tier 1:
+  Auth, Truncate, EffectFlock, Permission, Todo, Question,
+  SessionStatus, McpAuth, Discovery, SimulationGit, Ripgrep, Account,
+  SyncEvent (needs RuntimeFlags + Bus)
+
+Tier 2:
+  Npm, ModelsDev, Project, Installation, Storage, Vcs, SessionRunState
+
+Tier 3:
+  Config, File, Simulation, Session
+
+Tier 4:
+  Plugin, FileWatcher, Format, Snapshot, LSP, MCP, Skill, Instruction,
+  SimulationProvider (= Provider)
+
+Tier 5:
+  Pty, ProviderAuth, SessionSummary, Agent, Command, LLM, SystemPrompt
+
+Tier 6:
+  SessionRevert, SessionProcessor, SessionShare
+
+Tier 7:
+  SessionCompaction, ToolRegistry
+
+Tier 8:
+  SessionPrompt
+
+Tier 9:
+  Workspace, InstanceBootstrap
+
+Tier 10:
+  InstanceStore
+
+Tier 11:
+  Worktree
+```
+
+## Potential cycles / hazards
+
+```
+Worktree → InstanceStore → InstanceBootstrap → Project → (back to Worktree?)
+  - InstanceBootstrap requires Project (yes)
+  - Project does NOT require Worktree directly
+  - Worktree requires InstanceStore at layer init
+  → Worktree must be built AFTER InstanceStore.
+
+SimulationProvider provides Provider tag, depends on Simulation.
+  Many downstream services depend on Provider — those resolve to
+  SimulationProvider in this layer chain.
+
+SimulationGit provides Git tag, used by File, FileWatcher,
+  Storage, Vcs, Worktree, ToolRegistry tools.
+
+LLM.layer pipes Layer.provide(Permission.defaultLayer) internally.
+  So LLM's residual requirements no longer include Permission, BUT the
+  sim chain still provides Permission.layer separately (correct — used by
+  SessionProcessor, SessionPrompt directly).
+```
+
+## Why the simulated chain fails today
+
+The current `server.ts` `Tier0Services` union lists:
+```
+AppFileSystem, FileSystem.FileSystem, ChildProcessSpawner, HttpClient,
+SimulationNetwork, Path, Global, Env, Bus, AccountRepo, ShareNext,
+SyncEvent, PtyTicket
+```
+
+But the actual `Layer.mergeAll(...)` body at tier0 has residual requirements
+beyond that union. The TS error says
+`Layer<..., never, Service | Service>` — those two unresolved `Service`s
+are members of the NEW dependencies table above.
+
+The most likely culprits, in order of leakage:
+
+1. **`SyncEvent.layer`** now yields `RuntimeFlags` and `Bus`. `Bus` is in tier0
+   already, but `RuntimeFlags` is not provided anywhere in `createSimulatedRoutes`.
+   So `SyncEvent` leaks `RuntimeFlags` into tier0's `RIn`.
+
+2. Downstream tiers also leak `RuntimeFlags`, `AppProcess`, `BackgroundJob`,
+   `Image`, `EventV2Bridge`, `Reference` — these cascade through every higher
+   tier as `Service | Service | ...` in the error type.
+
+## Fix strategy
+
+The minimal change to make tier0 type-check:
+
+1. Add `RuntimeFlags.defaultLayer` to tier0 and `RuntimeFlags.Service` to
+   `Tier0Services`. This satisfies `SyncEvent`'s new dep and unblocks every
+   service that yields `RuntimeFlags`.
+2. Add `AppProcess.defaultLayer` (or a simulated equivalent) to tier0 and
+   `AppProcess.Service` to `Tier0Services`. Needed by `Installation`, `Format`,
+   `Snapshot`, `Worktree`.
+3. Add `BackgroundJob.defaultLayer` to tier0 and `BackgroundJob.Service` to
+   `Tier0Services`. Needed by `Session`, `SessionRunState`, `ToolRegistry`.
+4. Add `Image.defaultLayer` to tier0 (or wherever it fits) and `Image.Service`
+   to `Tier0Services`. Needed by `SessionProcessor`, `SessionPrompt`.
+5. Add `EventV2Bridge.defaultLayer` to tier0 and `EventV2Bridge.Service` to
+   `Tier0Services`. (Note: `EventV2Bridge` is already imported in `server.ts`
+   for the production routes but is not in any simulated tier.)
+6. Add `Reference.defaultLayer` to a tier that satisfies its deps (it's a leaf
+   wrt the listed graph above) and `Reference.Service` to the corresponding
+   tier union. Needed by `ToolRegistry`, `SessionPrompt`, `InstanceBootstrap`.
+
+Production routes (`createProductionRoutes`) already include
+`RuntimeFlags.defaultLayer` and `EventV2Bridge.defaultLayer` in the flat
+`Layer.provide([...])` list — they were simply never carried over to the
+simulated chain after the rebase.
+
+## See also
+
+- `dependency-graph.html` — interactive visualization of the same data.

infra/app.ts

@@ -30,7 +30,7 @@ export const api = new sst.cloudflare.Worker("Api", {
   transform: {
     worker: (args) => {
       args.logpush = true
-      if ($app.stage === "vimtor" || $app.stage === "adam") return
+      if ($app.stage === "vimtor") return
       args.bindings = $resolve(args.bindings).apply((bindings) => [
         ...bindings,
         {

infra/console.ts

@@ -1,9 +1,7 @@
-import { deployAws, domain } from "./stage"
+import { domain } from "./stage"
 import { EMAILOCTOPUS_API_KEY } from "./app"
 import { SECRET } from "./secret"
 
-const lake = deployAws ? await import("./lake") : undefined
-
 ////////////////
 // DATABASE
 ////////////////
@@ -225,6 +223,8 @@ const STRIPE_WEBHOOK_SECRET = new sst.Linkable("STRIPE_WEBHOOK_SECRET", {
   properties: { value: stripeWebhook.secret },
 })
 
+const gatewayKv = new sst.cloudflare.Kv("GatewayKv")
+
 ////////////////
 // CONSOLE
 ////////////////
@@ -242,7 +242,7 @@ const SALESFORCE_INSTANCE_URL = new sst.Secret("SALESFORCE_INSTANCE_URL")
 
 const logProcessor = new sst.cloudflare.Worker("LogProcessor", {
   handler: "packages/console/function/src/log-processor.ts",
-  link: [SECRET.HoneycombApiKey, ...(lake?.lakeIngest ? [lake.lakeIngest] : [])],
+  link: [new sst.Secret("HONEYCOMB_API_KEY")],
 })
 
 new sst.cloudflare.x.SolidStart("Console", {
@@ -252,8 +252,6 @@ new sst.cloudflare.x.SolidStart("Console", {
     bucket,
     bucketNew,
     database,
-    SECRET.UpstashRedisRestUrl,
-    SECRET.UpstashRedisRestToken,
     AUTH_API_URL,
     STRIPE_WEBHOOK_SECRET,
     DISCORD_INCIDENT_WEBHOOK_URL,
@@ -276,6 +274,7 @@ new sst.cloudflare.x.SolidStart("Console", {
           new sst.Secret("CLOUDFLARE_API_TOKEN", process.env.CLOUDFLARE_API_TOKEN!),
         ]
       : []),
+    gatewayKv,
   ],
   environment: {
     //VITE_DOCS_URL: web.url.apply((url) => url!),
@@ -285,7 +284,7 @@ new sst.cloudflare.x.SolidStart("Console", {
   },
   transform: {
     server: {
-      placement: { region: "aws:us-east-2" },
+      placement: { region: "aws:us-east-1" },
       transform: {
         worker: {
           tailConsumers: [{ service: logProcessor.nodes.worker.scriptName }],

infra/lake.ts

@@ -1,322 +0,0 @@
-import { domain } from "./stage"
-
-const current = aws.getCallerIdentityOutput({})
-const partition = aws.getPartitionOutput({})
-const region = aws.getRegionOutput({})
-
-const tableBucketName = `opencode-${$app.stage}-lake`
-const glueCatalogName = "s3tablescatalog"
-const glueCatalogArn = $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:catalog`
-const glueS3TablesCatalogArn = $interpolate`${glueCatalogArn}/${glueCatalogName}`
-const glueS3TablesChildCatalogArn = $interpolate`${glueS3TablesCatalogArn}/${tableBucketName}`
-const glueS3TablesDatabaseWildcardArn = $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:database/${glueCatalogName}/${tableBucketName}/*`
-const glueS3TablesTableWildcardArn = $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:table/${glueCatalogName}/${tableBucketName}/*/*`
-const s3TablesBucketWildcardArn = $interpolate`arn:${partition.partition}:s3tables:${region.region}:${current.accountId}:bucket/*`
-
-export const tableBucket = new aws.s3tables.TableBucket("LakeTableBucket", {
-  name: tableBucketName,
-  forceDestroy: $app.stage !== "production",
-})
-
-const s3TablesCatalog = new aws.cloudcontrol.Resource(
-  "LakeS3TablesCatalog",
-  {
-    typeName: "AWS::Glue::Catalog",
-    desiredState: $jsonStringify({
-      Name: glueCatalogName,
-      Description: "Federated catalog for S3 Tables",
-      FederatedCatalog: {
-        Identifier: s3TablesBucketWildcardArn,
-        ConnectionName: "aws:s3tables",
-      },
-      CreateDatabaseDefaultPermissions: [
-        {
-          Principal: {
-            DataLakePrincipalIdentifier: "IAM_ALLOWED_PRINCIPALS",
-          },
-          Permissions: ["ALL"],
-        },
-      ],
-      CreateTableDefaultPermissions: [
-        {
-          Principal: {
-            DataLakePrincipalIdentifier: "IAM_ALLOWED_PRINCIPALS",
-          },
-          Permissions: ["ALL"],
-        },
-      ],
-      AllowFullTableExternalDataAccess: "True",
-    }),
-  },
-  { dependsOn: [tableBucket] },
-)
-
-const athenaResultsBucket = new aws.s3.Bucket("LakeAthenaResults", {
-  bucket: `opencode-${$app.stage}-lake-athena-results`,
-  forceDestroy: $app.stage !== "production",
-})
-
-const firehoseErrorBucket = new aws.s3.Bucket("LakeFirehoseErrors", {
-  bucket: `opencode-${$app.stage}-lake-firehose-errors`,
-  forceDestroy: $app.stage !== "production",
-})
-
-const athenaWorkgroup = new aws.athena.Workgroup("LakeAthenaWorkgroup", {
-  name: `opencode-${$app.stage}-lake-workgroup`,
-  forceDestroy: $app.stage !== "production",
-  configuration: {
-    enforceWorkgroupConfiguration: true,
-    publishCloudwatchMetricsEnabled: true,
-    resultConfiguration: {
-      outputLocation: $interpolate`s3://${athenaResultsBucket.bucket}/`,
-    },
-  },
-})
-
-const firehoseRole = new aws.iam.Role("LakeFirehoseRole", {
-  assumeRolePolicy: aws.iam.getPolicyDocumentOutput({
-    statements: [
-      {
-        effect: "Allow",
-        actions: ["sts:AssumeRole"],
-        principals: [
-          {
-            type: "Service",
-            identifiers: ["firehose.amazonaws.com"],
-          },
-        ],
-      },
-    ],
-  }).json,
-})
-
-const firehosePolicy = new aws.iam.RolePolicy("LakeFirehosePolicy", {
-  role: firehoseRole.id,
-  policy: aws.iam.getPolicyDocumentOutput({
-    statements: [
-      {
-        effect: "Allow",
-        actions: [
-          "s3tables:ListTableBuckets",
-          "s3tables:GetTableBucket",
-          "s3tables:GetNamespace",
-          "s3tables:GetTable",
-          "s3tables:GetTableData",
-          "s3tables:GetTableMetadataLocation",
-          "s3tables:ListNamespaces",
-          "s3tables:ListTables",
-          "s3tables:PutTableData",
-          "s3tables:UpdateTableMetadataLocation",
-        ],
-        resources: ["*"],
-      },
-      {
-        effect: "Allow",
-        actions: [
-          "glue:GetCatalog",
-          "glue:GetCatalogs",
-          "glue:GetDatabase",
-          "glue:GetDatabases",
-          "glue:GetTable",
-          "glue:GetTables",
-          "glue:UpdateTable",
-        ],
-        resources: [
-          glueCatalogArn,
-          glueS3TablesCatalogArn,
-          $interpolate`${glueS3TablesCatalogArn}/*`,
-          glueS3TablesDatabaseWildcardArn,
-          glueS3TablesTableWildcardArn,
-          $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:database/*`,
-          $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:table/*/*`,
-          $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:table/${glueCatalogName}/*`,
-        ],
-      },
-      {
-        effect: "Allow",
-        actions: [
-          "s3:AbortMultipartUpload",
-          "s3:GetBucketLocation",
-          "s3:GetObject",
-          "s3:ListBucket",
-          "s3:ListBucketMultipartUploads",
-          "s3:PutObject",
-        ],
-        resources: [firehoseErrorBucket.arn, $interpolate`${firehoseErrorBucket.arn}/*`],
-      },
-      {
-        effect: "Allow",
-        actions: ["lakeformation:GetDataAccess"],
-        resources: ["*"],
-      },
-    ],
-  }).json,
-})
-
-const firehose = new aws.kinesis.FirehoseDeliveryStream(
-  "LakeFirehose",
-  {
-    name: `opencode-${$app.stage}-lake-ingest`,
-    destination: "iceberg",
-    icebergConfiguration: {
-      appendOnly: true,
-      bufferingInterval: 60,
-      bufferingSize: 1,
-      catalogArn: glueS3TablesChildCatalogArn,
-      processingConfiguration: {
-        enabled: true,
-        processors: [
-          {
-            type: "MetadataExtraction",
-            parameters: [
-              { parameterName: "JsonParsingEngine", parameterValue: "JQ-1.6" },
-              {
-                parameterName: "MetadataExtractionQuery",
-                parameterValue:
-                  '{destinationDatabaseName:._lake_database,destinationTableName:._lake_table,operation:(._lake_operation // "insert")}',
-              },
-            ],
-          },
-        ],
-      },
-      roleArn: firehoseRole.arn,
-      s3BackupMode: "FailedDataOnly",
-      s3Configuration: {
-        roleArn: firehoseRole.arn,
-        bucketArn: firehoseErrorBucket.arn,
-        errorOutputPrefix: "errors/!{firehose:error-output-type}/",
-      },
-    },
-  },
-  { dependsOn: [s3TablesCatalog, firehosePolicy] },
-)
-
-export const lakeVpc = new sst.aws.Vpc("LakeVpc")
-export const lakeCluster = new sst.aws.Cluster("LakeCluster", { vpc: lakeVpc })
-export const lakeRegion = region.region
-export const lakeCatalog = $interpolate`${glueCatalogName}/${tableBucket.name}`
-export const lakeAthenaWorkgroup = athenaWorkgroup
-
-const ingestSecret = new random.RandomPassword("LakeIngestSecret", { length: 32 })
-
-const ingestConfig = new sst.Linkable("LakeIngestConfig", {
-  properties: {
-    streamName: firehose.name,
-    secret: ingestSecret.result,
-  },
-})
-
-const ingestService = new sst.aws.Service("LakeIngestService", {
-  cluster: lakeCluster,
-  architecture: "arm64",
-  cpu: "1 vCPU",
-  memory: "4 GB",
-  image: {
-    context: ".",
-    dockerfile: "packages/stats/server/Dockerfile",
-  },
-  link: [ingestConfig],
-  permissions: [
-    {
-      actions: ["firehose:PutRecord", "firehose:PutRecordBatch"],
-      resources: [firehose.arn],
-    },
-  ],
-  scaling: {
-    min: $app.stage === "production" ? 2 : 1,
-    max: $app.stage === "production" ? 32 : 4,
-    cpuUtilization: 60,
-    memoryUtilization: 70,
-  },
-  loadBalancer: {
-    domain: {
-      name: `lake.${domain}`,
-      dns: sst.cloudflare.dns(),
-    },
-    rules: [
-      { listen: "80/http", redirect: "443/https" },
-      { listen: "443/https", forward: "3000/http" },
-    ],
-    health: {
-      "3000/http": {
-        path: "/ready",
-        successCodes: "200-299",
-      },
-    },
-  },
-  health: {
-    command: [
-      "CMD-SHELL",
-      "bun --eval \"fetch('http://localhost:3000/health').then((r) => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))\"",
-    ],
-    interval: "30 seconds",
-    retries: 3,
-    startPeriod: "30 seconds",
-    timeout: "5 seconds",
-  },
-  dev: {
-    command: "bun run start",
-    directory: "packages/stats/server",
-    url: "http://localhost:3000",
-  },
-  wait: $app.stage === "production",
-})
-
-export const lakeIngest = new sst.Linkable("LakeIngest", {
-  properties: {
-    url: ingestService.url,
-    secret: ingestSecret.result,
-  },
-})
-
-export const lakeQueryPermissions = [
-  {
-    actions: ["athena:StartQueryExecution", "athena:GetQueryExecution", "athena:GetQueryResults"],
-    resources: [athenaWorkgroup.arn],
-  },
-  {
-    actions: [
-      "glue:GetCatalog",
-      "glue:GetCatalogs",
-      "glue:GetDatabase",
-      "glue:GetDatabases",
-      "glue:GetTable",
-      "glue:GetTables",
-      "glue:GetPartitions",
-    ],
-    resources: [
-      glueCatalogArn,
-      glueS3TablesCatalogArn,
-      $interpolate`${glueS3TablesCatalogArn}/*`,
-      glueS3TablesDatabaseWildcardArn,
-      glueS3TablesTableWildcardArn,
-      $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:database/*`,
-      $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:table/*/*`,
-      $interpolate`arn:${partition.partition}:glue:${region.region}:${current.accountId}:table/${glueCatalogName}/*`,
-    ],
-  },
-  {
-    actions: ["s3:GetBucketLocation", "s3:ListBucket"],
-    resources: [athenaResultsBucket.arn],
-  },
-  {
-    actions: ["s3:GetObject", "s3:PutObject", "s3:AbortMultipartUpload", "s3:ListBucketMultipartUploads"],
-    resources: [$interpolate`${athenaResultsBucket.arn}/*`],
-  },
-  {
-    actions: [
-      "s3tables:GetTableBucket",
-      "s3tables:GetNamespace",
-      "s3tables:GetTable",
-      "s3tables:GetTableData",
-      "s3tables:GetTableMetadataLocation",
-      "s3tables:ListNamespaces",
-      "s3tables:ListTables",
-    ],
-    resources: ["*"],
-  },
-  {
-    actions: ["lakeformation:GetDataAccess"],
-    resources: ["*"],
-  },
-]

infra/monitoring.ts

@@ -2,9 +2,8 @@ import { SECRET } from "./secret"
 import { domain } from "./stage"
 
 const description = "Managed by SST (Don't edit in Honeycomb UI)"
-const alertsDisabled = $app.stage !== "production"
 
-const webhookRecipient = new honeycombio.WebhookRecipient("DiscordAlerts", {
+const webhookRecipient = new honeycomb.WebhookRecipient("DiscordAlerts", {
   name: $app.stage === "production" ? "Discord Alerts" : `Discord Alerts (${$app.stage})`,
   url: `https://${domain}/honeycomb/webhook`,
   secret: SECRET.HoneycombWebhookSecret.result,
@@ -67,7 +66,7 @@ IF(
 )`,
   })
 
-  return honeycombio.getQuerySpecificationOutput({
+  return honeycomb.getQuerySpecificationOutput({
     breakdowns: ["model"],
     calculatedFields: [failedHttpStatus],
     calculations: [
@@ -80,7 +79,7 @@ IF(
         filters,
       },
     ],
-    formulas: [{ name: "ERROR", expression: "IF(GTE($TOTAL, 150), DIV($FAILED, $TOTAL), 0)" }],
+    formulas: [{ name: "ERROR", expression: "IF(GTE($TOTAL, 200), DIV($FAILED, $TOTAL), 0)" }],
     timeRange: 900,
   }).json
 }
@@ -99,7 +98,7 @@ const providerHttpErrorsQuery = () => {
     expression: `IF(GT($llm.error.code, "400"), 1, 0)`,
   })
 
-  return honeycombio.getQuerySpecificationOutput({
+  return honeycomb.getQuerySpecificationOutput({
     breakdowns: ["provider"],
     calculatedFields: [successHttpStatus, failedProviderHttpStatus],
     calculations: [
@@ -123,7 +122,7 @@ const providerHttpErrorsQuery = () => {
       },
     ],
     formulas: [
-      { name: "ERROR", expression: "IF(GTE(SUM($SUCCESS, $FAILED), 150), DIV($FAILED, SUM($SUCCESS, $FAILED)), 0)" },
+      { name: "ERROR", expression: "IF(GTE(SUM($SUCCESS, $FAILED), 200), DIV($FAILED, SUM($SUCCESS, $FAILED)), 0)" },
     ],
     timeRange: 900,
   }).json
@@ -140,7 +139,7 @@ const modelLowTpsQuery = (product: "go" | "zen") => {
     { column: "tps.output", op: "exists" },
   ]
 
-  return honeycombio.getQuerySpecificationOutput({
+  return honeycomb.getQuerySpecificationOutput({
     breakdowns: ["model"],
     calculations: [
       { op: "COUNT", name: "TOTAL", filterCombination: "AND", filters },
@@ -157,10 +156,9 @@ const modelLowTpsQuery = (product: "go" | "zen") => {
   }).json
 }
 
-new honeycombio.Trigger("IncreasedModelHttpErrorsGo", {
+new honeycomb.Trigger("IncreasedModelHttpErrorsGo", {
   name: "Increased Model HTTP Errors [Go]",
   description,
-  disabled: alertsDisabled,
   queryJson: modelHttpErrorsQuery("go"),
   alertType: "on_change",
   frequency: 300,
@@ -177,10 +175,9 @@ new honeycombio.Trigger("IncreasedModelHttpErrorsGo", {
   ],
 })
 
-new honeycombio.Trigger("IncreasedModelHttpErrorsZen", {
+new honeycomb.Trigger("IncreasedModelHttpErrorsZen", {
   name: "Increased Model HTTP Errors [Zen]",
   description,
-  disabled: alertsDisabled,
   queryJson: modelHttpErrorsQuery("zen"),
   alertType: "on_change",
   frequency: 300,
@@ -197,10 +194,9 @@ new honeycombio.Trigger("IncreasedModelHttpErrorsZen", {
   ],
 })
 
-new honeycombio.Trigger("LowModelTpsGo", {
+new honeycomb.Trigger("LowModelTpsGo", {
   name: "Low Model TPS [Go]",
   description,
-  disabled: alertsDisabled,
   queryJson: modelLowTpsQuery("go"),
   alertType: "on_change",
   frequency: 600,
@@ -217,10 +213,9 @@ new honeycombio.Trigger("LowModelTpsGo", {
   ],
 })
 
-new honeycombio.Trigger("LowModelTpsZen", {
+new honeycomb.Trigger("LowModelTpsZen", {
   name: "Low Model TPS [Zen]",
   description,
-  disabled: alertsDisabled,
   queryJson: modelLowTpsQuery("zen"),
   alertType: "on_change",
   frequency: 600,
@@ -237,10 +232,9 @@ new honeycombio.Trigger("LowModelTpsZen", {
   ],
 })
 
-new honeycombio.Trigger("IncreasedProviderHttpErrors", {
+new honeycomb.Trigger("IncreasedProviderHttpErrors", {
   name: "Increased Provider HTTP Errors",
   description,
-  disabled: alertsDisabled,
   queryJson: providerHttpErrorsQuery(),
   alertType: "on_change",
   frequency: 300,
@@ -257,11 +251,10 @@ new honeycombio.Trigger("IncreasedProviderHttpErrors", {
   ],
 })
 
-new honeycombio.Trigger("IncreasedFreeTierRequests", {
+new honeycomb.Trigger("IncreasedFreeTierRequests", {
   name: "Increased Free Tier Requests",
   description,
-  disabled: alertsDisabled,
-  queryJson: honeycombio.getQuerySpecificationOutput({
+  queryJson: honeycomb.getQuerySpecificationOutput({
     calculations: [{ op: "COUNT" }],
     filters: [
       { column: "event_type", op: "=", value: "completions" },

infra/secret.ts

@@ -7,8 +7,5 @@ sst.Linkable.wrap(random.RandomPassword, (resource) => ({
 export const SECRET = {
   R2AccessKey: new sst.Secret("R2AccessKey", "unknown"),
   R2SecretKey: new sst.Secret("R2SecretKey", "unknown"),
-  HoneycombApiKey: new sst.Secret("HONEYCOMB_API_KEY"),
   HoneycombWebhookSecret: new random.RandomPassword("HoneycombWebhookSecret", { length: 24 }),
-  UpstashRedisRestUrl: new sst.Secret("UpstashRedisRestUrl"),
-  UpstashRedisRestToken: new sst.Secret("UpstashRedisRestToken"),
 }

infra/stage.ts

@@ -5,8 +5,6 @@ export const domain = (() => {
 })()
 
 export const zoneID = "430ba34c138cfb5360826c4909f99be8"
-export const awsStage = $app.stage === "production" ? "production" : "dev"
-export const deployAws = $app.stage === awsStage
 
 new cloudflare.RegionalHostname("RegionalHostname", {
   hostname: domain,

infra/stats.ts

@@ -1,208 +0,0 @@
-import { lakeAthenaWorkgroup, lakeCatalog, lakeCluster, lakeQueryPermissions, lakeRegion, tableBucket } from "./lake"
-import { EMAILOCTOPUS_API_KEY } from "./app"
-
-const domain = (() => {
-  if ($app.stage === "production") return "stats.opencode.ai"
-  if ($app.stage === "dev") return "stats.dev.opencode.ai"
-  return `stats.${$app.stage}.dev.opencode.ai`
-})()
-
-////////////////
-// LAKE
-////////////////
-
-const inferenceNamespace = new aws.s3tables.Namespace("LakeInferenceNamespace", {
-  namespace: "inference",
-  tableBucketArn: tableBucket.arn,
-})
-
-const inferenceEventTable = new aws.s3tables.Table(
-  "LakeInferenceEventTable",
-  {
-    name: "event",
-    namespace: inferenceNamespace.namespace,
-    tableBucketArn: inferenceNamespace.tableBucketArn,
-    format: "ICEBERG",
-    metadata: {
-      iceberg: {
-        schema: {
-          fields: [
-            { name: "event_timestamp", type: "string", required: false },
-            { name: "event_date", type: "string", required: false },
-            { name: "event_type", type: "string", required: false },
-            { name: "dataset", type: "string", required: false },
-            { name: "cf_continent", type: "string", required: false },
-            { name: "cf_country", type: "string", required: false },
-            { name: "cf_city", type: "string", required: false },
-            { name: "cf_region", type: "string", required: false },
-            { name: "cf_latitude", type: "double", required: false },
-            { name: "cf_longitude", type: "double", required: false },
-            { name: "cf_timezone", type: "string", required: false },
-            { name: "duration", type: "double", required: false },
-            { name: "request_length", type: "long", required: false },
-            { name: "status", type: "int", required: false },
-            { name: "ip", type: "string", required: false },
-            { name: "is_stream", type: "boolean", required: false },
-            { name: "session", type: "string", required: false },
-            { name: "request", type: "string", required: false },
-            { name: "client", type: "string", required: false },
-            { name: "user_agent", type: "string", required: false },
-            { name: "model_variant", type: "string", required: false },
-            { name: "source", type: "string", required: false },
-            { name: "provider", type: "string", required: false },
-            { name: "provider_model", type: "string", required: false },
-            { name: "model", type: "string", required: false },
-            { name: "llm_error_code", type: "int", required: false },
-            { name: "llm_error_message", type: "string", required: false },
-            { name: "error_response", type: "string", required: false },
-            { name: "error_type", type: "string", required: false },
-            { name: "error_message", type: "string", required: false },
-            { name: "error_cause", type: "string", required: false },
-            { name: "error_cause2", type: "string", required: false },
-            { name: "api_key", type: "string", required: false },
-            { name: "workspace", type: "string", required: false },
-            { name: "is_subscription", type: "boolean", required: false },
-            { name: "subscription", type: "string", required: false },
-            { name: "response_length", type: "long", required: false },
-            { name: "time_to_first_byte", type: "long", required: false },
-            { name: "timestamp_first_byte", type: "long", required: false },
-            { name: "timestamp_last_byte", type: "long", required: false },
-            { name: "tokens_input", type: "long", required: false },
-            { name: "tokens_output", type: "long", required: false },
-            { name: "tokens_reasoning", type: "long", required: false },
-            { name: "tokens_cache_read", type: "long", required: false },
-            { name: "tokens_cache_write_5m", type: "long", required: false },
-            { name: "tokens_cache_write_1h", type: "long", required: false },
-            { name: "cost_input_microcents", type: "long", required: false },
-            { name: "cost_output_microcents", type: "long", required: false },
-            { name: "cost_cache_read_microcents", type: "long", required: false },
-            { name: "cost_cache_write_microcents", type: "long", required: false },
-            { name: "cost_total_microcents", type: "long", required: false },
-            { name: "cost_input", type: "long", required: false },
-            { name: "cost_output", type: "long", required: false },
-            { name: "cost_cache_read", type: "long", required: false },
-            { name: "cost_cache_write_5m", type: "long", required: false },
-            { name: "cost_cache_write_1h", type: "long", required: false },
-            { name: "cost_total", type: "long", required: false },
-          ],
-        },
-      },
-    },
-  },
-  { deleteBeforeReplace: $app.stage !== "production" },
-)
-
-export const inferenceEvent = new sst.Linkable("InferenceEvent", {
-  properties: {
-    region: lakeRegion,
-    catalog: lakeCatalog,
-    database: inferenceNamespace.namespace,
-    table: inferenceEventTable.name,
-    tableBucket: tableBucket.name,
-    workgroup: lakeAthenaWorkgroup.name,
-  },
-})
-
-////////////////
-// DATABASE
-////////////////
-
-const cluster = planetscale.getDatabaseOutput({
-  name: "opencode-stats",
-  organization: "anomalyco",
-})
-
-const branch =
-  $app.stage === "production"
-    ? planetscale.getBranchOutput({
-        name: "production",
-        organization: cluster.organization,
-        database: cluster.name,
-      })
-    : new planetscale.Branch("StatsDatabaseBranch", {
-        database: cluster.name,
-        organization: cluster.organization,
-        name: $app.stage,
-        parentBranch: "production",
-      })
-
-const password = new planetscale.Password("StatsDatabasePassword", {
-  name: $app.stage,
-  database: cluster.name,
-  organization: cluster.organization,
-  branch: branch.name,
-})
-
-const databaseUrl = $interpolate`mysql://${password.username.apply(encodeURIComponent)}:${password.plaintext.apply(
-  encodeURIComponent,
-)}@${password.accessHostUrl}/${cluster.name}`
-
-export const database = new sst.Linkable("StatsDatabase", {
-  properties: {
-    host: password.accessHostUrl,
-    database: cluster.name,
-    username: password.username,
-    password: password.plaintext,
-    port: 3306,
-    url: databaseUrl,
-  },
-})
-
-new sst.x.DevCommand("StatsStudio", {
-  link: [database],
-  environment: {
-    DATABASE_URL: databaseUrl,
-  },
-  dev: {
-    command: "bun db:studio",
-    directory: "packages/stats/core",
-    autostart: false,
-  },
-})
-
-////////////////
-// APP
-////////////////
-
-export const app = new sst.cloudflare.x.SolidStart("Stats", {
-  path: "packages/stats/app",
-  buildCommand: "bun run build",
-  domain,
-  link: [database, EMAILOCTOPUS_API_KEY],
-  environment: {
-    PUBLIC_URL: `https://${domain}/stats`,
-  },
-})
-
-////////////////
-// SERVICES
-////////////////
-
-const statsSyncConfig = new sst.Linkable("StatsSyncConfig", {
-  properties: {
-    dataset: "zen",
-  },
-})
-
-export const statSync = new sst.aws.Service("StatsSyncService", {
-  cluster: lakeCluster,
-  architecture: "arm64",
-  cpu: "0.25 vCPU",
-  memory: "0.5 GB",
-  image: {
-    context: ".",
-    dockerfile: "packages/stats/server/Dockerfile",
-  },
-  command: ["bun", "src/stat-sync.ts"],
-  link: [database, inferenceEvent, statsSyncConfig],
-  permissions: lakeQueryPermissions,
-  scaling: {
-    min: 1,
-    max: 1,
-  },
-  dev: {
-    command: "bun src/stat-sync.ts",
-    directory: "packages/stats/server",
-    autostart: false,
-  },
-})

nix/desktop.nix

@@ -3,7 +3,6 @@
   stdenv,
   bun,
   nodejs,
-  darwin,
   electron_41,
   makeWrapper,
   writableTmpDirAsHomeHook,
@@ -15,12 +14,7 @@ let
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "opencode-desktop";
-  inherit (opencode)
-    version
-    src
-    node_modules
-    patches
-    ;
+  inherit (opencode) version src node_modules;
 
   nativeBuildInputs = [
     bun
@@ -29,9 +23,6 @@ stdenv.mkDerivation (finalAttrs: {
     writableTmpDirAsHomeHook
   ] ++ lib.optionals stdenv.hostPlatform.isLinux [
     autoPatchelfHook
-  ] ++ lib.optionals stdenv.hostPlatform.isDarwin [
-    # Ad-hoc sign the .app: --config.mac.identity=null below skips signing.
-    darwin.autoSignDarwinBinariesHook
   ];
 
   buildInputs = lib.optionals stdenv.hostPlatform.isLinux [

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-3OI8L9IT1XFN44CO3YEgHy/zKqVNhzkJjW1P2+9X4lU=",
-    "aarch64-linux": "sha256-YZSeZIUBQCII3+dLwKhvKv4RKHwAkLSnvGXXEHbmjeQ=",
-    "aarch64-darwin": "sha256-8CsowndXBpFDTd2RNSMh7xaULwLoz3Lu6kfqkacOk2s=",
-    "x86_64-darwin": "sha256-pWyjVHZVBjcGvVU9AoSR4nhuMNKIHKJK5faihD8UzhQ="
+    "x86_64-linux": "sha256-Ucvyzyq+oYvWglkeowSvb0LgDzkAvaSdq0CdA6jgN6U=",
+    "aarch64-linux": "sha256-SERwZvvN6P8/OwNolHmC0KU9H5laVQm+FD/NNKauZA8=",
+    "aarch64-darwin": "sha256-I1ABwMHkTAntlYyg43w0cW8iPYfZa9MT0In2C7plB5g=",
+    "x86_64-darwin": "sha256-degJTL0RG7QQO8/USgIF//ya7oNmwChTmAoJcpXbIp0="
   }
 }

package.json

@@ -4,13 +4,12 @@
   "description": "AI-powered development tool",
   "private": true,
   "type": "module",
-  "packageManager": "bun@1.3.14",
+  "packageManager": "bun@1.3.13",
   "scripts": {
     "dev": "bun run --cwd packages/opencode --conditions=browser src/index.ts",
     "dev:desktop": "bun --cwd packages/desktop dev",
     "dev:web": "bun --cwd packages/app dev",
     "dev:console": "ulimit -n 10240 2>/dev/null; bun run --cwd packages/console/app dev",
-    "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
     "lint": "oxlint",
     "typecheck": "bun turbo typecheck",
@@ -18,29 +17,27 @@
     "postinstall": "bun run --cwd packages/opencode fix-node-pty",
     "prepare": "husky",
     "random": "echo 'Random script'",
-    "sso": "aws sso login --sso-session=opencode --no-browser",
+    "hello": "echo 'Hello World!'",
     "test": "echo 'do not run tests from root' && exit 1"
   },
   "workspaces": {
     "packages": [
       "packages/*",
       "packages/console/*",
-      "packages/stats/*",
       "packages/sdk/js",
       "packages/slack"
     ],
     "catalog": {
-      "@effect/opentelemetry": "4.0.0-beta.66",
-      "@effect/platform-node": "4.0.0-beta.66",
-      "@effect/sql-sqlite-bun": "4.0.0-beta.66",
+      "@effect/opentelemetry": "4.0.0-beta.65",
+      "@effect/platform-node": "4.0.0-beta.65",
       "@npmcli/arborist": "9.4.0",
-      "@types/bun": "1.3.13",
+      "@types/bun": "1.3.12",
       "@types/cross-spawn": "6.0.6",
       "@octokit/rest": "22.0.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.3.0",
-      "@opentui/keymap": "0.3.0",
-      "@opentui/solid": "0.3.0",
+      "@opentui/core": "0.2.11",
+      "@opentui/keymap": "0.2.11",
+      "@opentui/solid": "0.2.11",
       "ulid": "3.0.1",
       "@kobalte/core": "0.13.11",
       "@types/luxon": "3.7.1",
@@ -56,9 +53,9 @@
       "@tailwindcss/vite": "4.1.11",
       "diff": "8.0.2",
       "dompurify": "3.3.1",
-      "drizzle-kit": "1.0.0-rc.2",
-      "drizzle-orm": "1.0.0-rc.2",
-      "effect": "4.0.0-beta.66",
+      "drizzle-kit": "1.0.0-beta.19-d95b7a4",
+      "drizzle-orm": "1.0.0-beta.19-d95b7a4",
+      "effect": "4.0.0-beta.65",
       "ai": "6.0.168",
       "cross-spawn": "7.0.6",
       "hono": "4.10.7",
@@ -74,11 +71,10 @@
       "@typescript/native-preview": "7.0.0-dev.20251207.1",
       "zod": "4.1.8",
       "remeda": "2.26.0",
-      "sst": "4.13.1",
       "shiki": "3.20.0",
       "solid-list": "0.3.0",
       "tailwindcss": "4.1.11",
-      "virtua": "0.49.1",
+      "virtua": "0.42.3",
       "vite": "7.1.4",
       "@solidjs/meta": "0.29.4",
       "@solidjs/router": "0.15.4",
@@ -87,7 +83,7 @@
       "@sentry/vite-plugin": "4.6.0",
       "solid-js": "1.9.10",
       "vite-plugin-solid": "2.11.10",
-      "@lydell/node-pty": "1.2.0-beta.12"
+      "@lydell/node-pty": "1.2.0-beta.10"
     }
   },
   "devDependencies": {
@@ -101,7 +97,7 @@
     "oxlint-tsgolint": "0.21.0",
     "prettier": "3.6.2",
     "semver": "^7.6.0",
-    "sst": "catalog:",
+    "sst": "3.18.10",
     "turbo": "2.8.13"
   },
   "dependencies": {
@@ -142,9 +138,6 @@
     "@npmcli/agent@4.0.0": "patches/@npmcli%2Fagent@4.0.0.patch",
     "@silvia-odwyer/photon-node@0.3.4": "patches/@silvia-odwyer%2Fphoton-node@0.3.4.patch",
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
-    "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
-    "virtua@0.49.1": "patches/virtua@0.49.1.patch",
-    "@ai-sdk/xai@3.0.82": "patches/@ai-sdk%2Fxai@3.0.82.patch",
-    "gcp-metadata@8.1.2": "patches/gcp-metadata@8.1.2.patch"
+    "solid-js@1.9.10": "patches/solid-js@1.9.10.patch"
   }
 }

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

@@ -1,352 +0,0 @@
-import { expect, test, type Locator, type Page } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-const directory = "C:/OpenCode/TimelineStateRegression"
-const projectID = "proj_timeline_state_regression"
-const sessionID = "ses_timeline_state_regression"
-const userMessageID = "msg_user_regression"
-const assistantMessageID = "msg_assistant_regression"
-const editPartID = "prt_0001_edit"
-const textPartID = "prt_9999_text"
-const title = "Timeline collapse state regression"
-const model = { providerID: "opencode", modelID: "claude-opus-4-6", variant: "max" }
-
-type EventPayload = {
-  directory: string
-  payload: Record<string, unknown>
-}
-
-declare global {
-  interface Window {
-    __timelineDiffProbe: {
-      reset: () => void
-      shadowRoots: () => number
-    }
-  }
-}
-
-const userMessage = {
-  info: {
-    id: userMessageID,
-    sessionID,
-    role: "user",
-    time: { created: 1700000000000 },
-    summary: { diffs: [] },
-    agent: "build",
-    model,
-  },
-  parts: [
-    {
-      id: "prt_user_text",
-      sessionID,
-      messageID: userMessageID,
-      type: "text",
-      text: "Please edit the file.",
-    },
-  ],
-}
-
-const editPart = {
-  id: editPartID,
-  sessionID,
-  messageID: assistantMessageID,
-  type: "tool",
-  callID: "call_edit_regression",
-  tool: "edit",
-  state: {
-    status: "completed",
-    input: { filePath: "src/regression.ts" },
-    output: "Edited src/regression.ts",
-    title: "src/regression.ts",
-    metadata: {
-      filediff: {
-        file: "src/regression.ts",
-        additions: 1,
-        deletions: 1,
-        before: "export const value = 'before'\n",
-        after: "export const value = 'after'\n",
-      },
-      diff: "diff --git a/src/regression.ts b/src/regression.ts\n-export const value = 'before'\n+export const value = 'after'\n",
-    },
-    time: { start: 1700000001000, end: 1700000002000 },
-  },
-}
-
-const streamedTextPart = {
-  id: textPartID,
-  sessionID,
-  messageID: assistantMessageID,
-  type: "text",
-  text: "Streaming added a later assistant text part.",
-}
-
-const assistantMessage = {
-  info: {
-    id: assistantMessageID,
-    sessionID,
-    role: "assistant",
-    time: { created: 1700000001000 },
-    parentID: userMessageID,
-    modelID: model.modelID,
-    providerID: model.providerID,
-    mode: "build",
-    agent: "build",
-    path: { cwd: directory, root: directory },
-    cost: 0.01,
-    tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } },
-    variant: "max",
-  },
-  parts: [editPart],
-}
-
-test.describe("regression: session timeline local row state", () => {
-  test("keeps a manually collapsed tool collapsed when later assistant content streams", async ({ page }) => {
-    const events: EventPayload[] = []
-    await mockServer(page, events)
-    await configurePage(page)
-
-    await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-    await expect(page.getByRole("heading", { name: title })).toBeVisible()
-
-    const wrapper = page.locator(`[data-timeline-part-id="${editPartID}"]`).first()
-    await expect(wrapper).toBeVisible()
-    await expectExpanded(wrapper, true)
-
-    await wrapper.evaluate((element) => {
-      ;(element as HTMLElement).dataset.regressionMarker = "before-stream"
-    })
-    await wrapper.locator('[data-slot="collapsible-trigger"]').first().click()
-    await expectExpanded(wrapper, false)
-
-    events.push({
-      directory,
-      payload: {
-        type: "message.part.updated",
-        properties: { part: streamedTextPart },
-      },
-    })
-
-    await expect(page.locator(`[data-timeline-part-id="${textPartID}"]`).first()).toBeVisible({ timeout: 10_000 })
-
-    expect(await readToolState(page)).toEqual({
-      expanded: false,
-      row: "AssistantPart",
-      streamedTextVisible: true,
-    })
-  })
-
-  test("does not remount an edit diff when sibling parts or diff counts update", async ({ page }) => {
-    const events: EventPayload[] = []
-    await installDiffProbe(page)
-    await mockServer(page, events)
-    await configurePage(page)
-
-    await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-    await expect(page.getByRole("heading", { name: title })).toBeVisible()
-
-    const wrapper = page.locator(`[data-timeline-part-id="${editPartID}"]`).first()
-    await expect(wrapper).toBeVisible()
-    await expect(wrapper.locator('[data-component="file"][data-mode="diff"]').first()).toBeVisible()
-    await markDiffProbe(page)
-
-    events.push({
-      directory,
-      payload: {
-        type: "message.part.updated",
-        properties: { part: streamedTextPart },
-      },
-    })
-
-    await expect(page.locator(`[data-timeline-part-id="${textPartID}"]`).first()).toBeVisible({ timeout: 10_000 })
-    expect(await readDiffProbe(page)).toEqual({ fileMarker: "before", shadowRoots: 0, toolMarker: "before" })
-
-    await markDiffProbe(page)
-    events.push({
-      directory,
-      payload: {
-        type: "message.part.updated",
-        properties: { part: editPartWithAdditions(2) },
-      },
-    })
-
-    await expect(wrapper.locator('[data-slot="diff-changes-additions"]').filter({ hasText: "+2" }).first()).toBeVisible(
-      { timeout: 10_000 },
-    )
-    expect(await readDiffProbe(page)).toEqual({ fileMarker: "before", shadowRoots: 0, toolMarker: "before" })
-  })
-})
-
-async function configurePage(page: Page) {
-  await page.addInitScript(() => {
-    localStorage.setItem(
-      "settings.v3",
-      JSON.stringify({
-        general: {
-          editToolPartsExpanded: true,
-          shellToolPartsExpanded: true,
-          showReasoningSummaries: true,
-          showSessionProgressBar: true,
-        },
-      }),
-    )
-  })
-}
-
-async function expectExpanded(locator: Locator, expected: boolean) {
-  await expect.poll(() => locator.evaluate(readExpanded)).toBe(expected)
-}
-
-async function readToolState(page: Page) {
-  return page
-    .locator(`[data-timeline-part-id="${editPartID}"]`)
-    .first()
-    .evaluate(
-      (element, textPartID) => ({
-        expanded: (() => {
-          const trigger = element.querySelector('[data-slot="collapsible-trigger"]')
-          const aria = trigger?.getAttribute("aria-expanded")
-          if (aria === "true") return true
-          if (aria === "false") return false
-
-          const root = element.querySelector('[data-component="collapsible"]')
-          if (root?.hasAttribute("data-expanded")) return true
-          if (root?.hasAttribute("data-closed")) return false
-
-          const content = element.querySelector<HTMLElement>('[data-slot="collapsible-content"]')
-          return !!content && content.getBoundingClientRect().height > 0
-        })(),
-        row: element.closest("[data-timeline-row]")?.getAttribute("data-timeline-row"),
-        streamedTextVisible: !!document.querySelector(`[data-timeline-part-id="${textPartID}"]`),
-      }),
-      textPartID,
-    )
-}
-
-async function installDiffProbe(page: Page) {
-  await page.addInitScript(() => {
-    let shadowRootCount = 0
-    const attachShadow = Element.prototype.attachShadow
-    Element.prototype.attachShadow = function (init) {
-      shadowRootCount += 1
-      return attachShadow.call(this, init)
-    }
-    window.__timelineDiffProbe = {
-      reset: () => {
-        shadowRootCount = 0
-      },
-      shadowRoots: () => shadowRootCount,
-    }
-  })
-}
-
-async function markDiffProbe(page: Page) {
-  await page
-    .locator(`[data-timeline-part-id="${editPartID}"]`)
-    .first()
-    .evaluate((element) => {
-      const tool = element as HTMLElement
-      const file = tool.querySelector<HTMLElement>('[data-component="file"][data-mode="diff"]')
-      if (!file) throw new Error("missing edit diff file")
-
-      tool.dataset.timelineProbe = "before"
-      file.dataset.timelineProbe = "before"
-      window.__timelineDiffProbe.reset()
-    })
-}
-
-async function readDiffProbe(page: Page) {
-  return page
-    .locator(`[data-timeline-part-id="${editPartID}"]`)
-    .first()
-    .evaluate((element) => {
-      const tool = element as HTMLElement
-      const file = tool.querySelector<HTMLElement>('[data-component="file"][data-mode="diff"]')
-      return {
-        fileMarker: file?.dataset.timelineProbe,
-        shadowRoots: window.__timelineDiffProbe.shadowRoots(),
-        toolMarker: tool.dataset.timelineProbe,
-      }
-    })
-}
-
-function editPartWithAdditions(additions: number) {
-  return {
-    ...editPart,
-    state: {
-      ...editPart.state,
-      metadata: {
-        ...editPart.state.metadata,
-        filediff: {
-          ...editPart.state.metadata.filediff,
-          additions,
-        },
-      },
-    },
-  }
-}
-
-function readExpanded(element: Element) {
-  const trigger = element.querySelector('[data-slot="collapsible-trigger"]')
-  const aria = trigger?.getAttribute("aria-expanded")
-  if (aria === "true") return true
-  if (aria === "false") return false
-
-  const root = element.querySelector('[data-component="collapsible"]')
-  if (root?.hasAttribute("data-expanded")) return true
-  if (root?.hasAttribute("data-closed")) return false
-
-  const content = element.querySelector<HTMLElement>('[data-slot="collapsible-content"]')
-  return !!content && content.getBoundingClientRect().height > 0
-}
-
-async function mockServer(page: Page, events: EventPayload[]) {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: project(),
-    provider: provider(),
-    sessions: [session()],
-    pageMessages: () => ({ items: [userMessage, assistantMessage] }),
-    events: () => events.splice(0),
-  })
-}
-
-function project() {
-  return {
-    id: projectID,
-    worktree: directory,
-    vcs: "git",
-    name: "timeline-state-regression",
-    time: { created: 1700000000000, updated: 1700000000000 },
-    sandboxes: [],
-  }
-}
-
-function session() {
-  return {
-    id: sessionID,
-    slug: "timeline-state-regression",
-    projectID,
-    directory,
-    title,
-    version: "dev",
-    time: { created: 1700000000000, updated: 1700000000000 },
-  }
-}
-
-function provider() {
-  return {
-    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" },
-  }
-}
-
-function base64Encode(value: string) {
-  return Buffer.from(value, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
-}

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

@@ -1,267 +0,0 @@
-import { expect, test, type Page } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-const directory = "C:/OpenCode/ContextResizeRegression"
-const projectID = "proj_context_resize_regression"
-const sessionID = "ses_context_resize_regression"
-const title = "Context resize regression"
-const model = { providerID: "opencode", modelID: "claude-opus-4-6", variant: "max" }
-const contextIDs = ["prt_0100_read", "prt_0101_glob", "prt_0102_grep", "prt_0103_list"]
-const followingTextID = "prt_0104_text"
-
-type Message = {
-  info: Record<string, unknown> & { id: string; role: "user" | "assistant" }
-  parts: Record<string, unknown>[]
-}
-
-const messages = [...Array.from({ length: 8 }, (_, index) => turn(index, false)).flat(), ...turn(10, true)]
-
-test.describe("regression: session timeline context group resize", () => {
-  test("remeasures a recent explored context group before the next paint", async ({ page }) => {
-    await page.setViewportSize({ width: 1400, height: 900 })
-    await mockServer(page)
-    await configurePage(page)
-
-    await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-    await expect(page.getByRole("heading", { name: title })).toBeVisible()
-    await expect(page.locator(`[data-timeline-part-ids="${contextIDs.join(",")}"]`).first()).toBeVisible()
-    await expect(page.locator(`[data-timeline-part-id="${followingTextID}"]`).first()).toBeVisible()
-    await settle(page)
-
-    const samples = await sampleExpansion(page)
-    const visibleOverlap = samples.filter((sample) => sample.frame >= 1 && sample.overlap > 0.5)
-
-    console.log("context resize samples", JSON.stringify(samples, null, 2))
-
-    expect(samples[0]?.overlap).toBe(0)
-    expect(visibleOverlap).toEqual([])
-    expect(samples.at(-1)?.expanded).toBe("true")
-  })
-})
-
-async function configurePage(page: Page) {
-  await page.addInitScript(() => {
-    localStorage.setItem(
-      "settings.v3",
-      JSON.stringify({
-        general: {
-          editToolPartsExpanded: true,
-          shellToolPartsExpanded: true,
-          showReasoningSummaries: true,
-          showSessionProgressBar: true,
-        },
-      }),
-    )
-  })
-}
-
-async function sampleExpansion(page: Page) {
-  return page.evaluate(
-    ({ contextIDs, followingTextID }) =>
-      new Promise<
-        {
-          frame: number
-          label: string
-          scrollTop: number
-          scrollHeight: number
-          contextBottom: number
-          textTop: number
-          overlap: number
-          gap: number
-          expanded: string | null
-        }[]
-      >((resolve) => {
-        const context = document.querySelector<HTMLElement>(`[data-timeline-part-ids="${contextIDs.join(",")}"]`)
-        const text = document.querySelector<HTMLElement>(`[data-timeline-part-id="${followingTextID}"]`)
-        const scroller = context?.closest<HTMLElement>(".scroll-view__viewport")
-        const trigger = context?.querySelector<HTMLElement>('[data-slot="collapsible-trigger"]')
-        const contextRow = context?.closest<HTMLElement>('[data-timeline-row="AssistantPart"]')
-        const textRow = text?.closest<HTMLElement>('[data-timeline-row="AssistantPart"]')
-        if (!context || !text || !scroller || !trigger || !contextRow || !textRow)
-          throw new Error("missing regression nodes")
-
-        scroller.scrollTop = scroller.scrollHeight
-        const samples: {
-          frame: number
-          label: string
-          scrollTop: number
-          scrollHeight: number
-          contextBottom: number
-          textTop: number
-          overlap: number
-          gap: number
-          expanded: string | null
-        }[] = []
-        const capture = (frame: number, label: string) => {
-          const contextRect = contextRow.getBoundingClientRect()
-          const textRect = textRow.getBoundingClientRect()
-          samples.push({
-            frame,
-            label,
-            scrollTop: Math.round(scroller.scrollTop * 10) / 10,
-            scrollHeight: Math.round(scroller.scrollHeight * 10) / 10,
-            contextBottom: Math.round(contextRect.bottom * 10) / 10,
-            textTop: Math.round(textRect.top * 10) / 10,
-            overlap: Math.max(0, Math.round((contextRect.bottom - textRect.top) * 10) / 10),
-            gap: Math.max(0, Math.round((textRect.top - contextRect.bottom) * 10) / 10),
-            expanded: trigger.getAttribute("aria-expanded"),
-          })
-        }
-
-        capture(-1, "before")
-        trigger.click()
-        capture(0, "sync-after-click")
-
-        let frame = 1
-        const tick = () => {
-          capture(frame, "raf")
-          frame += 1
-          if (frame > 8) {
-            resolve(samples)
-            return
-          }
-          requestAnimationFrame(tick)
-        }
-        requestAnimationFrame(tick)
-      }),
-    { contextIDs, followingTextID },
-  )
-}
-
-function turn(index: number, target: boolean): Message[] {
-  const userID = id("msg_user", index)
-  const assistantID = id("msg_assistant", index)
-  return [
-    {
-      info: {
-        id: userID,
-        sessionID,
-        role: "user",
-        time: { created: 1700000000000 + index * 10_000 },
-        summary: { diffs: [] },
-        agent: "build",
-        model,
-      },
-      parts: [{ id: id("prt_user", index), sessionID, messageID: userID, type: "text", text: `User message ${index}` }],
-    },
-    {
-      info: {
-        id: assistantID,
-        sessionID,
-        role: "assistant",
-        time: { created: 1700000000000 + index * 10_000 + 1_000, completed: 1700000000000 + index * 10_000 + 2_000 },
-        parentID: userID,
-        modelID: model.modelID,
-        providerID: model.providerID,
-        mode: "build",
-        agent: "build",
-        path: { cwd: directory, root: directory },
-        cost: 0.01,
-        tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } },
-        variant: "max",
-        finish: "stop",
-      },
-      parts: target
-        ? [
-            contextTool(contextIDs[0]!, assistantID, "read", { filePath: "src/recent-a.ts", offset: 0, limit: 120 }),
-            contextTool(contextIDs[1]!, assistantID, "glob", { path: directory, pattern: "**/*.ts" }),
-            contextTool(contextIDs[2]!, assistantID, "grep", { path: directory, pattern: "Explored", include: "*.ts" }),
-            contextTool(contextIDs[3]!, assistantID, "list", { path: "src" }),
-            {
-              id: followingTextID,
-              sessionID,
-              messageID: assistantID,
-              type: "text",
-              text: "This assistant text is immediately after the explored context group.",
-            },
-          ]
-        : [
-            {
-              id: id("prt_text", index),
-              sessionID,
-              messageID: assistantID,
-              type: "text",
-              text: `Assistant filler ${index}. ${"filler ".repeat(60)}`,
-            },
-          ],
-    },
-  ]
-}
-
-function contextTool(partID: string, messageID: string, tool: string, input: Record<string, unknown>) {
-  return {
-    id: partID,
-    sessionID,
-    messageID,
-    type: "tool",
-    callID: `call_${partID}`,
-    tool,
-    state: {
-      status: "completed",
-      input,
-      output: `Completed ${tool}.\n${"detail line\n".repeat(8)}`,
-      title: input.filePath || input.path || input.pattern || "completed",
-      metadata: {},
-      time: { start: 1700000000000, end: 1700000000100 },
-    },
-  }
-}
-
-async function mockServer(page: Page) {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: project(),
-    provider: provider(),
-    sessions: [session()],
-    pageMessages: () => ({ items: messages }),
-  })
-}
-
-async function settle(page: Page) {
-  await page.evaluate(() => new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))))
-}
-
-function id(prefix: string, index: number) {
-  return `${prefix}_${String(index).padStart(4, "0")}`
-}
-
-function project() {
-  return {
-    id: projectID,
-    worktree: directory,
-    vcs: "git",
-    name: "context-resize-regression",
-    time: { created: 1700000000000, updated: 1700000000000 },
-    sandboxes: [],
-  }
-}
-
-function session() {
-  return {
-    id: sessionID,
-    slug: "context-resize-regression",
-    projectID,
-    directory,
-    title,
-    version: "dev",
-    time: { created: 1700000000000, updated: 1700000000000 },
-  }
-}
-
-function provider() {
-  return {
-    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" },
-  }
-}
-
-function base64Encode(value: string) {
-  return Buffer.from(value, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
-}

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

@@ -1,314 +0,0 @@
-const words = [
-  "alpha",
-  "bravo",
-  "charlie",
-  "delta",
-  "echo",
-  "foxtrot",
-  "golf",
-  "hotel",
-  "india",
-  "juliet",
-  "kilo",
-  "lima",
-  "metro",
-  "nova",
-  "orbit",
-  "pixel",
-  "quartz",
-  "river",
-  "signal",
-  "vector",
-]
-
-const sourceID = "ses_smoke_source"
-const targetID = "ses_smoke_target"
-const directory = "C:/OpenCode/SmokeProject"
-const projectID = "proj_smoke_timeline"
-const model = { providerID: "opencode", modelID: "claude-opus-4-6", variant: "max" }
-
-type MessageInfo = Record<string, unknown> & { id: string; role: "user" | "assistant" }
-type MessagePart = Record<string, unknown> & { id: string; type: string; text?: string; tool?: string }
-type Message = { info: MessageInfo; parts: MessagePart[] }
-
-function lorem(seed: number, length: number) {
-  let out = ""
-  let i = seed
-  while (out.length < length) {
-    const word = words[i % words.length]
-    out += (out ? " " : "") + word
-    if (i % 17 === 0) out += ".\n\n"
-    i += 7
-  }
-  return out.slice(0, length)
-}
-
-function id(prefix: string, value: number) {
-  return `${prefix}_smoke_${String(value).padStart(4, "0")}`
-}
-
-function userMessage(sessionID: string, index: number, textLength: number, diffs: unknown[] = []): Message {
-  const messageID = id("msg_user", index)
-  return {
-    info: {
-      id: messageID,
-      sessionID,
-      role: "user",
-      time: { created: 1700000000000 + index * 10_000 },
-      summary: { diffs },
-      agent: "build",
-      model,
-    },
-    parts: [
-      {
-        id: id("prt_user_text", index),
-        sessionID,
-        messageID,
-        type: "text",
-        text: lorem(index, textLength),
-      },
-    ],
-  }
-}
-
-function assistantMessage(sessionID: string, index: number, parentID: string, parts: MessagePart[]): Message {
-  const messageID = id("msg_assistant", index)
-  return {
-    info: {
-      id: messageID,
-      sessionID,
-      role: "assistant",
-      time: { created: 1700000000000 + index * 10_000 + 1_000, completed: 1700000000000 + index * 10_000 + 8_000 },
-      parentID,
-      modelID: model.modelID,
-      providerID: model.providerID,
-      mode: "build",
-      agent: "build",
-      path: { cwd: directory, root: directory },
-      cost: 0.01,
-      tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } },
-      variant: "max",
-      finish: "stop",
-    },
-    parts: parts.map((part) => ({
-      ...part,
-      sessionID,
-      messageID,
-    })),
-  }
-}
-
-function textPart(index: number, partIndex: number, length: number): MessagePart {
-  return { id: id(`prt_text_${partIndex}`, index), type: "text", text: lorem(index * 13 + partIndex, length) }
-}
-
-function reasoningPart(index: number, partIndex: number, length: number): MessagePart {
-  return {
-    id: id(`prt_reasoning_${partIndex}`, index),
-    type: "reasoning",
-    text: lorem(index * 19 + partIndex, length),
-    time: { start: 1700000000000 + index * 10_000, end: 1700000000000 + index * 10_000 + 500 },
-  }
-}
-
-function toolPart(
-  index: number,
-  partIndex: number,
-  tool: string,
-  input: Record<string, unknown>,
-  outputLength = 160,
-): MessagePart {
-  const metadata =
-    tool === "apply_patch"
-      ? { files: [patchFile(index, "update"), patchFile(index + 1, index % 2 === 0 ? "add" : "delete")] }
-      : tool === "edit" || tool === "write"
-        ? {
-            filediff: fileDiff(String(input.filePath ?? `src/generated/file-${index}.ts`), index),
-            diff: patch(index, outputLength),
-            preview: patch(index + 1, 420),
-          }
-        : tool === "question"
-          ? { answers: [["Proceed"], ["Keep sample output"]] }
-          : {}
-  return {
-    id: id(`prt_tool_${tool}_${partIndex}`, index),
-    type: "tool",
-    callID: id("call", index * 10 + partIndex),
-    tool,
-    state: {
-      status: "completed",
-      input,
-      output: lorem(index * 23 + partIndex, outputLength),
-      title: tool === "bash" ? "Verify generated output" : input.filePath || input.path || input.pattern || "completed",
-      metadata,
-      time: { start: 1700000000000 + index * 10_000, end: 1700000000000 + index * 10_000 + 400 },
-    },
-  }
-}
-
-function patchFile(seed: number, type: "add" | "update" | "delete") {
-  return {
-    filePath: `src/generated/patch-${seed}.ts`,
-    relativePath: `src/generated/patch-${seed}.ts`,
-    type,
-    additions: (seed % 7) + 1,
-    deletions: type === "add" ? 0 : seed % 4,
-    patch: patch(seed, 520),
-    before: type === "add" ? undefined : code(seed, 18),
-    after: type === "delete" ? undefined : code(seed + 1, 24),
-  }
-}
-
-function fileDiff(file: string, seed: number) {
-  return {
-    file,
-    additions: (seed % 9) + 1,
-    deletions: seed % 4,
-    before: code(seed, 32),
-    after: code(seed + 1, 38),
-  }
-}
-
-function patch(seed: number, length: number) {
-  return `diff --git a/src/generated/file-${seed}.ts b/src/generated/file-${seed}.ts\n+${lorem(seed, length).replace(/\n/g, "\n+")}`
-}
-
-function code(seed: number, lines: number) {
-  return Array.from({ length: lines }, (_, index) => `export const value${index} = "${lorem(seed + index, 32)}"`).join(
-    "\n",
-  )
-}
-
-function turn(index: number): Message[] {
-  const diff = index % 9 === 0 ? [fileDiff(`src/generated/summary-${index}.ts`, index)] : []
-  const user = userMessage(targetID, index, 100 + (index % 4) * 80, diff)
-  const parts = [
-    ...(index % 5 === 0 ? [reasoningPart(index, 0, 420)] : []),
-    ...(index % 3 === 0
-      ? [
-          toolPart(index, 0, "read", { filePath: `src/generated/file-${index}.ts`, offset: 0, limit: 80 }, 220),
-          toolPart(index, 5, "glob", { path: directory, pattern: `**/*sample-${index}*.ts` }, 140),
-          toolPart(index, 1, "grep", { path: directory, pattern: `sample-${index}`, include: "*.ts" }, 180),
-          toolPart(index, 6, "list", { path: `src/generated/${index}` }, 120),
-        ]
-      : []),
-    textPart(index, 2, 160 + (index % 6) * 90),
-    ...(index % 4 === 0 ? [toolPart(index, 3, "edit", { filePath: `src/generated/file-${index}.ts` }, 700)] : []),
-    ...(index % 6 === 0
-      ? [toolPart(index, 7, "write", { filePath: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
-      : []),
-    ...(index % 8 === 0
-      ? [toolPart(index, 8, "apply_patch", { files: [`src/generated/patch-${index}.ts`] }, 620)]
-      : []),
-    ...(index % 7 === 0
-      ? [toolPart(index, 4, "bash", { command: "bun typecheck", description: "Verify generated output" }, 620)]
-      : []),
-    ...(index % 10 === 0 ? [toolPart(index, 9, "webfetch", { url: "https://example.com/docs/sample" }, 120)] : []),
-    ...(index % 11 === 0 ? [toolPart(index, 10, "websearch", { query: "sample movement notes" }, 240)] : []),
-    ...(index % 13 === 0
-      ? [
-          toolPart(
-            index,
-            11,
-            "question",
-            { questions: [{ question: "Use generated fixture?" }, { question: "Keep same row shape?" }] },
-            120,
-          ),
-        ]
-      : []),
-    ...(index % 17 === 0
-      ? [toolPart(index, 12, "task", { description: "Inspect generated fixture", subagent_type: "explore" }, 160)]
-      : []),
-  ]
-  return [user, assistantMessage(targetID, index, user.info.id, parts)]
-}
-
-const targetMessages = Array.from({ length: 72 }, (_, index) => turn(index)).flat()
-const sourceMessages = Array.from({ length: 12 }, (_, index) => [
-  userMessage(sourceID, index + 1000, 120),
-  assistantMessage(sourceID, index + 1000, id("msg_user", index + 1000), [textPart(index + 1000, 0, 240)]),
-]).flat()
-
-function renderable(part: MessagePart) {
-  if (part.type === "tool" && part.tool === "todowrite") return false
-  if (part.type === "text") return !!part.text.trim()
-  if (part.type === "reasoning") return !!part.text.trim()
-  return part.type !== "step-start" && part.type !== "step-finish" && part.type !== "patch"
-}
-
-function orderedParts(message: Message) {
-  return message.parts.slice().sort((a, b) => a.id.localeCompare(b.id))
-}
-
-export const fixture = {
-  directory,
-  project: {
-    id: projectID,
-    worktree: directory,
-    vcs: "git",
-    name: "smoke-project",
-    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: sourceID,
-      slug: "source",
-      projectID,
-      directory,
-      title: "Uncommitted changes inquiry",
-      version: "dev",
-      time: { created: 1700000000000, updated: 1700000000000 },
-    },
-    {
-      id: targetID,
-      slug: "target",
-      projectID,
-      directory,
-      title: "Example Game: sample jump movement & sample physics analysis",
-      version: "dev",
-      time: { created: 1700000001000, updated: 1700000001000 },
-    },
-  ],
-  sourceID,
-  targetID,
-  messages: { [sourceID]: sourceMessages, [targetID]: targetMessages },
-  expected: {
-    sourceTitle: "Uncommitted changes inquiry",
-    targetTitle: "Example Game: sample jump movement & sample physics analysis",
-    targetMessageIDs: targetMessages
-      .filter((message) => message.info.role === "user")
-      .map((message) => message.info.id),
-    targetPartIDs: targetMessages.flatMap((message) =>
-      orderedParts(message)
-        .filter(renderable)
-        .map((part) => part.id),
-    ),
-  },
-}
-
-export function pageMessages(sessionID: string, limit: number, before?: string) {
-  const messages = fixture.messages[sessionID as keyof typeof fixture.messages] ?? []
-  const end = before
-    ? Math.max(
-        0,
-        messages.findIndex((message) => message.info.id === before),
-      )
-    : messages.length
-  const start = Math.max(0, end - limit)
-  return {
-    items: messages.slice(start, end),
-    cursor: start > 0 ? messages[start]!.info.id : undefined,
-  }
-}

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

@@ -1,428 +0,0 @@
-import { expect, test, type Page } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import { fixture, pageMessages } from "./session-timeline.fixture"
-import { trackPageErrors, expectNoSmokeErrors } from "../utils/errors"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-const forbiddenText = ["Load details", "Show earlier steps"]
-
-type SmokeState = {
-  ids: string[]
-  visibleIds: string[]
-  messageIds: string[]
-  visibleMessageIds: string[]
-  topVisibleId?: string
-  signature: string
-  scrollTop: number
-  scrollHeight: number
-  clientHeight: number
-  errorToasts: string[]
-  forbiddenText: string[]
-}
-
-type SmokeWindow = Window & {
-  __timelineSmokeState?: () => SmokeState
-  __timelineSmokeErrorToasts?: string[]
-  __timelineSmokeForbiddenText?: string[]
-}
-
-test.describe("smoke: session timeline", () => {
-  test.setTimeout(240_000)
-
-  test("renders seeded timeline in order while paging through history", async ({ page }) => {
-    const errors = trackPageErrors(page)
-    await mockOpenCodeServer(page, {
-      sessions: fixture.sessions,
-      provider: fixture.provider,
-      directory: fixture.directory,
-      project: fixture.project,
-      pageMessages,
-    })
-    await configureSmokePage(page, fixture.directory)
-
-    await selectHomeProject(page, fixture.project.name)
-    await navigateToSession(page, fixture.directory, fixture.sourceID, fixture.expected.sourceTitle)
-    await expectSessionReady(page)
-    await navigateToSession(page, fixture.directory, fixture.targetID, fixture.expected.targetTitle)
-    const expectedPartIDs = fixture.expected.targetPartIDs
-    const expectedMessageIDs = fixture.expected.targetMessageIDs
-    await expectSessionTimelineReady(page, expectedPartIDs, expectedMessageIDs, errors)
-    await expectCanScrollToStart(page, expectedPartIDs, expectedMessageIDs, errors)
-  })
-})
-
-async function configureSmokePage(page: Page, directory: string) {
-  await page.addInitScript(() => {
-    localStorage.setItem(
-      "settings.v3",
-      JSON.stringify({
-        general: {
-          editToolPartsExpanded: true,
-          shellToolPartsExpanded: true,
-          showReasoningSummaries: true,
-          showSessionProgressBar: true,
-        },
-      }),
-    )
-  })
-
-  await page.addInitScript((directory) => {
-    localStorage.setItem(
-      "opencode.global.dat:server",
-      JSON.stringify({
-        projects: {
-          local: [{ worktree: directory, expanded: true }],
-        },
-        lastProject: {
-          local: directory,
-        },
-      }),
-    )
-  }, directory)
-
-  await page.addInitScript(() => {
-    const smoke = window as SmokeWindow
-    smoke.__timelineSmokeErrorToasts = []
-    smoke.__timelineSmokeForbiddenText = []
-    const partSelector = "[data-timeline-part-id], [data-timeline-part-ids]"
-    const idsOf = (el: HTMLElement) =>
-      [el.dataset.timelinePartId, ...(el.dataset.timelinePartIds?.split(",") ?? [])].filter((id): id is string => !!id)
-
-    smoke.__timelineSmokeState = () => {
-      const scroller = [...document.querySelectorAll<HTMLElement>(".scroll-view__viewport")].find((el) =>
-        el.querySelector("[data-timeline-row], [data-session-title]"),
-      )
-      if (!scroller) {
-        return {
-          ids: [],
-          visibleIds: [],
-          messageIds: [],
-          visibleMessageIds: [],
-          topVisibleId: undefined,
-          signature: "",
-          scrollTop: 0,
-          scrollHeight: 0,
-          clientHeight: 0,
-          errorToasts: smoke.__timelineSmokeErrorToasts ?? [],
-          forbiddenText: smoke.__timelineSmokeForbiddenText ?? [],
-        }
-      }
-
-      const ids: string[] = []
-      const visibleIds: string[] = []
-      const scrollerRect = scroller.getBoundingClientRect()
-      let topVisibleId: string | undefined
-      for (const el of scroller.querySelectorAll<HTMLElement>(partSelector)) {
-        const next = idsOf(el)
-        ids.push(...next)
-
-        const rect = el.getBoundingClientRect()
-        if (rect.bottom >= scrollerRect.top && rect.top <= scrollerRect.bottom) {
-          if (!topVisibleId) topVisibleId = next[0]
-          visibleIds.push(...next)
-        }
-      }
-
-      const messageIds: string[] = []
-      const visibleMessageIds: string[] = []
-      const rows = [...scroller.querySelectorAll<HTMLElement>("[data-message-id]")].map((el) => {
-        const rect = el.getBoundingClientRect()
-        const id = el.dataset.messageId
-        if (id) {
-          messageIds.push(id)
-          if (rect.bottom >= scrollerRect.top && rect.top <= scrollerRect.bottom) visibleMessageIds.push(id)
-        }
-        return {
-          id,
-          top: Math.round(rect.top),
-          bottom: Math.round(rect.bottom),
-        }
-      })
-      const signature = JSON.stringify({
-        top: Math.round(scroller.scrollTop),
-        height: Math.round(scroller.scrollHeight),
-        rows,
-        ids,
-      })
-
-      return {
-        ids,
-        visibleIds,
-        messageIds,
-        visibleMessageIds,
-        topVisibleId,
-        signature,
-        scrollTop: Math.round(scroller.scrollTop),
-        scrollHeight: Math.round(scroller.scrollHeight),
-        clientHeight: Math.round(scroller.clientHeight),
-        errorToasts: smoke.__timelineSmokeErrorToasts ?? [],
-        forbiddenText: smoke.__timelineSmokeForbiddenText ?? [],
-      }
-    }
-    let recordFrame: number | undefined
-    const record = () => {
-      for (const toast of document.querySelectorAll<HTMLElement>('[data-component="toast"][data-variant="error"]')) {
-        const text = toast.textContent?.trim()
-        if (text && !smoke.__timelineSmokeErrorToasts!.includes(text)) smoke.__timelineSmokeErrorToasts!.push(text)
-      }
-      const text = document.body?.textContent ?? ""
-      for (const value of ["Load details", "Show earlier steps"]) {
-        if (text.includes(value) && !smoke.__timelineSmokeForbiddenText!.includes(value)) {
-          smoke.__timelineSmokeForbiddenText!.push(value)
-        }
-      }
-    }
-    const start = () => {
-      const root = document.documentElement ?? document.body
-      if (!root) return
-      new MutationObserver(() => {
-        if (recordFrame) return
-        recordFrame = requestAnimationFrame(() => {
-          recordFrame = undefined
-          record()
-        })
-      }).observe(root, { childList: true, subtree: true })
-      record()
-    }
-    if (document.documentElement ?? document.body) start()
-    else document.addEventListener("DOMContentLoaded", start, { once: true })
-  })
-}
-
-async function expectCanScrollToStart(
-  page: Page,
-  expectedPartIDs: string[],
-  expectedMessageIDs: string[],
-  errors: string[],
-) {
-  await pointAtTimeline(page)
-  const seenParts = new Set<string>()
-  const seenMessages = new Set<string>()
-  const samples: TraversalSample[] = []
-  let current = await timelineState(page)
-  let unchangedAtTop = 0
-
-  for (let attempt = 0; attempt < 600; attempt++) {
-    collectSeen(current, seenParts, seenMessages)
-    samples.push(sampleTraversal(current, seenParts.size, seenMessages.size))
-    expectNoSmokeErrors(errors, current.errorToasts, current.forbiddenText)
-    expectOrderedIDs(expectedPartIDs, current.ids, "mounted part")
-    expectOrderedIDs(expectedPartIDs, current.visibleIds, "visible part")
-    expectOrderedIDs(expectedMessageIDs, unique(current.messageIds), "mounted message")
-    expectOrderedIDs(expectedMessageIDs, unique(current.visibleMessageIds), "visible message")
-
-    if (
-      current.scrollTop <= 1 &&
-      seenParts.size === expectedPartIDs.length &&
-      seenMessages.size === expectedMessageIDs.length
-    ) {
-      expectCompleteScroll(current, expectedPartIDs, expectedMessageIDs, seenParts, seenMessages, samples)
-      return
-    }
-
-    const before = current
-    const changed = await scrollTimelineUp(page, current)
-    current = await timelineState(page)
-    if (!changed && current.signature === before.signature && current.scrollTop <= 1) unchangedAtTop++
-    else unchangedAtTop = 0
-    if (unchangedAtTop >= 2) break
-  }
-
-  collectSeen(current, seenParts, seenMessages)
-  samples.push(sampleTraversal(current, seenParts.size, seenMessages.size))
-  expectCompleteScroll(current, expectedPartIDs, expectedMessageIDs, seenParts, seenMessages, samples)
-}
-
-async function timelineState(page: Page) {
-  return page.evaluate(
-    () =>
-      (window as SmokeWindow).__timelineSmokeState?.() ?? {
-        ids: [],
-        visibleIds: [],
-        messageIds: [],
-        visibleMessageIds: [],
-        topVisibleId: undefined,
-        signature: "",
-        scrollTop: 0,
-        scrollHeight: 0,
-        clientHeight: 0,
-        errorToasts: [],
-        forbiddenText: [],
-      },
-  )
-}
-
-function timelineScroller(page: Page) {
-  return page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
-}
-
-async function pointAtTimeline(page: Page) {
-  const box = await timelineScroller(page).boundingBox()
-  if (!box) throw new Error("Timeline scroller is not visible")
-  await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2)
-}
-
-async function scrollTimelineUp(page: Page, before: SmokeState) {
-  return page.evaluate(
-    (prev) =>
-      new Promise<boolean>((resolve) => {
-        const scroller = [...document.querySelectorAll<HTMLElement>(".scroll-view__viewport")].find((el) =>
-          el.querySelector("[data-timeline-row], [data-session-title]"),
-        )
-        if (!scroller) {
-          resolve(false)
-          return
-        }
-
-        scroller.dispatchEvent(new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: -1, deltaMode: 0 }))
-        scroller.scrollTop = Math.max(0, scroller.scrollTop - Math.max(80, Math.round(scroller.clientHeight * 0.45)))
-
-        const read = () => (window as SmokeWindow).__timelineSmokeState?.().signature ?? ""
-        let frames = 0
-        let stableFrames = 0
-        let last = ""
-        let changed = false
-        const check = () => {
-          const current = read()
-          if (current !== prev) changed = true
-          if (current === last) stableFrames++
-          else {
-            stableFrames = 0
-            last = current
-          }
-          if (changed && stableFrames >= 2) {
-            resolve(true)
-            return
-          }
-          frames++
-          if (frames >= 30) {
-            resolve(changed)
-            return
-          }
-          requestAnimationFrame(check)
-        }
-        requestAnimationFrame(check)
-      }),
-    before.signature,
-  )
-}
-
-function expectOrderedIDs(expected: string[], actual: string[], label: string) {
-  expect(actual.length, `${label} ids should not be empty`).toBeGreaterThan(0)
-  const actualSet = new Set(actual)
-  expect(actual, `${label} ids`).toEqual(expected.filter((id) => actualSet.has(id)))
-}
-
-function unique(values: string[]) {
-  return values.filter((value, index) => values.indexOf(value) === index)
-}
-
-function collectSeen(state: SmokeState, seenParts: Set<string>, seenMessages: Set<string>) {
-  for (const id of state.ids) seenParts.add(id)
-  for (const id of state.visibleIds) seenParts.add(id)
-  for (const id of state.messageIds) seenMessages.add(id)
-  for (const id of state.visibleMessageIds) seenMessages.add(id)
-}
-
-type TraversalSample = ReturnType<typeof sampleTraversal>
-
-function sampleTraversal(state: SmokeState, seenParts: number, seenMessages: number) {
-  return {
-    seenParts,
-    seenMessages,
-    mounted: state.ids.length,
-    visible: state.visibleIds.length,
-    mountedMessages: unique(state.messageIds).length,
-    visibleMessages: unique(state.visibleMessageIds).length,
-    top: state.scrollTop,
-    height: state.scrollHeight,
-    first: state.ids[0],
-    last: state.ids.at(-1),
-    topVisible: state.topVisibleId,
-    visibleFirst: state.visibleIds[0],
-    visibleLast: state.visibleIds.at(-1),
-  }
-}
-
-function sampleSummary(samples: TraversalSample[]) {
-  return samples
-    .filter((_, index) => index % Math.max(1, Math.floor(samples.length / 8)) === 0 || index === samples.length - 1)
-    .map(
-      (sample, index) =>
-        `${index}: seenParts=${sample.seenParts} seenMessages=${sample.seenMessages} mounted=${sample.mounted}/${sample.mountedMessages} visible=${sample.visible}/${sample.visibleMessages} top=${sample.top}/${sample.height} first=${sample.first} last=${sample.last} topVisible=${sample.topVisible} visible=${sample.visibleFirst}..${sample.visibleLast}`,
-    )
-    .join("\n")
-}
-
-async function waitForTimelineStable(page: Page) {
-  await page.waitForFunction(
-    () =>
-      new Promise<boolean>((resolve) => {
-        requestAnimationFrame(() => {
-          const a = (window as SmokeWindow).__timelineSmokeState?.().signature ?? ""
-          requestAnimationFrame(() => {
-            const b = (window as SmokeWindow).__timelineSmokeState?.().signature ?? ""
-            requestAnimationFrame(() =>
-              resolve(!!a && a === b && b === ((window as SmokeWindow).__timelineSmokeState?.().signature ?? "")),
-            )
-          })
-        })
-      }),
-  )
-}
-
-async function expectSessionTimelineReady(
-  page: Page,
-  expectedPartIDs: string[],
-  expectedMessageIDs: string[],
-  errors: string[],
-) {
-  await waitForTimelineStable(page)
-  for (const text of forbiddenText) await expect(page.getByText(text)).toHaveCount(0)
-  const currentState = await timelineState(page)
-  expectNoSmokeErrors(errors, currentState.errorToasts, currentState.forbiddenText)
-  expectOrderedIDs(expectedPartIDs, currentState.ids, "mounted part")
-  expectOrderedIDs(expectedPartIDs, currentState.visibleIds, "visible part")
-  expectOrderedIDs(expectedMessageIDs, unique(currentState.messageIds), "mounted message")
-  expectOrderedIDs(expectedMessageIDs, unique(currentState.visibleMessageIds), "visible message")
-}
-
-function expectCompleteScroll(
-  state: SmokeState,
-  expectedPartIDs: string[],
-  expectedMessageIDs: string[],
-  seenParts: Set<string>,
-  seenMessages: Set<string>,
-  samples: TraversalSample[],
-) {
-  expect(state.scrollTop, `timeline should reach the start\n${sampleSummary(samples)}`).toBeLessThanOrEqual(1)
-  expect(
-    expectedPartIDs.filter((id) => !seenParts.has(id)),
-    `missing visible timeline parts\n${sampleSummary(samples)}`,
-  ).toEqual([])
-  expect(
-    expectedMessageIDs.filter((id) => !seenMessages.has(id)),
-    `missing visible messages\n${sampleSummary(samples)}`,
-  ).toEqual([])
-  expect(new Set(expectedPartIDs).size).toBe(expectedPartIDs.length)
-  expect(new Set(expectedMessageIDs).size).toBe(expectedMessageIDs.length)
-  expect(expectedPartIDs.length).toBe(331)
-}
-
-async function selectHomeProject(page: Page, projectName: string) {
-  await page.goto("/")
-  await page
-    .locator('[data-component="home-project-row"]')
-    .filter({ hasText: new RegExp(projectName, "i") })
-    .click()
-  await expect(page).toHaveURL(/\/$/)
-}
-
-async function navigateToSession(page: Page, directory: string, sessionId: string, expectedTitle: string) {
-  await page.goto(`/${base64Encode(directory)}/session/${sessionId}`)
-  await expect(page.getByRole("heading", { name: expectedTitle })).toBeVisible()
-}
-
-async function expectSessionReady(page: Page) {
-  await expect(page.getByRole("textbox", { name: /Ask anything/i })).toBeVisible()
-}

packages/app/e2e/todo.spec.ts

@@ -0,0 +1,11 @@
+import { test } from "@playwright/test"
+
+test(
+  "test something cool",
+  {
+    annotation: { type: "todo" },
+  },
+  async () => {
+    test.fixme()
+  },
+)

packages/app/e2e/utils/errors.ts

@@ -1,18 +0,0 @@
-import { expect, type Page } from "@playwright/test"
-
-export function trackPageErrors(page: Page) {
-  const errors: string[] = []
-  page.on("console", (message) => {
-    if (message.type() === "error") errors.push(message.text())
-  })
-  page.on("pageerror", (error) => errors.push(error.stack ?? error.message))
-  return errors
-}
-
-export function expectNoSmokeErrors(consoleErrors: string[], toastErrors: string[], forbiddenText: string[]) {
-  expect({ consoleErrors, toastErrors, forbiddenText }).toEqual({
-    consoleErrors: [],
-    toastErrors: [],
-    forbiddenText: [],
-  })
-}

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

@@ -1,92 +0,0 @@
-import type { Page, Route } from "@playwright/test"
-
-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 {
-  provider: unknown
-  directory: string
-  project: unknown
-  sessions: ({ id: string } & Record<string, unknown>)[]
-  pageMessages: (sessionId: string, limit: number, before?: string) => { items: unknown[]; cursor?: string }
-  events?: () => unknown[]
-}
-
-export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
-  const staticRoutes: Record<string, unknown> = {
-    "/provider": config.provider,
-    "/path": {
-      state: config.directory,
-      config: config.directory,
-      worktree: config.directory,
-      directory: config.directory,
-      home: "C:/OpenCode",
-    },
-    "/project": [config.project],
-    "/project/current": config.project,
-    "/agent": [{ name: "build", mode: "primary" }],
-    "/vcs": { branch: "main", default_branch: "main" },
-    "/session": config.sessions,
-  }
-
-  await page.route("**/*", async (route) => {
-    const url = new URL(route.request().url())
-    const targetPort = process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"
-    if (url.port !== targetPort) return route.fallback()
-
-    const path = url.pathname
-    if (path === "/global/event" || path === "/event") return sse(route, config.events?.())
-    if (path === "/global/health") return json(route, { healthy: true })
-    if (emptyObject.has(path)) return json(route, {})
-    if (emptyList.has(path)) return json(route, [])
-    if (path in staticRoutes) return json(route, staticRoutes[path])
-
-    const sessionMatch = path.match(/^\/session\/([^/]+)$/)
-    if (sessionMatch) {
-      const session = config.sessions.find((s) => s.id === sessionMatch[1])
-      return json(route, session ?? {})
-    }
-
-    if (/^\/session\/[^/]+\/(children|todo|diff)$/.test(path)) return json(route, [])
-
-    const messagesMatch = path.match(/^\/session\/([^/]+)\/message$/)
-    if (messagesMatch) {
-      const limit = Number(url.searchParams.get("limit") ?? 80)
-      const before = url.searchParams.get("before") ?? undefined
-      const pageData = config.pageMessages(messagesMatch[1], limit, before)
-      return json(route, pageData.items, pageData.cursor ? { "x-next-cursor": pageData.cursor } : undefined)
-    }
-
-    return json(route, {})
-  })
-}
-
-function json(route: Route, body: unknown, headers?: Record<string, string>) {
-  return route.fulfill({
-    status: 200,
-    contentType: "application/json",
-    headers: {
-      "access-control-allow-origin": "*",
-      "access-control-expose-headers": "x-next-cursor",
-      ...headers,
-    },
-    body: JSON.stringify(body ?? null),
-  })
-}
-
-function sse(route: Route, events?: unknown[]) {
-  return route.fulfill({
-    status: 200,
-    contentType: "text/event-stream",
-    body: events?.map((event) => `data: ${JSON.stringify(event)}\n\n`).join("") || ": ok\n\n",
-  })
-}

packages/app/index.html

@@ -10,6 +10,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-v3.png" />
     <link rel="manifest" href="/site.webmanifest" />
     <meta name="theme-color" content="#F8F7F7" />
+    <meta name="theme-color" content="#131010" media="(prefers-color-scheme: dark)" />
     <meta property="og:image" content="/social-share.png" />
     <meta property="twitter:image" content="/social-share.png" />
     <script id="oc-theme-preload-script" src="/oc-theme-preload.js"></script>

packages/app/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@opencode-ai/app",
-  "version": "1.15.13",
+  "version": "1.15.4",
   "description": "",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
-    "./desktop-menu": "./src/desktop-menu.ts",
     "./vite": "./vite.js",
     "./index.css": "./src/index.css"
   },
@@ -42,10 +41,10 @@
   },
   "dependencies": {
     "@kobalte/core": "catalog:",
-    "@opencode-ai/core": "workspace:*",
+    "@sentry/solid": "catalog:",
     "@opencode-ai/sdk": "workspace:*",
     "@opencode-ai/ui": "workspace:*",
-    "@sentry/solid": "catalog:",
+    "@opencode-ai/core": "workspace:*",
     "@shikijs/transformers": "3.9.2",
     "@solid-primitives/active-element": "2.1.3",
     "@solid-primitives/audio": "1.4.2",
@@ -54,7 +53,6 @@
     "@solid-primitives/i18n": "2.2.1",
     "@solid-primitives/media": "2.3.3",
     "@solid-primitives/resize-observer": "2.1.5",
-    "@solid-primitives/scheduled": "1.5.3",
     "@solid-primitives/scroll": "2.1.3",
     "@solid-primitives/storage": "catalog:",
     "@solid-primitives/timer": "1.4.4",

packages/app/public/oc-theme-preload.js

@@ -16,10 +16,6 @@
   document.documentElement.dataset.theme = themeId
   document.documentElement.dataset.colorScheme = mode
 
-  // Update theme-color meta tag to match app color scheme
-  var metas = document.querySelectorAll("meta[name='theme-color']")
-  if (metas.length > 0) metas[0].setAttribute("content", isDark ? "#131010" : "#F8F7F7")
-
   if (themeId === "oc-2") return
 
   var css = localStorage.getItem("opencode-theme-css-" + mode)

packages/app/src/app.tsx

@@ -14,7 +14,6 @@ import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
 import { Effect } from "effect"
 import {
   type Component,
-  createEffect,
   createMemo,
   createResource,
   createSignal,
@@ -31,8 +30,8 @@ import { Dynamic } from "solid-js/web"
 import { CommandProvider } from "@/context/command"
 import { CommentsProvider } from "@/context/comments"
 import { FileProvider } from "@/context/file"
-import { ServerSDKProvider } from "@/context/server-sdk"
-import { ServerSyncProvider } from "@/context/server-sync"
+import { GlobalSDKProvider } from "@/context/global-sdk"
+import { GlobalSyncProvider } from "@/context/global-sync"
 import { HighlightsProvider } from "@/context/highlights"
 import { LanguageProvider, type Locale, useLanguage } from "@/context/language"
 import { LayoutProvider } from "@/context/layout"
@@ -41,26 +40,30 @@ import { NotificationProvider } from "@/context/notification"
 import { PermissionProvider } from "@/context/permission"
 import { PromptProvider } from "@/context/prompt"
 import { ServerConnection, ServerProvider, serverName, useServer } from "@/context/server"
-import { SettingsProvider, useSettings } from "@/context/settings"
+import { SettingsProvider } from "@/context/settings"
 import { TerminalProvider } from "@/context/terminal"
 import DirectoryLayout from "@/pages/directory-layout"
 import Layout from "@/pages/layout"
 import { ErrorPage } from "./pages/error"
 import { useCheckServerHealth } from "./utils/server-health"
-import { ServersProvider } from "./context/servers"
 
 const HomeRoute = lazy(() => import("@/pages/home"))
-const Session = lazy(() => import("@/pages/session"))
+const loadSession = () => import("@/pages/session")
+const Session = lazy(loadSession)
+const Loading = () => <div class="size-full" />
 
-const SessionRoute = Object.assign(
-  () => (
-    <SessionProviders>
-      <Session />
-    </SessionProviders>
-  ),
-  { preload: Session.preload },
+if (typeof location === "object" && /\/session(?:\/|$)/.test(location.pathname)) {
+  void loadSession()
+}
+
+const SessionRoute = () => (
+  <SessionProviders>
+    <Session />
+  </SessionProviders>
 )
 
+const SessionIndexRoute = () => <Navigate href="session" />
+
 function UiI18nBridge(props: ParentProps) {
   const language = useLanguage()
   return <I18nProvider value={{ locale: language.intl, t: language.t }}>{props.children}</I18nProvider>
@@ -75,7 +78,6 @@ declare global {
     }
     api?: {
       setTitlebar?: (theme: { mode: "light" | "dark" }) => Promise<void>
-      exportDebugLogs?: () => Promise<string>
     }
   }
 }
@@ -93,26 +95,9 @@ function QueryProvider(props: ParentProps) {
   return <QueryClientProvider client={client}>{props.children}</QueryClientProvider>
 }
 
-function BodyDesignClass() {
-  const settings = useSettings()
-
-  createEffect(() => {
-    if (typeof document === "undefined") return
-
-    const enabled = settings.general.newLayoutDesigns()
-    document.body.classList.toggle("text-12-regular", !enabled)
-    document.body.classList.toggle("font-(family-name:--font-family-text)", enabled)
-    document.body.classList.toggle("text-[13px]", enabled)
-    document.body.classList.toggle("font-[440]", enabled)
-  })
-
-  return null
-}
-
 function AppShellProviders(props: ParentProps) {
   return (
     <SettingsProvider>
-      <BodyDesignClass />
       <PermissionProvider>
         <LayoutProvider>
           <NotificationProvider>
@@ -315,29 +300,31 @@ export function AppInterface(props: {
   disableHealthCheck?: boolean
 }) {
   return (
-    <ServerProvider defaultServer={props.defaultServer} servers={props.servers}>
-      <ServersProvider>
-        <ConnectionGate disableHealthCheck={props.disableHealthCheck}>
-          <ServerKey>
-            <QueryProvider>
-              <ServerSDKProvider>
-                <ServerSyncProvider>
-                  <Dynamic
-                    component={props.router ?? Router}
-                    root={(routerProps) => <RouterRoot appChildren={props.children}>{routerProps.children}</RouterRoot>}
-                  >
-                    <Route path="/" component={HomeRoute} />
-                    <Route path="/:dir" component={DirectoryLayout}>
-                      <Route path="/" component={() => <Navigate href="session" />} />
-                      <Route path="/session/:id?" component={SessionRoute} />
-                    </Route>
-                  </Dynamic>
-                </ServerSyncProvider>
-              </ServerSDKProvider>
-            </QueryProvider>
-          </ServerKey>
-        </ConnectionGate>
-      </ServersProvider>
+    <ServerProvider
+      defaultServer={props.defaultServer}
+      disableHealthCheck={props.disableHealthCheck}
+      servers={props.servers}
+    >
+      <ConnectionGate disableHealthCheck={props.disableHealthCheck}>
+        <ServerKey>
+          <QueryProvider>
+            <GlobalSDKProvider>
+              <GlobalSyncProvider>
+                <Dynamic
+                  component={props.router ?? Router}
+                  root={(routerProps) => <RouterRoot appChildren={props.children}>{routerProps.children}</RouterRoot>}
+                >
+                  <Route path="/" component={HomeRoute} />
+                  <Route path="/:dir" component={DirectoryLayout}>
+                    <Route path="/" component={SessionIndexRoute} />
+                    <Route path="/session/:id?" component={SessionRoute} />
+                  </Route>
+                </Dynamic>
+              </GlobalSyncProvider>
+            </GlobalSDKProvider>
+          </QueryProvider>
+        </ServerKey>
+      </ConnectionGate>
     </ServerProvider>
   )
 }

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

@@ -12,15 +12,15 @@ import { showToast } from "@opencode-ai/ui/toast"
 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"
-import { useServerSync } from "@/context/server-sync"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useGlobalSync } from "@/context/global-sync"
 import { useLanguage } from "@/context/language"
 import { useProviders } from "@/hooks/use-providers"
 
 export function DialogConnectProvider(props: { provider: string }) {
   const dialog = useDialog()
-  const serverSync = useServerSync()
-  const serverSDK = useServerSDK()
+  const globalSync = useGlobalSync()
+  const globalSDK = useGlobalSDK()
   const language = useLanguage()
   const providers = useProviders()
 
@@ -41,7 +41,9 @@ export function DialogConnectProvider(props: { provider: string }) {
   })
 
   const provider = createMemo(
-    () => providers.all().get(props.provider) ?? serverSync.data.provider.all.get(props.provider)!,
+    () =>
+      providers.all().find((x) => x.id === props.provider) ??
+      globalSync.data.provider.all.find((x) => x.id === props.provider)!,
   )
   const fallback = createMemo<ProviderAuthMethod[]>(() => [
     {
@@ -52,16 +54,16 @@ export function DialogConnectProvider(props: { provider: string }) {
   const [auth] = createResource(
     () => props.provider,
     async () => {
-      const cached = serverSync.data.provider_auth[props.provider]
+      const cached = globalSync.data.provider_auth[props.provider]
       if (cached) return cached
-      const res = await serverSDK.client.provider.auth()
+      const res = await globalSDK.client.provider.auth()
       if (!alive.value) return fallback()
-      serverSync.set("provider_auth", res.data ?? {})
+      globalSync.set("provider_auth", res.data ?? {})
       return res.data?.[props.provider] ?? fallback()
     },
   )
-  const loading = createMemo(() => auth.loading && !serverSync.data.provider_auth[props.provider])
-  const methods = createMemo(() => auth.latest ?? serverSync.data.provider_auth[props.provider] ?? fallback())
+  const loading = createMemo(() => auth.loading && !globalSync.data.provider_auth[props.provider])
+  const methods = createMemo(() => auth.latest ?? globalSync.data.provider_auth[props.provider] ?? fallback())
   const [store, setStore] = createStore({
     methodIndex: undefined as undefined | number,
     authorization: undefined as undefined | ProviderAuthAuthorization,
@@ -158,7 +160,7 @@ export function DialogConnectProvider(props: { provider: string }) {
       }
       dispatch({ type: "auth.pending" })
       const start = Date.now()
-      await serverSDK.client.provider.oauth
+      await globalSDK.client.provider.oauth
         .authorize(
           {
             providerID: props.provider,
@@ -330,7 +332,7 @@ export function DialogConnectProvider(props: { provider: string }) {
   })
 
   async function complete() {
-    await serverSDK.client.global.dispose()
+    await globalSDK.client.global.dispose()
     dialog.close()
     showToast({
       variant: "success",
@@ -407,7 +409,7 @@ export function DialogConnectProvider(props: { provider: string }) {
       }
 
       setFormStore("error", undefined)
-      await serverSDK.client.auth.set({
+      await globalSDK.client.auth.set({
         providerID: props.provider,
         auth: {
           type: "api",
@@ -478,7 +480,7 @@ export function DialogConnectProvider(props: { provider: string }) {
       }
 
       setFormStore("error", undefined)
-      const result = await serverSDK.client.provider.oauth
+      const result = await globalSDK.client.provider.oauth
         .callback({
           providerID: props.provider,
           method: store.methodIndex,
@@ -524,14 +526,14 @@ export function DialogConnectProvider(props: { provider: string }) {
     const code = createMemo(() => {
       const instructions = store.authorization?.instructions
       if (instructions?.includes(":")) {
-        return instructions.split(":").pop()?.trim()
+        return instructions.split(":")[1]?.trim()
       }
       return instructions
     })
 
     onMount(() => {
       void (async () => {
-        const result = await serverSDK.client.provider.oauth
+        const result = await globalSDK.client.provider.oauth
           .callback({
             providerID: props.provider,
             method: store.methodIndex,

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

@@ -9,8 +9,8 @@ import { showToast } from "@opencode-ai/ui/toast"
 import { batch, For } from "solid-js"
 import { createStore, produce } from "solid-js/store"
 import { Link } from "@/components/link"
-import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "@/context/server-sync"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useGlobalSync } from "@/context/global-sync"
 import { useLanguage } from "@/context/language"
 import { type FormState, headerRow, modelRow, validateCustomProvider } from "./dialog-custom-provider-form"
 import { DialogSelectProvider } from "./dialog-select-provider"
@@ -21,8 +21,8 @@ type Props = {
 
 export function DialogCustomProvider(props: Props) {
   const dialog = useDialog()
-  const serverSync = useServerSync()
-  const serverSDK = useServerSDK()
+  const globalSync = useGlobalSync()
+  const globalSDK = useGlobalSDK()
   const language = useLanguage()
 
   const [form, setForm] = createStore<FormState>({
@@ -105,8 +105,8 @@ export function DialogCustomProvider(props: Props) {
     const output = validateCustomProvider({
       form,
       t: language.t,
-      disabledProviders: serverSync.data.config.disabled_providers ?? [],
-      existingProviderIDs: new Set(serverSync.data.provider.all.keys()),
+      disabledProviders: globalSync.data.config.disabled_providers ?? [],
+      existingProviderIDs: new Set(globalSync.data.provider.all.map((p) => p.id)),
     })
     batch(() => {
       setForm("err", output.err)
@@ -118,11 +118,11 @@ export function DialogCustomProvider(props: Props) {
 
   const saveMutation = useMutation(() => ({
     mutationFn: async (result: NonNullable<ReturnType<typeof validate>>) => {
-      const disabledProviders = serverSync.data.config.disabled_providers ?? []
+      const disabledProviders = globalSync.data.config.disabled_providers ?? []
       const nextDisabled = disabledProviders.filter((id) => id !== result.providerID)
 
       if (result.key) {
-        await serverSDK.client.auth.set({
+        await globalSDK.client.auth.set({
           providerID: result.providerID,
           auth: {
             type: "api",
@@ -131,7 +131,7 @@ export function DialogCustomProvider(props: Props) {
         })
       }
 
-      await serverSync.updateConfig({
+      await globalSync.updateConfig({
         provider: { [result.providerID]: result.config },
         disabled_providers: nextDisabled,
       })

packages/app/src/components/dialog-edit-project.tsx

@@ -6,20 +6,20 @@ import { useMutation } from "@tanstack/solid-query"
 import { Icon } from "@opencode-ai/ui/icon"
 import { createMemo, For, Show } from "solid-js"
 import { createStore } from "solid-js/store"
-import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "@/context/server-sync"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useGlobalSync } from "@/context/global-sync"
 import { type LocalProject, getAvatarColors } from "@/context/layout"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { Avatar } from "@opencode-ai/ui/avatar"
 import { useLanguage } from "@/context/language"
-import { getProjectAvatarSource } from "@/pages/layout/helpers"
+import { getProjectAvatarSource } from "@/pages/layout/sidebar-items"
 
 const AVATAR_COLOR_KEYS = ["pink", "mint", "orange", "purple", "cyan", "lime"] as const
 
 export function DialogEditProject(props: { project: LocalProject }) {
   const dialog = useDialog()
-  const serverSDK = useServerSDK()
-  const serverSync = useServerSync()
+  const globalSDK = useGlobalSDK()
+  const globalSync = useGlobalSync()
   const language = useLanguage()
 
   const folderName = createMemo(() => getFilename(props.project.worktree))
@@ -78,19 +78,19 @@ export function DialogEditProject(props: { project: LocalProject }) {
       const start = store.startup.trim()
 
       if (props.project.id && props.project.id !== "global") {
-        await serverSDK.client.project.update({
+        await globalSDK.client.project.update({
           projectID: props.project.id,
           directory: props.project.worktree,
           name,
           icon: { color: store.color || "", override: store.iconOverride || "" },
           commands: { start },
         })
-        serverSync.project.icon(props.project.worktree, store.iconOverride || undefined)
+        globalSync.project.icon(props.project.worktree, store.iconOverride || undefined)
         dialog.close()
         return
       }
 
-      serverSync.project.meta(props.project.worktree, {
+      globalSync.project.meta(props.project.worktree, {
         name,
         icon: { color: store.color || undefined, override: store.iconOverride || undefined },
         commands: { start: start || undefined },

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

@@ -6,8 +6,8 @@ import type { ListRef } from "@opencode-ai/ui/list"
 import { getDirectory, getFilename } from "@opencode-ai/core/util/path"
 import fuzzysort from "fuzzysort"
 import { createMemo, createResource, createSignal } from "solid-js"
-import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "@/context/server-sync"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useGlobalSync } from "@/context/global-sync"
 import { useLayout } from "@/context/layout"
 import { useLanguage } from "@/context/language"
 
@@ -128,7 +128,7 @@ function uniqueRows(rows: Row[]) {
 }
 
 function useDirectorySearch(args: {
-  sdk: ReturnType<typeof useServerSDK>
+  sdk: ReturnType<typeof useGlobalSDK>
   start: () => string | undefined
   home: () => string
 }) {
@@ -246,8 +246,8 @@ function useDirectorySearch(args: {
 }
 
 export function DialogSelectDirectory(props: DialogSelectDirectoryProps) {
-  const sync = useServerSync()
-  const sdk = useServerSDK()
+  const sync = useGlobalSync()
+  const sdk = useGlobalSDK()
   const layout = useLayout()
   const dialog = useDialog()
   const language = useLanguage()

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

@@ -9,8 +9,8 @@ import { getDirectory, getFilename } from "@opencode-ai/core/util/path"
 import { useNavigate } from "@solidjs/router"
 import { createMemo, createSignal, Match, onCleanup, Show, Switch } from "solid-js"
 import { formatKeybind, useCommand, type CommandOption } from "@/context/command"
-import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "@/context/server-sync"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useGlobalSync } from "@/context/global-sync"
 import { useLayout } from "@/context/layout"
 import { useFile } from "@/context/file"
 import { useLanguage } from "@/context/language"
@@ -175,7 +175,7 @@ function createFileEntries(props: {
 function createSessionEntries(props: {
   workspaces: () => string[]
   label: (directory: string) => string
-  serverSDK: ReturnType<typeof useServerSDK>
+  globalSDK: ReturnType<typeof useGlobalSDK>
   language: ReturnType<typeof useLanguage>
 }) {
   const state: {
@@ -207,7 +207,7 @@ function createSessionEntries(props: {
     state.inflight = Promise.all(
       dirs.map((directory) => {
         const description = props.label(directory)
-        return props.serverSDK.client.session
+        return props.globalSDK.client.session
           .list({ directory, roots: true })
           .then((x) =>
             (x.data ?? [])
@@ -268,8 +268,8 @@ export function DialogSelectFile(props: { mode?: DialogSelectFileMode; onOpenFil
   const file = useFile()
   const dialog = useDialog()
   const navigate = useNavigate()
-  const serverSDK = useServerSDK()
-  const serverSync = useServerSync()
+  const globalSDK = useGlobalSDK()
+  const globalSync = useGlobalSync()
   const { params, tabs, view } = useSessionLayout()
   const filesOnly = () => props.mode === "files"
   const state = { cleanup: undefined as (() => void) | void, committed: false }
@@ -292,21 +292,21 @@ export function DialogSelectFile(props: { mode?: DialogSelectFileMode; onOpenFil
     if (directory && !dirs.includes(directory)) return [...dirs, directory]
     return dirs
   })
-  const homedir = createMemo(() => serverSync.data.path.home)
+  const homedir = createMemo(() => globalSync.data.path.home)
   const label = (directory: string) => {
     const current = project()
     const kind =
       current && directory === current.worktree
         ? language.t("workspace.type.local")
         : language.t("workspace.type.sandbox")
-    const [store] = serverSync.child(directory, { bootstrap: false })
+    const [store] = globalSync.child(directory, { bootstrap: false })
     const home = homedir()
     const path = home ? directory.replace(home, "~") : directory
     const name = store.vcs?.branch ?? getFilename(directory)
     return `${kind} : ${name || path}`
   }
 
-  const { sessions } = createSessionEntries({ workspaces, label, serverSDK, language })
+  const { sessions } = createSessionEntries({ workspaces, label, globalSDK, language })
 
   const items = async (text: string) => {
     const query = text.trim()

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

@@ -6,7 +6,7 @@ import { Dialog } from "@opencode-ai/ui/dialog"
 import { List } from "@opencode-ai/ui/list"
 import { Switch } from "@opencode-ai/ui/switch"
 import { useLanguage } from "@/context/language"
-import { useQueryOptions } from "@/context/server-sync"
+import { useQueryOptions } from "@/context/global-sync"
 import { pathKey } from "@/utils/path-key"
 
 const statusLabels = {

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

@@ -91,7 +91,7 @@ export const DialogSelectModelUnpaid: Component<{ model?: ModelState }> = (props
             <div class="w-full">
               <List
                 class="w-full px-0"
-                key={(p) => p.id}
+                key={(x) => x?.id}
                 items={providers.popular}
                 activeIcon="plus-small"
                 sortBy={(a, b) => {

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

@@ -35,7 +35,7 @@ export const DialogSelectProvider: Component = () => {
         key={(x) => x?.id}
         items={() => {
           language.locale()
-          return [{ id: CUSTOM_ID, name: customLabel() }, ...providers.all().values()]
+          return [{ id: CUSTOM_ID, name: customLabel() }, ...providers.all()]
         }}
         filterKeys={["id", "name"]}
         groupBy={(x) => (popularProviders.includes(x.id) ? popularGroup() : otherGroup())}

packages/app/src/components/dialog-usage-exceeded.tsx

@@ -1,44 +0,0 @@
-import { usePlatform } from "@/context/platform"
-import { Button } from "@opencode-ai/ui/button"
-import { useDialog } from "@opencode-ai/ui/context/dialog"
-import { Dialog } from "@opencode-ai/ui/dialog"
-import { JSX } from "solid-js"
-
-export type DialogGoUpsellProps = {
-  title: string
-  description: JSX.Element
-  link?: string
-  actionLabel: string
-  onClose?: (dontShowAgain?: boolean) => void
-}
-
-export function DialogUsageExceeded(props: DialogGoUpsellProps) {
-  const dialog = useDialog()
-  const platform = usePlatform()
-
-  const runAction = () => {
-    if (props.link) platform.openLink(props.link)
-    props.onClose?.()
-    dialog.close()
-  }
-
-  const dismiss = () => {
-    props.onClose?.(true)
-    dialog.close()
-  }
-
-  return (
-    <Dialog title={props.title} description={props.description} fit>
-      <div class="flex flex-col gap-4 pl-6 pr-2.5 pb-3">
-        <div class="flex justify-end gap-2">
-          <Button variant="ghost" size="large" onClick={dismiss}>
-            Don't show again
-          </Button>
-          <Button variant="primary" size="large" onClick={runAction}>
-            {props.actionLabel}
-          </Button>
-        </div>
-      </div>
-    </Dialog>
-  )
-}

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

@@ -162,8 +162,8 @@ beforeAll(async () => {
     }),
   }))
 
-  mock.module("@/context/server-sync", () => ({
-    useServerSync: () => ({
+  mock.module("@/context/global-sync", () => ({
+    useGlobalSync: () => ({
       child: (directory: string) => {
         syncedDirectories.push(directory)
         storedSessions[directory] ??= []

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

@@ -5,7 +5,7 @@ import { Binary } from "@opencode-ai/core/util/binary"
 import { useNavigate, useParams } from "@solidjs/router"
 import { batch, type Accessor } from "solid-js"
 import type { FileSelection } from "@/context/file"
-import { useServerSync } from "@/context/server-sync"
+import { useGlobalSync } from "@/context/global-sync"
 import { useLanguage } from "@/context/language"
 import { useLayout } from "@/context/layout"
 import { useLocal } from "@/context/local"
@@ -38,7 +38,7 @@ export type FollowupDraft = {
 
 type FollowupSendInput = {
   client: ReturnType<typeof useSDK>["client"]
-  serverSync: ReturnType<typeof useServerSync>
+  globalSync: ReturnType<typeof useGlobalSync>
   sync: ReturnType<typeof useSync>
   draft: FollowupDraft
   messageID?: string
@@ -53,7 +53,7 @@ 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 [, setStore] = input.globalSync.child(input.draft.sessionDirectory)
 
   const setBusy = () => {
     if (!input.optimisticBusy) return
@@ -205,7 +205,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
   const navigate = useNavigate()
   const sdk = useSDK()
   const sync = useSync()
-  const serverSync = useServerSync()
+  const globalSync = useGlobalSync()
   const local = useLocal()
   const permission = usePermission()
   const prompt = usePrompt()
@@ -226,8 +226,8 @@ export function createPromptSubmit(input: PromptSubmitInput) {
     const sessionID = params.id
     if (!sessionID) return Promise.resolve()
 
-    serverSync.todo.set(sessionID, [])
-    const [, setStore] = serverSync.child(sdk.directory)
+    globalSync.todo.set(sessionID, [])
+    const [, setStore] = globalSync.child(sdk.directory)
     setStore("todo", sessionID, [])
 
     input.onAbort?.()
@@ -273,7 +273,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
   }
 
   const seed = (dir: string, info: Session) => {
-    const [, setStore] = serverSync.child(dir)
+    const [, setStore] = globalSync.child(dir)
     setStore("session", (list: Session[]) => {
       const result = Binary.search(list, info.id, (item) => item.id)
       const next = [...list]
@@ -354,7 +354,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
           directory: sessionDirectory,
           throwOnError: true,
         })
-        serverSync.child(sessionDirectory)
+        globalSync.child(sessionDirectory)
       }
 
       input.onNewSessionWorktreeReset?.()
@@ -557,7 +557,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
     void sendFollowupDraft({
       client,
       sync,
-      serverSync,
+      globalSync,
       draft,
       messageID,
       optimisticBusy: sessionDirectory === projectDirectory,

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

@@ -52,7 +52,7 @@ export function SessionContextUsage(props: SessionContextUsageProps) {
       }),
   )
 
-  const metrics = createMemo(() => getSessionContextMetrics(messages(), [...providers.all().values()]))
+  const metrics = createMemo(() => getSessionContextMetrics(messages(), providers.all()))
   const context = createMemo(() => metrics().context)
   const cost = createMemo(() => {
     return usd().format(metrics().totalCost)

packages/app/src/components/session/index.ts

@@ -3,4 +3,3 @@ export { SessionContextTab } from "./session-context-tab"
 export { SortableTab, FileVisual } from "./session-sortable-tab"
 export { SortableTerminalTab } from "./session-sortable-terminal-tab"
 export { NewSessionView } from "./session-new-view"
-export { NewSessionDesignView } from "./session-new-design-view"

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

@@ -132,7 +132,7 @@ export function SessionContextTab() {
       }),
   )
 
-  const metrics = createMemo(() => getSessionContextMetrics(messages(), [...providers.all().values()]))
+  const metrics = createMemo(() => getSessionContextMetrics(messages(), providers.all()))
   const ctx = createMemo(() => metrics().context)
   const formatter = createMemo(() => createSessionContextFormatter(language.intl()))
 

packages/app/src/components/session/session-header.tsx

@@ -24,9 +24,7 @@ import { useSessionLayout } from "@/pages/session/session-layout"
 import { messageAgentColor } from "@/utils/agent"
 import { decode64 } from "@/utils/base64"
 import { Persist, persisted } from "@/utils/persist"
-import { StatusPopover, StatusPopoverV2 } from "../status-popover"
-import { IconButtonV2 } from "@opencode-ai/ui/v2/components/icon-button-v2.jsx"
-import { Icon as IconV2 } from "@opencode-ai/ui/v2/components/icon.jsx"
+import { StatusPopover } from "../status-popover"
 
 const OPEN_APPS = [
   "vscode",
@@ -155,11 +153,11 @@ export function SessionHeader() {
   })
   const hotkey = createMemo(() => command.keybind("file.open"))
   const os = createMemo(() => detectOS(platform))
-  const isDesktopV2 = createMemo(() => platform.platform === "desktop" && settings.general.newLayoutDesigns())
-  const search = createMemo(() => (isDesktopV2() ? settings.general.showSearch() : true))
-  const tree = createMemo(() => (isDesktopV2() ? settings.general.showFileTree() : true))
-  const term = createMemo(() => (isDesktopV2() ? settings.general.showTerminal() : true))
-  const status = createMemo(() => (isDesktopV2() ? settings.general.showStatus() : true))
+  const isDesktopBeta = platform.platform === "desktop" && import.meta.env.VITE_OPENCODE_CHANNEL === "beta"
+  const search = createMemo(() => !isDesktopBeta || settings.general.showSearch())
+  const tree = createMemo(() => !isDesktopBeta || settings.general.showFileTree())
+  const term = createMemo(() => !isDesktopBeta || settings.general.showTerminal())
+  const status = createMemo(() => !isDesktopBeta || settings.general.showStatus())
 
   const [exists, setExists] = createStore<Partial<Record<OpenApp, boolean>>>({
     finder: true,
@@ -233,14 +231,6 @@ export function SessionHeader() {
   const tint = createMemo(() =>
     messageAgentColor(params.id ? sync.data.message[params.id] : undefined, sync.data.agent),
   )
-  const v2ActionsState = createMemo<SessionHeaderV2ActionsState>(() => ({
-    statusVisible: status(),
-    statusLabel: language.t("status.popover.trigger"),
-    reviewLabel: language.t("command.review.toggle"),
-    reviewKeybind: command.keybind("review.toggle"),
-    reviewOpened: view().reviewPanel.opened(),
-    onReviewToggle: () => view().reviewPanel.toggle(),
-  }))
 
   const selectApp = (app: OpenApp) => {
     if (!options().some((item) => item.id === app)) return
@@ -321,235 +311,193 @@ export function SessionHeader() {
       <Show when={rightMount()}>
         {(mount) => (
           <Portal mount={mount()}>
-            <Show
-              when={isDesktopV2}
-              fallback={
-                <div class="flex items-center gap-2">
-                  <Show when={projectDirectory()}>
-                    <div class="hidden xl:flex items-center">
-                      <Show
-                        when={canOpen()}
-                        fallback={
-                          <div class="flex h-[24px] box-border items-center rounded-md border border-border-weak-base bg-surface-panel overflow-hidden">
-                            <Button
-                              variant="ghost"
-                              class="rounded-none h-full py-0 pr-3 pl-0.5 gap-1.5 border-none shadow-none"
-                              onClick={copyPath}
-                              aria-label={language.t("session.header.open.copyPath")}
-                            >
-                              <Icon name="copy" size="small" class="text-icon-base" />
-                              <span class="text-12-regular text-text-strong">
-                                {language.t("session.header.open.copyPath")}
-                              </span>
-                            </Button>
+            <div class="flex items-center gap-2">
+              <Show when={projectDirectory()}>
+                <div class="hidden xl:flex items-center">
+                  <Show
+                    when={canOpen()}
+                    fallback={
+                      <div class="flex h-[24px] box-border items-center rounded-md border border-border-weak-base bg-surface-panel overflow-hidden">
+                        <Button
+                          variant="ghost"
+                          class="rounded-none h-full py-0 pr-3 pl-0.5 gap-1.5 border-none shadow-none"
+                          onClick={copyPath}
+                          aria-label={language.t("session.header.open.copyPath")}
+                        >
+                          <Icon name="copy" size="small" class="text-icon-base" />
+                          <span class="text-12-regular text-text-strong">
+                            {language.t("session.header.open.copyPath")}
+                          </span>
+                        </Button>
+                      </div>
+                    }
+                  >
+                    <div class="flex items-center">
+                      <div class="flex h-[24px] box-border items-center rounded-md border border-border-weak-base bg-surface-panel overflow-hidden">
+                        <Button
+                          variant="ghost"
+                          class="rounded-none h-full px-0.5 border-none shadow-none disabled:!cursor-default"
+                          classList={{
+                            "bg-surface-raised-base-active": opening(),
+                          }}
+                          onClick={() => openDir(current().id)}
+                          disabled={opening()}
+                          aria-label={language.t("session.header.open.ariaLabel", { app: current().label })}
+                        >
+                          <div class="flex size-5 shrink-0 items-center justify-center [&_[data-component=app-icon]]:size-5">
+                            <Show when={opening()} fallback={<AppIcon id={current().icon} />}>
+                              <Spinner class="size-3.5" style={{ color: tint() ?? "var(--icon-base)" }} />
+                            </Show>
                           </div>
-                        }
-                      >
-                        <div class="flex items-center">
-                          <div class="flex h-[24px] box-border items-center rounded-md border border-border-weak-base bg-surface-panel overflow-hidden">
-                            <Button
-                              variant="ghost"
-                              class="rounded-none h-full px-0.5 border-none shadow-none disabled:!cursor-default"
-                              classList={{
-                                "bg-surface-raised-base-active": opening(),
-                              }}
-                              onClick={() => openDir(current().id)}
-                              disabled={opening()}
-                              aria-label={language.t("session.header.open.ariaLabel", { app: current().label })}
-                            >
-                              <div class="flex size-5 shrink-0 items-center justify-center [&_[data-component=app-icon]]:size-5">
-                                <Show when={opening()} fallback={<AppIcon id={current().icon} />}>
-                                  <Spinner class="size-3.5" style={{ color: tint() ?? "var(--icon-base)" }} />
-                                </Show>
-                              </div>
-                            </Button>
-                            <DropdownMenu
-                              gutter={4}
-                              placement="bottom-end"
-                              open={menu.open}
-                              onOpenChange={(open) => setMenu("open", open)}
-                            >
-                              <DropdownMenu.Trigger
-                                as={IconButton}
-                                icon="chevron-down"
-                                variant="ghost"
-                                disabled={opening()}
-                                class="rounded-none h-full w-[20px] p-0 border-none shadow-none data-[expanded]:bg-surface-raised-base-active disabled:!cursor-default"
-                                classList={{
-                                  "bg-surface-raised-base-active": opening(),
+                        </Button>
+                        <DropdownMenu
+                          gutter={4}
+                          placement="bottom-end"
+                          open={menu.open}
+                          onOpenChange={(open) => setMenu("open", open)}
+                        >
+                          <DropdownMenu.Trigger
+                            as={IconButton}
+                            icon="chevron-down"
+                            variant="ghost"
+                            disabled={opening()}
+                            class="rounded-none h-full w-[20px] p-0 border-none shadow-none data-[expanded]:bg-surface-raised-base-active disabled:!cursor-default"
+                            classList={{
+                              "bg-surface-raised-base-active": opening(),
+                            }}
+                            aria-label={language.t("session.header.open.menu")}
+                          />
+                          <DropdownMenu.Portal>
+                            <DropdownMenu.Content class="[&_[data-slot=dropdown-menu-item]]:pl-1 [&_[data-slot=dropdown-menu-radio-item]]:pl-1 [&_[data-slot=dropdown-menu-radio-item]+[data-slot=dropdown-menu-radio-item]]:mt-1">
+                              <DropdownMenu.Group>
+                                <DropdownMenu.GroupLabel class="!px-1 !py-1">
+                                  {language.t("session.header.openIn")}
+                                </DropdownMenu.GroupLabel>
+                                <DropdownMenu.RadioGroup
+                                  class="mt-1"
+                                  value={current().id}
+                                  onChange={(value) => {
+                                    if (!OPEN_APPS.includes(value as OpenApp)) return
+                                    selectApp(value as OpenApp)
+                                  }}
+                                >
+                                  <For each={options()}>
+                                    {(o) => (
+                                      <DropdownMenu.RadioItem
+                                        value={o.id}
+                                        disabled={opening()}
+                                        onSelect={() => {
+                                          setMenu("open", false)
+                                          openDir(o.id)
+                                        }}
+                                      >
+                                        <div class="flex size-5 shrink-0 items-center justify-center [&_[data-component=app-icon]]:size-5">
+                                          <AppIcon id={o.icon} />
+                                        </div>
+                                        <DropdownMenu.ItemLabel>{o.label}</DropdownMenu.ItemLabel>
+                                        <DropdownMenu.ItemIndicator>
+                                          <Icon name="check-small" size="small" class="text-icon-weak" />
+                                        </DropdownMenu.ItemIndicator>
+                                      </DropdownMenu.RadioItem>
+                                    )}
+                                  </For>
+                                </DropdownMenu.RadioGroup>
+                              </DropdownMenu.Group>
+                              <DropdownMenu.Separator />
+                              <DropdownMenu.Item
+                                onSelect={() => {
+                                  setMenu("open", false)
+                                  copyPath()
                                 }}
-                                aria-label={language.t("session.header.open.menu")}
-                              />
-                              <DropdownMenu.Portal>
-                                <DropdownMenu.Content class="[&_[data-slot=dropdown-menu-item]]:pl-1 [&_[data-slot=dropdown-menu-radio-item]]:pl-1 [&_[data-slot=dropdown-menu-radio-item]+[data-slot=dropdown-menu-radio-item]]:mt-1">
-                                  <DropdownMenu.Group>
-                                    <DropdownMenu.GroupLabel class="!px-1 !py-1">
-                                      {language.t("session.header.openIn")}
-                                    </DropdownMenu.GroupLabel>
-                                    <DropdownMenu.RadioGroup
-                                      class="mt-1"
-                                      value={current().id}
-                                      onChange={(value) => {
-                                        if (!OPEN_APPS.includes(value as OpenApp)) return
-                                        selectApp(value as OpenApp)
-                                      }}
-                                    >
-                                      <For each={options()}>
-                                        {(o) => (
-                                          <DropdownMenu.RadioItem
-                                            value={o.id}
-                                            disabled={opening()}
-                                            onSelect={() => {
-                                              setMenu("open", false)
-                                              openDir(o.id)
-                                            }}
-                                          >
-                                            <div class="flex size-5 shrink-0 items-center justify-center [&_[data-component=app-icon]]:size-5">
-                                              <AppIcon id={o.icon} />
-                                            </div>
-                                            <DropdownMenu.ItemLabel>{o.label}</DropdownMenu.ItemLabel>
-                                            <DropdownMenu.ItemIndicator>
-                                              <Icon name="check-small" size="small" class="text-icon-weak" />
-                                            </DropdownMenu.ItemIndicator>
-                                          </DropdownMenu.RadioItem>
-                                        )}
-                                      </For>
-                                    </DropdownMenu.RadioGroup>
-                                  </DropdownMenu.Group>
-                                  <DropdownMenu.Separator />
-                                  <DropdownMenu.Item
-                                    onSelect={() => {
-                                      setMenu("open", false)
-                                      copyPath()
-                                    }}
-                                  >
-                                    <div class="flex size-5 shrink-0 items-center justify-center">
-                                      <Icon name="copy" size="small" class="text-icon-weak" />
-                                    </div>
-                                    <DropdownMenu.ItemLabel>
-                                      {language.t("session.header.open.copyPath")}
-                                    </DropdownMenu.ItemLabel>
-                                  </DropdownMenu.Item>
-                                </DropdownMenu.Content>
-                              </DropdownMenu.Portal>
-                            </DropdownMenu>
-                          </div>
-                        </div>
-                      </Show>
+                              >
+                                <div class="flex size-5 shrink-0 items-center justify-center">
+                                  <Icon name="copy" size="small" class="text-icon-weak" />
+                                </div>
+                                <DropdownMenu.ItemLabel>
+                                  {language.t("session.header.open.copyPath")}
+                                </DropdownMenu.ItemLabel>
+                              </DropdownMenu.Item>
+                            </DropdownMenu.Content>
+                          </DropdownMenu.Portal>
+                        </DropdownMenu>
+                      </div>
                     </div>
                   </Show>
-                  <div class="flex items-center gap-1">
-                    <Show when={status()}>
-                      <Tooltip placement="bottom" value={language.t("status.popover.trigger")}>
-                        <StatusPopover />
-                      </Tooltip>
-                    </Show>
-                    <Show when={term()}>
-                      <TooltipKeybind
-                        title={language.t("command.terminal.toggle")}
-                        keybind={command.keybind("terminal.toggle")}
-                      >
-                        <Button
-                          variant="ghost"
-                          class="group/terminal-toggle titlebar-icon w-8 h-6 p-0 box-border shrink-0"
-                          onClick={toggleTerminal}
-                          aria-label={language.t("command.terminal.toggle")}
-                          aria-expanded={view().terminal.opened()}
-                          aria-controls="terminal-panel"
-                        >
-                          <Icon size="small" name={view().terminal.opened() ? "terminal-active" : "terminal"} />
-                        </Button>
-                      </TooltipKeybind>
-                    </Show>
-
-                    <div class="hidden md:flex items-center gap-1 shrink-0">
-                      <TooltipKeybind
-                        title={language.t("command.review.toggle")}
-                        keybind={command.keybind("review.toggle")}
-                      >
-                        <Button
-                          variant="ghost"
-                          class="group/review-toggle titlebar-icon w-8 h-6 p-0 box-border"
-                          onClick={() => view().reviewPanel.toggle()}
-                          aria-label={language.t("command.review.toggle")}
-                          aria-expanded={view().reviewPanel.opened()}
-                          aria-controls="review-panel"
-                        >
-                          <Icon size="small" name={view().reviewPanel.opened() ? "review-active" : "review"} />
-                        </Button>
-                      </TooltipKeybind>
-
-                      <Show when={tree()}>
-                        <TooltipKeybind
-                          title={language.t("command.fileTree.toggle")}
-                          keybind={command.keybind("fileTree.toggle")}
-                        >
-                          <Button
-                            variant="ghost"
-                            class="titlebar-icon w-8 h-6 p-0 box-border"
-                            onClick={() => layout.fileTree.toggle()}
-                            aria-label={language.t("command.fileTree.toggle")}
-                            aria-expanded={layout.fileTree.opened()}
-                            aria-controls="file-tree-panel"
-                          >
-                            <div class="relative flex items-center justify-center size-4">
-                              <Icon
-                                size="small"
-                                name={layout.fileTree.opened() ? "file-tree-active" : "file-tree"}
-                                classList={{
-                                  "text-icon-strong": layout.fileTree.opened(),
-                                  "text-icon-weak": !layout.fileTree.opened(),
-                                }}
-                              />
-                            </div>
-                          </Button>
-                        </TooltipKeybind>
-                      </Show>
-                    </div>
-                  </div>
                 </div>
-              }
-            >
-              <SessionHeaderV2Actions state={v2ActionsState()} />
-            </Show>
+              </Show>
+              <div class="flex items-center gap-1">
+                <Show when={status()}>
+                  <Tooltip placement="bottom" value={language.t("status.popover.trigger")}>
+                    <StatusPopover />
+                  </Tooltip>
+                </Show>
+                <Show when={term()}>
+                  <TooltipKeybind
+                    title={language.t("command.terminal.toggle")}
+                    keybind={command.keybind("terminal.toggle")}
+                  >
+                    <Button
+                      variant="ghost"
+                      class="group/terminal-toggle titlebar-icon w-8 h-6 p-0 box-border shrink-0"
+                      onClick={toggleTerminal}
+                      aria-label={language.t("command.terminal.toggle")}
+                      aria-expanded={view().terminal.opened()}
+                      aria-controls="terminal-panel"
+                    >
+                      <Icon size="small" name={view().terminal.opened() ? "terminal-active" : "terminal"} />
+                    </Button>
+                  </TooltipKeybind>
+                </Show>
+
+                <div class="hidden md:flex items-center gap-1 shrink-0">
+                  <TooltipKeybind
+                    title={language.t("command.review.toggle")}
+                    keybind={command.keybind("review.toggle")}
+                  >
+                    <Button
+                      variant="ghost"
+                      class="group/review-toggle titlebar-icon w-8 h-6 p-0 box-border"
+                      onClick={() => view().reviewPanel.toggle()}
+                      aria-label={language.t("command.review.toggle")}
+                      aria-expanded={view().reviewPanel.opened()}
+                      aria-controls="review-panel"
+                    >
+                      <Icon size="small" name={view().reviewPanel.opened() ? "review-active" : "review"} />
+                    </Button>
+                  </TooltipKeybind>
+
+                  <Show when={tree()}>
+                    <TooltipKeybind
+                      title={language.t("command.fileTree.toggle")}
+                      keybind={command.keybind("fileTree.toggle")}
+                    >
+                      <Button
+                        variant="ghost"
+                        class="titlebar-icon w-8 h-6 p-0 box-border"
+                        onClick={() => layout.fileTree.toggle()}
+                        aria-label={language.t("command.fileTree.toggle")}
+                        aria-expanded={layout.fileTree.opened()}
+                        aria-controls="file-tree-panel"
+                      >
+                        <div class="relative flex items-center justify-center size-4">
+                          <Icon
+                            size="small"
+                            name={layout.fileTree.opened() ? "file-tree-active" : "file-tree"}
+                            classList={{
+                              "text-icon-strong": layout.fileTree.opened(),
+                              "text-icon-weak": !layout.fileTree.opened(),
+                            }}
+                          />
+                        </div>
+                      </Button>
+                    </TooltipKeybind>
+                  </Show>
+                </div>
+              </div>
+            </div>
           </Portal>
         )}
       </Show>
     </>
   )
 }
-
-type SessionHeaderV2ActionsState = {
-  statusVisible: boolean
-  statusLabel: string
-  reviewLabel: string
-  reviewKeybind: string
-  reviewOpened: boolean
-  onReviewToggle: () => void
-}
-
-function SessionHeaderV2Actions(props: { state: SessionHeaderV2ActionsState }) {
-  return (
-    <div class="flex items-center gap-0">
-      <Show when={props.state.statusVisible}>
-        <Tooltip placement="bottom" value={props.state.statusLabel}>
-          <StatusPopoverV2 />
-        </Tooltip>
-      </Show>
-      <TooltipKeybind title={props.state.reviewLabel} keybind={props.state.reviewKeybind}>
-        <IconButtonV2
-          type="button"
-          variant="ghost-muted"
-          size="large"
-          class="!w-9 shrink-0"
-          state={props.state.reviewOpened ? "pressed" : undefined}
-          onClick={props.state.onReviewToggle}
-          aria-label={props.state.reviewLabel}
-          aria-expanded={props.state.reviewOpened}
-          aria-controls="review-panel"
-          icon={<IconV2 name="sidebar-right" />}
-        />
-      </TooltipKeybind>
-    </div>
-  )
-}

packages/app/src/components/session/session-new-design-view.tsx

@@ -1,15 +0,0 @@
-import type { JSX } from "solid-js"
-import { WordmarkV2 } from "@opencode-ai/ui/v2/components/wordmark-v2.jsx"
-
-export function NewSessionDesignView(props: { children: JSX.Element }) {
-  return (
-    <div data-component="session-new-design" class="relative size-full overflow-hidden bg-v2-background-bg-deep">
-      <div class="absolute inset-x-0 top-[25.375%] flex justify-center px-6">
-        <div class="w-full max-w-[720px]">
-          <WordmarkV2 class="h-auto w-full text-v2-icon-icon-base" />
-          <div class="mt-8">{props.children}</div>
-        </div>
-      </div>
-    </div>
-  )
-}

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

@@ -12,8 +12,8 @@ import { useParams } from "@solidjs/router"
 import { useLanguage } from "@/context/language"
 import { usePermission } from "@/context/permission"
 import { usePlatform, type DisplayBackend } from "@/context/platform"
-import { useServerSync } from "@/context/server-sync"
-import { useServerSDK } from "@/context/server-sdk"
+import { useGlobalSync } from "@/context/global-sync"
+import { useGlobalSDK } from "@/context/global-sdk"
 import {
   monoDefault,
   monoFontFamily,
@@ -175,8 +175,8 @@ export const SettingsGeneral: Component = () => {
 
   const themeOptions = createMemo<ThemeOption[]>(() => theme.ids().map((id) => ({ id, name: theme.name(id) })))
 
-  const serverSync = useServerSync()
-  const globalSdk = useServerSDK()
+  const globalSync = useGlobalSync()
+  const globalSdk = useGlobalSDK()
 
   const [shells] = createResource(
     () =>
@@ -193,22 +193,16 @@ export const SettingsGeneral: Component = () => {
     { initialValue: null as DisplayBackend | null },
   )
 
-  const [pinchZoom, { mutate: setPinchZoom }] = createResource(
-    () => (desktop() && platform.getPinchZoomEnabled ? true : false),
-    () => Promise.resolve(platform.getPinchZoomEnabled?.() ?? false).catch(() => false),
-    { initialValue: false },
-  )
-
   onMount(() => {
     void theme.loadThemes()
   })
 
   const autoOption = { id: "auto", value: "", label: language.t("settings.general.row.shell.autoDefault") }
-  const currentShell = createMemo(() => serverSync.data.config.shell ?? "")
+  const currentShell = createMemo(() => globalSync.data.config.shell ?? "")
 
   const shellOptions = createMemo<ShellSelectOption[]>(() => {
     const list = shells.latest
-    const current = serverSync.data.config.shell
+    const current = globalSync.data.config.shell
 
     const nameCounts = new Map<string, number>()
     for (const s of list) {
@@ -245,13 +239,6 @@ export const SettingsGeneral: Component = () => {
     })
   }
 
-  const onPinchZoomChange = (checked: boolean) => {
-    setPinchZoom(checked)
-    const update = platform.setPinchZoomEnabled?.(checked)
-    if (!update) return
-    void update.catch(() => setPinchZoom(!checked))
-  }
-
   const colorSchemeOptions = createMemo((): { value: ColorScheme; label: string }[] => [
     { value: "system", label: language.t("theme.scheme.system") },
     { value: "light", label: language.t("theme.scheme.light") },
@@ -343,7 +330,7 @@ export const SettingsGeneral: Component = () => {
             onSelect={(option) => {
               if (!option) return
               if (option.value === currentShell()) return
-              serverSync.updateConfig({ shell: option.value })
+              globalSync.updateConfig({ shell: option.value })
             }}
             variant="secondary"
             size="small"
@@ -399,18 +386,6 @@ export const SettingsGeneral: Component = () => {
             />
           </div>
         </SettingsRow>
-
-        <SettingsRow
-          title={language.t("settings.general.row.newLayoutDesigns.title")}
-          description={language.t("settings.general.row.newLayoutDesigns.description")}
-        >
-          <div data-action="settings-new-layout-designs">
-            <Switch
-              checked={settings.general.newLayoutDesigns()}
-              onChange={(checked) => settings.general.setNewLayoutDesigns(checked)}
-            />
-          </div>
-        </SettingsRow>
       </SettingsList>
     </div>
   )
@@ -456,6 +431,18 @@ export const SettingsGeneral: Component = () => {
           </div>
         </SettingsRow>
 
+        <SettingsRow
+          title={language.t("settings.general.row.showTerminal.title")}
+          description={language.t("settings.general.row.showTerminal.description")}
+        >
+          <div data-action="settings-show-terminal">
+            <Switch
+              checked={settings.general.showTerminal()}
+              onChange={(checked) => settings.general.setShowTerminal(checked)}
+            />
+          </div>
+        </SettingsRow>
+
         <SettingsRow
           title={language.t("settings.general.row.showStatus.title")}
           description={language.t("settings.general.row.showStatus.description")}
@@ -467,18 +454,6 @@ export const SettingsGeneral: Component = () => {
             />
           </div>
         </SettingsRow>
-
-        <SettingsRow
-          title={language.t("settings.general.row.showCustomAgents.title")}
-          description={language.t("settings.general.row.showCustomAgents.description")}
-        >
-          <div data-action="settings-show-custom-agents">
-            <Switch
-              checked={settings.general.showCustomAgents()}
-              onChange={(checked) => settings.general.setShowCustomAgents(checked)}
-            />
-          </div>
-        </SettingsRow>
       </SettingsList>
     </div>
   )
@@ -754,45 +729,7 @@ export const SettingsGeneral: Component = () => {
     </div>
   )
 
-  const DisplaySection = () => (
-    <Show when={desktop()}>
-      <div class="flex flex-col gap-1">
-        <h3 class="text-14-medium text-text-strong pb-2">{language.t("settings.general.section.display")}</h3>
-
-        <SettingsList>
-          <SettingsRow
-            title={language.t("settings.general.row.pinchZoom.title")}
-            description={language.t("settings.general.row.pinchZoom.description")}
-          >
-            <div data-action="settings-pinch-zoom">
-              <Switch checked={pinchZoom.latest} onChange={onPinchZoomChange} />
-            </div>
-          </SettingsRow>
-
-          <Show when={linux()}>
-            <SettingsRow
-              title={
-                <div class="flex items-center gap-2">
-                  <span>{language.t("settings.general.row.wayland.title")}</span>
-                  <Tooltip value={language.t("settings.general.row.wayland.tooltip")} placement="top">
-                    <span class="text-text-weak">
-                      <Icon name="help" size="small" />
-                    </span>
-                  </Tooltip>
-                </div>
-              }
-              description={language.t("settings.general.row.wayland.description")}
-            >
-              <div data-action="settings-wayland">
-                <Switch checked={displayBackend.latest === "wayland"} onChange={onDisplayBackendChange} />
-              </div>
-            </SettingsRow>
-          </Show>
-        </SettingsList>
-      </div>
-    </Show>
-  )
-
+  console.log(import.meta.env)
   return (
     <div class="flex flex-col h-full overflow-y-auto no-scrollbar px-4 pb-10 sm:px-10 sm:pb-10">
       <div class="sticky top-0 z-10 bg-[linear-gradient(to_bottom,var(--surface-stronger-non-alpha)_calc(100%_-_24px),transparent)]">
@@ -812,9 +749,33 @@ export const SettingsGeneral: Component = () => {
 
         <UpdatesSection />
 
-        <DisplaySection />
+        <Show when={linux()}>
+          <div class="flex flex-col gap-1">
+            <h3 class="text-14-medium text-text-strong pb-2">{language.t("settings.general.section.display")}</h3>
 
-        <Show when={desktop()}>
+            <SettingsList>
+              <SettingsRow
+                title={
+                  <div class="flex items-center gap-2">
+                    <span>{language.t("settings.general.row.wayland.title")}</span>
+                    <Tooltip value={language.t("settings.general.row.wayland.tooltip")} placement="top">
+                      <span class="text-text-weak">
+                        <Icon name="help" size="small" />
+                      </span>
+                    </Tooltip>
+                  </div>
+                }
+                description={language.t("settings.general.row.wayland.description")}
+              >
+                <div data-action="settings-wayland">
+                  <Switch checked={displayBackend.latest === "wayland"} onChange={onDisplayBackendChange} />
+                </div>
+              </SettingsRow>
+            </SettingsList>
+          </div>
+        </Show>
+
+        <Show when={desktop() && import.meta.env.VITE_OPENCODE_CHANNEL === "beta"}>
           <AdvancedSection />
         </Show>
       </div>

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

@@ -6,8 +6,8 @@ import { showToast } from "@opencode-ai/ui/toast"
 import { popularProviders, useProviders } from "@/hooks/use-providers"
 import { createMemo, type Component, For, Show } from "solid-js"
 import { useLanguage } from "@/context/language"
-import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "@/context/server-sync"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useGlobalSync } from "@/context/global-sync"
 import { DialogConnectProvider } from "./dialog-connect-provider"
 import { DialogSelectProvider } from "./dialog-select-provider"
 import { DialogCustomProvider } from "./dialog-custom-provider"
@@ -30,8 +30,8 @@ const PROVIDER_NOTES = [
 export const SettingsProviders: Component = () => {
   const dialog = useDialog()
   const language = useLanguage()
-  const serverSDK = useServerSDK()
-  const serverSync = useServerSync()
+  const globalSDK = useGlobalSDK()
+  const globalSync = useGlobalSync()
   const providers = useProviders()
 
   const connected = createMemo(() => {
@@ -74,7 +74,7 @@ export const SettingsProviders: Component = () => {
   const note = (id: string) => PROVIDER_NOTES.find((item) => item.match(id))?.key
 
   const isConfigCustom = (providerID: string) => {
-    const provider = serverSync.data.config.provider?.[providerID]
+    const provider = globalSync.data.config.provider?.[providerID]
     if (!provider) return false
     if (provider.npm !== "@ai-sdk/openai-compatible") return false
     if (!provider.models || Object.keys(provider.models).length === 0) return false
@@ -82,11 +82,11 @@ export const SettingsProviders: Component = () => {
   }
 
   const disableProvider = async (providerID: string, name: string) => {
-    const before = serverSync.data.config.disabled_providers ?? []
+    const before = globalSync.data.config.disabled_providers ?? []
     const next = before.includes(providerID) ? before : [...before, providerID]
-    serverSync.set("config", "disabled_providers", next)
+    globalSync.set("config", "disabled_providers", next)
 
-    await serverSync
+    await globalSync
       .updateConfig({ disabled_providers: next })
       .then(() => {
         showToast({
@@ -97,7 +97,7 @@ export const SettingsProviders: Component = () => {
         })
       })
       .catch((err: unknown) => {
-        serverSync.set("config", "disabled_providers", before)
+        globalSync.set("config", "disabled_providers", before)
         const message = err instanceof Error ? err.message : String(err)
         showToast({ title: language.t("common.requestFailed"), description: message })
       })
@@ -105,14 +105,14 @@ export const SettingsProviders: Component = () => {
 
   const disconnect = async (providerID: string, name: string) => {
     if (isConfigCustom(providerID)) {
-      await serverSDK.client.auth.remove({ providerID }).catch(() => undefined)
+      await globalSDK.client.auth.remove({ providerID }).catch(() => undefined)
       await disableProvider(providerID, name)
       return
     }
-    await serverSDK.client.auth
+    await globalSDK.client.auth
       .remove({ providerID })
       .then(async () => {
-        await serverSDK.client.global.dispose()
+        await globalSDK.client.global.dispose()
         showToast({
           variant: "success",
           icon: "circle-check",

packages/app/src/components/status-popover-body.tsx

@@ -7,17 +7,16 @@ import { useMutation, useQueryClient } from "@tanstack/solid-query"
 import { showToast } from "@opencode-ai/ui/toast"
 import { useNavigate } from "@solidjs/router"
 import { type Accessor, createEffect, createMemo, For, type JSXElement, onCleanup, Show } from "solid-js"
-import { createStore } from "solid-js/store"
+import { createStore, reconcile } from "solid-js/store"
 import { ServerHealthIndicator, ServerRow } from "@/components/server/server-row"
 import { useLanguage } from "@/context/language"
 import { usePlatform } from "@/context/platform"
 import { useSDK } from "@/context/sdk"
 import { normalizeServerUrl, ServerConnection, useServer } from "@/context/server"
 import { useSync } from "@/context/sync"
-import { type ServerHealth } from "@/utils/server-health"
-import { useQueryOptions } from "@/context/server-sync"
+import { useCheckServerHealth, type ServerHealth } from "@/utils/server-health"
+import { useQueryOptions } from "@/context/global-sync"
 import { pathKey } from "@/utils/path-key"
-import { useServers } from "@/context/servers"
 
 const pollMs = 10_000
 
@@ -55,6 +54,40 @@ const listServersByHealth = (
   })
 }
 
+const useServerHealth = (servers: Accessor<ServerConnection.Any[]>, enabled: Accessor<boolean>) => {
+  const checkServerHealth = useCheckServerHealth()
+  const [status, setStatus] = createStore({} as Record<ServerConnection.Key, ServerHealth | undefined>)
+
+  createEffect(() => {
+    if (!enabled()) {
+      setStatus(reconcile({}))
+      return
+    }
+    const list = servers()
+    let dead = false
+
+    const refresh = async () => {
+      const results: Record<string, ServerHealth> = {}
+      await Promise.all(
+        list.map(async (conn) => {
+          results[ServerConnection.key(conn)] = await checkServerHealth(conn.http)
+        }),
+      )
+      if (dead) return
+      setStatus(reconcile(results))
+    }
+
+    void refresh()
+    const id = setInterval(() => void refresh(), pollMs)
+    onCleanup(() => {
+      dead = true
+      clearInterval(id)
+    })
+  })
+
+  return status
+}
+
 const useDefaultServerKey = (
   get: (() => string | Promise<string | null | undefined> | null | undefined) | undefined,
 ) => {
@@ -133,162 +166,8 @@ const useMcpToggleMutation = () => {
   }))
 }
 
-type ServerStatusState = {
-  servers: () => ServerStatusItem[]
-  defaultKey: () => ServerConnection.Key | undefined
-  ariaLabel: string
-  serversLabel: string
-  defaultLabel: string
-  manageLabel: string
-  onManage: () => void
-}
-
-type ServerStatusItem = {
-  key: ServerConnection.Key
-  conn: ServerConnection.Any
-  health?: ServerHealth
-  blocked: boolean
-  active: boolean
-  onSelect: () => void
-}
-
-export function StatusPopoverServerBody() {
-  const servers = useServers()
-  const server = useServer()
-  const platform = usePlatform()
-  const dialog = useDialog()
-  const language = useLanguage()
-  const navigate = useNavigate()
-
-  let dialogRun = 0
-  let dialogDead = false
-  onCleanup(() => {
-    dialogDead = true
-    dialogRun += 1
-  })
-
-  const sortedServers = createMemo(() => listServersByHealth(servers.list(), server.key, servers.health))
-  const defaultServer = useDefaultServerKey(platform.getDefaultServer)
-  const serverItems = createMemo(() =>
-    sortedServers().map((conn) => {
-      const key = ServerConnection.key(conn)
-      return {
-        key,
-        conn,
-        health: servers.health[key],
-        blocked: servers.health[key]?.healthy === false,
-        active: !!server.current && key === ServerConnection.key(server.current),
-        onSelect: () => {
-          navigate("/")
-          queueMicrotask(() => server.setActive(key))
-        },
-      }
-    }),
-  )
-
-  return (
-    <ServerStatusPopoverView
-      state={{
-        servers: serverItems,
-        defaultKey: defaultServer.key,
-        ariaLabel: language.t("status.popover.ariaLabel"),
-        serversLabel: language.t("status.popover.tab.servers"),
-        defaultLabel: language.t("common.default"),
-        manageLabel: language.t("status.popover.action.manageServers"),
-        onManage: () => {
-          const run = ++dialogRun
-          void import("./dialog-select-server").then((x) => {
-            if (dialogDead || dialogRun !== run) return
-            dialog.show(() => <x.DialogSelectServer />, defaultServer.refresh)
-          })
-        },
-      }}
-    />
-  )
-}
-
-function ServerStatusPopoverView(props: { state: ServerStatusState }) {
-  return (
-    <div class="flex items-center gap-1 w-[360px] rounded-xl shadow-[var(--shadow-lg-border-base)]">
-      <Tabs
-        aria-label={props.state.ariaLabel}
-        class="tabs bg-background-strong rounded-xl overflow-hidden"
-        data-component="tabs"
-        data-active="servers"
-        defaultValue="servers"
-        variant="alt"
-      >
-        <Tabs.List data-slot="tablist" class="bg-transparent border-b-0 px-4 pt-2 pb-0 gap-4 h-10">
-          <Tabs.Trigger value="servers" data-slot="tab" class="text-12-regular">
-            {props.state.servers().length > 0 ? `${props.state.servers().length} ` : ""}
-            {props.state.serversLabel}
-          </Tabs.Trigger>
-        </Tabs.List>
-        <Tabs.Content value="servers">
-          <ServerStatusList state={props.state} />
-        </Tabs.Content>
-      </Tabs>
-    </div>
-  )
-}
-
-function ServerStatusList(props: { state: ServerStatusState }) {
-  return (
-    <div class="flex flex-col px-2 pb-2">
-      <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
-        <For each={props.state.servers()}>
-          {(item) => {
-            return (
-              <button
-                type="button"
-                class="flex items-center gap-2 w-full h-8 pl-3 pr-1.5 py-1.5 rounded-md transition-colors text-left"
-                classList={{
-                  "hover:bg-surface-raised-base-hover": !item.blocked,
-                  "cursor-not-allowed": item.blocked,
-                }}
-                aria-disabled={item.blocked}
-                onClick={() => {
-                  if (item.blocked) return
-                  item.onSelect()
-                }}
-              >
-                <ServerHealthIndicator health={item.health} />
-                <ServerRow
-                  conn={item.conn}
-                  dimmed={item.blocked}
-                  status={item.health}
-                  class="flex items-center gap-2 w-full min-w-0"
-                  nameClass="text-14-regular text-text-base truncate"
-                  versionClass="text-12-regular text-text-weak truncate"
-                  badge={
-                    <Show when={item.key === props.state.defaultKey()}>
-                      <span class="text-11-regular text-text-base bg-surface-base px-1.5 py-0.5 rounded-md">
-                        {props.state.defaultLabel}
-                      </span>
-                    </Show>
-                  }
-                >
-                  <div class="flex-1" />
-                  <Show when={item.active}>
-                    <Icon name="check" size="small" class="text-icon-weak shrink-0" />
-                  </Show>
-                </ServerRow>
-              </button>
-            )
-          }}
-        </For>
-
-        <Button variant="secondary" class="mt-3 self-start h-8 px-3 py-1.5" onClick={props.state.onManage}>
-          {props.state.manageLabel}
-        </Button>
-      </div>
-    </div>
-  )
-}
-
 export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
   const sync = useSync()
-  const servers = useServers()
   const server = useServer()
   const platform = usePlatform()
   const dialog = useDialog()
@@ -313,7 +192,15 @@ export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
     dialogDead = true
     dialogRun += 1
   })
-  const sortedServers = createMemo(() => listServersByHealth(servers.list(), server.key, servers.health))
+  const servers = createMemo(() => {
+    const current = server.current
+    const list = server.list
+    if (!current) return list
+    if (list.every((item) => ServerConnection.key(item) !== ServerConnection.key(current))) return [current, ...list]
+    return [current, ...list.filter((item) => ServerConnection.key(item) !== ServerConnection.key(current))]
+  })
+  const health = useServerHealth(servers, props.shown)
+  const sortedServers = createMemo(() => listServersByHealth(servers(), server.key, health))
   const toggleMcp = useMcpToggleMutation()
   const defaultServer = useDefaultServerKey(platform.getDefaultServer)
   const mcpNames = createMemo(() => Object.keys(sync.data.mcp ?? {}).sort((a, b) => a.localeCompare(b)))
@@ -339,7 +226,7 @@ export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
       >
         <Tabs.List data-slot="tablist" class="bg-transparent border-b-0 px-4 pt-2 pb-0 gap-4 h-10">
           <Tabs.Trigger value="servers" data-slot="tab" class="text-12-regular">
-            {servers.list().length > 0 ? `${servers.list().length} ` : ""}
+            {sortedServers().length > 0 ? `${sortedServers().length} ` : ""}
             {language.t("status.popover.tab.servers")}
           </Tabs.Trigger>
           <Tabs.Trigger value="mcp" data-slot="tab" class="text-12-regular">
@@ -362,7 +249,7 @@ export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
               <For each={sortedServers()}>
                 {(s) => {
                   const key = ServerConnection.key(s)
-                  const blocked = () => servers.health[key]?.healthy === false
+                  const blocked = () => health[key]?.healthy === false
                   return (
                     <button
                       type="button"
@@ -378,11 +265,11 @@ export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
                         queueMicrotask(() => server.setActive(key))
                       }}
                     >
-                      <ServerHealthIndicator health={servers.health[key]} />
+                      <ServerHealthIndicator health={health[key]} />
                       <ServerRow
                         conn={s}
                         dimmed={blocked()}
-                        status={servers.health[key]}
+                        status={health[key]}
                         class="flex items-center gap-2 w-full min-w-0"
                         nameClass="text-14-regular text-text-base truncate"
                         versionClass="text-12-regular text-text-weak truncate"

packages/app/src/components/status-popover.tsx

@@ -1,24 +1,19 @@
 import { Button } from "@opencode-ai/ui/button"
 import { Icon } from "@opencode-ai/ui/icon"
-import { IconButtonV2 } from "@opencode-ai/ui/v2/components/icon-button-v2.jsx"
-import { Icon as IconV2 } from "@opencode-ai/ui/v2/components/icon.jsx"
 import { Popover } from "@opencode-ai/ui/popover"
-import { Suspense, createMemo, createSignal, lazy, Show, type JSX } from "solid-js"
+import { Suspense, createMemo, createSignal, lazy, Show } from "solid-js"
 import { useLanguage } from "@/context/language"
 import { useServer } from "@/context/server"
 import { useSync } from "@/context/sync"
-import { useServers } from "@/context/servers"
 
 const Body = lazy(() => import("./status-popover-body").then((x) => ({ default: x.StatusPopoverBody })))
-const ServerBody = lazy(() => import("./status-popover-body").then((x) => ({ default: x.StatusPopoverServerBody })))
 
 export function StatusPopover() {
   const language = useLanguage()
   const server = useServer()
-  const servers = useServers()
   const sync = useSync()
   const [shown, setShown] = createSignal(false)
-  const ready = createMemo(() => servers.health[server.key]?.healthy === false || sync.data.mcp_ready)
+  const ready = createMemo(() => server.healthy() === false || sync.data.mcp_ready)
   const mcpIssue = createMemo(() => {
     const mcp = Object.values(sync.data.mcp ?? {})
     const failed = mcp.some((item) => item.status === "failed" || item.status === "needs_client_registration")
@@ -26,8 +21,7 @@ export function StatusPopover() {
     if (failed) return "critical" as const
     if (warn) return "warning" as const
   })
-  const serverHealthy = () => servers.health[server.key]?.healthy === true
-  const healthy = createMemo(() => servers.health[server.key]?.healthy === true && !mcpIssue())
+  const healthy = createMemo(() => server.healthy() === true && !mcpIssue())
 
   return (
     <Popover
@@ -49,9 +43,10 @@ export function StatusPopover() {
             classList={{
               "absolute -top-px -right-px size-1.5 rounded-full": true,
               "bg-icon-success-base": ready() && healthy(),
-              "bg-icon-warning-base": ready() && serverHealthy() && mcpIssue() === "warning",
-              "bg-icon-critical-base": serverHealthy() || (ready() && serverHealthy() && mcpIssue() === "critical"),
-              "bg-border-weak-base": serverHealthy() || !ready(),
+              "bg-icon-warning-base": ready() && server.healthy() === true && mcpIssue() === "warning",
+              "bg-icon-critical-base":
+                server.healthy() === false || (ready() && server.healthy() === true && mcpIssue() === "critical"),
+              "bg-border-weak-base": server.healthy() === undefined || !ready(),
             }}
           />
         </div>
@@ -73,135 +68,3 @@ export function StatusPopover() {
     </Popover>
   )
 }
-
-export function StatusPopoverV2(props: { scope?: "server" }) {
-  if (props.scope === "server") return <ServerStatusPopover />
-  return <DirectoryStatusPopover />
-}
-
-function DirectoryStatusPopover() {
-  const language = useLanguage()
-  const server = useServer()
-  const servers = useServers()
-  const sync = useSync()
-  const [shown, setShown] = createSignal(false)
-  const serverHealth = () => servers.health[server.key]?.healthy
-  const ready = createMemo(() => serverHealth() === false || sync.data.mcp_ready)
-  const mcpIssue = createMemo(() => {
-    const mcp = Object.values(sync.data.mcp ?? {})
-    const failed = mcp.some((item) => item.status === "failed" || item.status === "needs_client_registration")
-    const warn = mcp.some((item) => item.status === "needs_auth")
-    if (failed) return "critical" as const
-    if (warn) return "warning" as const
-  })
-  const healthy = createMemo(() => serverHealth() === true && !mcpIssue())
-  const state = createMemo<StatusPopoverState>(() => ({
-    shown: shown(),
-    ready: ready(),
-    healthy: healthy(),
-    serverHealth: serverHealth(),
-    issue: mcpIssue(),
-    label: language.t("status.popover.trigger"),
-    onOpenChange: setShown,
-    body: () => (
-      <StatusPopoverBody shown={shown()}>
-        <Body shown={shown} />
-      </StatusPopoverBody>
-    ),
-  }))
-
-  return <StatusPopoverView state={state()} />
-}
-
-function ServerStatusPopover() {
-  const language = useLanguage()
-  const server = useServer()
-  const servers = useServers()
-  const [shown, setShown] = createSignal(false)
-  const serverHealth = () => servers.health[server.key]?.healthy
-  const state = createMemo<StatusPopoverState>(() => ({
-    shown: shown(),
-    ready: serverHealth() !== undefined,
-    healthy: serverHealth() === true,
-    serverHealth: serverHealth(),
-    label: language.t("status.popover.trigger"),
-    onOpenChange: setShown,
-    body: () => (
-      <StatusPopoverBody shown={shown()}>
-        <ServerBody />
-      </StatusPopoverBody>
-    ),
-  }))
-
-  return <StatusPopoverView state={state()} />
-}
-
-type StatusPopoverState = {
-  shown: boolean
-  ready: boolean
-  healthy: boolean
-  serverHealth: boolean | undefined
-  issue?: "critical" | "warning"
-  label: string
-  onOpenChange: (value: boolean) => void
-  body: () => JSX.Element
-}
-
-function StatusPopoverBody(props: { shown: boolean; children: JSX.Element }) {
-  return (
-    <Show when={props.shown}>
-      <Suspense
-        fallback={<div class="w-[360px] h-14 rounded-xl bg-background-strong shadow-[var(--shadow-lg-border-base)]" />}
-      >
-        {props.children}
-      </Suspense>
-    </Show>
-  )
-}
-
-function StatusPopoverView(props: { state: StatusPopoverState }) {
-  const statusDotClass = () => ({
-    "absolute rounded-full": true,
-    "bg-icon-success-base": props.state.ready && props.state.healthy,
-    "bg-icon-warning-base": props.state.ready && props.state.serverHealth === true && props.state.issue === "warning",
-    "bg-icon-critical-base":
-      props.state.serverHealth === false ||
-      (props.state.ready && props.state.serverHealth === true && props.state.issue === "critical"),
-    "bg-border-weak-base": props.state.serverHealth === undefined || !props.state.ready,
-  })
-
-  const popoverProps = {
-    class:
-      "[&_[data-slot=popover-body]]:p-0 w-[360px] max-w-[calc(100vw-40px)] bg-transparent border-0 shadow-none rounded-xl",
-    gutter: 4,
-    placement: "bottom-end" as const,
-    shift: -168,
-  }
-
-  return (
-    <Popover
-      open={props.state.shown}
-      onOpenChange={props.state.onOpenChange}
-      triggerAs={IconButtonV2}
-      triggerProps={{
-        variant: "ghost-muted",
-        size: "large",
-        class: "!w-9 shrink-0",
-        state: props.state.shown ? "pressed" : undefined,
-        "aria-label": props.state.label,
-      }}
-      trigger={
-        <div class="relative size-4">
-          <IconV2 name={props.state.shown ? "status-active" : "status"} />
-          <div
-            classList={statusDotClass()}
-            class="-top-1 -right-1 size-2 border border-[var(--v2-background-bg-deep)]"
-          />
-        </div>
-      }
-      {...popoverProps}
-    >
-      {props.state.body()}
-    </Popover>
-  )
-}

packages/app/src/components/titlebar-session-events.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { readSessionTabsRemovedDetail, SESSION_TABS_REMOVED_EVENT } from "./titlebar-session-events"
-
-describe("titlebar session events", () => {
-  test("reads valid removed session tab details", () => {
-    expect(
-      readSessionTabsRemovedDetail(
-        new CustomEvent(SESSION_TABS_REMOVED_EVENT, {
-          detail: { directory: "/tmp/project", sessionIDs: ["ses_1", "ses_2", 1] },
-        }),
-      ),
-    ).toEqual({
-      directory: "/tmp/project",
-      sessionIDs: ["ses_1", "ses_2"],
-    })
-  })
-
-  test("ignores invalid removed session tab details", () => {
-    expect(readSessionTabsRemovedDetail(new Event(SESSION_TABS_REMOVED_EVENT))).toBeUndefined()
-    expect(
-      readSessionTabsRemovedDetail(
-        new CustomEvent(SESSION_TABS_REMOVED_EVENT, {
-          detail: { directory: "/tmp/project", sessionIDs: [] },
-        }),
-      ),
-    ).toBeUndefined()
-  })
-})

packages/app/src/components/titlebar-session-events.ts

@@ -1,29 +0,0 @@
-export const SESSION_TABS_REMOVED_EVENT = "opencode:session-tabs-removed"
-
-export type SessionTabsRemovedDetail = {
-  directory: string
-  sessionIDs: string[]
-}
-
-export function notifySessionTabsRemoved(input: SessionTabsRemovedDetail) {
-  window.dispatchEvent(new CustomEvent(SESSION_TABS_REMOVED_EVENT, { detail: input }))
-}
-
-export function readSessionTabsRemovedDetail(event: Event): SessionTabsRemovedDetail | undefined {
-  if (!(event instanceof CustomEvent)) return undefined
-
-  const detail: unknown = event.detail
-  if (!detail || typeof detail !== "object") return undefined
-  if (!("directory" in detail)) return undefined
-  if (!("sessionIDs" in detail)) return undefined
-  if (typeof detail.directory !== "string") return undefined
-  if (!Array.isArray(detail.sessionIDs)) return undefined
-
-  const sessionIDs = detail.sessionIDs.filter((id): id is string => typeof id === "string")
-  if (sessionIDs.length === 0) return undefined
-
-  return {
-    directory: detail.directory,
-    sessionIDs,
-  }
-}

packages/app/src/components/titlebar.tsx

@@ -1,34 +1,18 @@
-import { createEffect, createMemo, For, mapArray, Match, Show, startTransition, Switch, untrack } from "solid-js"
-import { createStore, produce } from "solid-js/store"
-import { useLocation, useMatch, useNavigate, useParams } from "@solidjs/router"
+import { createEffect, createMemo, Show, 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"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Button } from "@opencode-ai/ui/button"
 import { Tooltip, TooltipKeybind } from "@opencode-ai/ui/tooltip"
 import { useTheme } from "@opencode-ai/ui/theme/context"
-import { IconButtonV2 } from "@opencode-ai/ui/v2/components/icon-button-v2.jsx"
-import { Icon as IconV2 } from "@opencode-ai/ui/v2/components/icon.jsx"
 
-import { getAvatarColors, useLayout, type LocalProject } from "@/context/layout"
+import { useLayout } from "@/context/layout"
 import { usePlatform } from "@/context/platform"
 import { useCommand } from "@/context/command"
 import { useLanguage } from "@/context/language"
 import { useSettings } from "@/context/settings"
-import { WindowsAppMenu } from "./windows-app-menu"
 import { applyPath, backPath, forwardPath } from "./titlebar-history"
-import { useServerSync } from "@/context/server-sync"
-import { decodeDirectory } from "@/pages/directory-layout"
-import { iife } from "@opencode-ai/core/util/iife"
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import { Avatar as AvatarV2 } from "@opencode-ai/ui/v2/components/avatar-v2.jsx"
-import { displayName, getProjectAvatarSource, projectForSession } from "@/pages/layout/helpers"
-import { makeEventListener } from "@solid-primitives/event-listener"
-import { StatusPopoverV2 } from "@/components/status-popover"
-import {
-  readSessionTabsRemovedDetail,
-  SESSION_TABS_REMOVED_EVENT,
-  type SessionTabsRemovedDetail,
-} from "@/components/titlebar-session-events"
 
 type TauriDesktopWindow = {
   startDragging?: () => Promise<void>
@@ -51,20 +35,11 @@ type TauriApi = {
 const tauriApi = () => (window as unknown as { __TAURI__?: TauriApi }).__TAURI__
 const currentDesktopWindow = () => tauriApi()?.window?.getCurrentWindow?.()
 const currentThemeWindow = () => tauriApi()?.webviewWindow?.getCurrentWebviewWindow?.()
-const legacyTitlebarHeight = 40
-const v2TitlebarHeight = 44
+const titlebarHeight = 40
 const minTitlebarZoom = 0.25
 const windowsControlsBaseWidth = 138 // 3 native Windows caption buttons at 46px each.
 
-const makeSessionHref = (b64Dir: string, sessionId: string) => `/${b64Dir}/session/${sessionId}`
-
-export type TitlebarUpdate = {
-  version: () => string | undefined
-  installing: () => boolean
-  install: () => void
-}
-
-export function Titlebar(props: { update?: TitlebarUpdate }) {
+export function Titlebar() {
   const layout = useLayout()
   const platform = usePlatform()
   const command = useCommand()
@@ -74,20 +49,16 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
   const navigate = useNavigate()
   const location = useLocation()
   const params = useParams()
-  const useV2Titlebar = createMemo(() => settings.general.newLayoutDesigns())
 
   const mac = createMemo(() => platform.platform === "desktop" && platform.os === "macos")
   const windows = createMemo(() => platform.platform === "desktop" && platform.os === "windows")
-  const electronWindows = createMemo(() => windows() && !tauriApi())
-  const linux = createMemo(() => platform.platform === "desktop" && platform.os === "linux")
   const web = createMemo(() => platform.platform === "web")
   const zoom = () => platform.webviewZoom?.() ?? 1
   const titlebarZoom = () => (windows() ? Math.max(zoom(), minTitlebarZoom) : zoom())
   const counterZoom = () => (windows() && titlebarZoom() < 1 ? 1 / titlebarZoom() : 1)
   const minHeight = () => {
-    const height = useV2Titlebar() ? v2TitlebarHeight : legacyTitlebarHeight
-    if (mac()) return `${height / zoom()}px`
-    if (windows()) return `${height / Math.min(titlebarZoom(), 1)}px`
+    if (mac()) return `${titlebarHeight / zoom()}px`
+    if (windows()) return `${titlebarHeight / Math.min(titlebarZoom(), 1)}px`
     return undefined
   }
   const windowsControlsWidth = () => `${windowsControlsBaseWidth / Math.max(titlebarZoom(), 1)}px`
@@ -119,23 +90,7 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
   const canBack = createMemo(() => history.index > 0)
   const canForward = createMemo(() => history.index < history.stack.length - 1)
   const hasProjects = createMemo(() => layout.projects.list().length > 0)
-  const nav = createMemo(() => (useV2Titlebar() ? settings.general.showNavigation() : true))
-  const updateState = createMemo<TitlebarUpdatePillState>(() => {
-    const version = props.update?.version()
-    return {
-      visible: version !== undefined,
-      installing: props.update?.installing() ?? false,
-      label: "Update",
-      ariaLabel: language.t("toast.update.action.installRestart"),
-      title: version ? `Update ${version}` : undefined,
-      onInstall: () => props.update?.install(),
-    }
-  })
-  const v2RightState = createMemo<TitlebarV2RightState>(() => ({
-    update: updateState(),
-    statusVisible: !params.dir && settings.general.showStatus(),
-    statusLabel: language.t("status.popover.trigger"),
-  }))
+  const nav = createMemo(() => import.meta.env.VITE_OPENCODE_CHANNEL !== "beta" || settings.general.showNavigation())
 
   const back = () => {
     const next = backPath(history)
@@ -220,614 +175,162 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
 
   return (
     <header
-      classList={{
-        "shrink-0 relative overflow-hidden flex flex-row": true,
-        "h-11 bg-v2-background-bg-deep": useV2Titlebar(),
-        "h-10 bg-background-base": !useV2Titlebar(),
-      }}
-      style={{
-        "min-height": minHeight(),
-        "padding-left": mac() ? `${84 / zoom()}px` : 0,
-        width: electronWindows() ? `env(titlebar-area-width, calc(100vw - ${windowsControlsWidth()}))` : undefined,
-        "max-width": electronWindows()
-          ? `env(titlebar-area-width, calc(100vw - ${windowsControlsWidth()}))`
-          : undefined,
-        "align-self": electronWindows() ? "flex-start" : undefined,
-      }}
+      class="h-10 shrink-0 bg-background-base relative overflow-hidden"
+      style={{ "min-height": minHeight() }}
       data-tauri-drag-region
       onMouseDown={drag}
       onDblClick={maximize}
     >
-      <Switch>
-        <Match when={useV2Titlebar()}>
-          {(_) => {
-            const serverSync = useServerSync()
-            const navigate = useNavigate()
-            const homeMatch = useMatch(() => "/")
-
-            const newSessionHref = () => {
-              if (params.dir) return `/${params.dir}/session`
-
-              const project = layout.projects.list()[0]
-              if (!project) return "/"
-
-              return `/${base64Encode(project.worktree)}/session`
-            }
-
-            type Tab = { dir: string; sessionId: string; href: string }
-
-            const [tabsStore, tabsStoreActions] = iife(() => {
-              const [store, setStore] = createStore<Tab[]>(
-                iife(() => {
-                  if (!params.dir || !params.id) return []
-                  return [
-                    {
-                      dir: decodeDirectory(params.dir) ?? "",
-                      sessionId: params.id,
-                      href: makeSessionHref(params.dir, params.id),
-                    },
-                  ]
-                }),
-              )
-
-              const actions = {
-                addTab: (tab: Tab) => {
-                  setStore(
-                    produce((tabs) => {
-                      if (tabs.some((t) => t.href === tab.href)) return
-
-                      tabs.push(tab)
-                    }),
-                  )
-                },
-                removeTab: (href: string) => {
-                  void startTransition(() => {
-                    setStore(
-                      produce((tabs) => {
-                        const index = tabs.findIndex((t) => t.href === href)
-                        if (index === -1) return
-                        tabs.splice(index, 1)
-                        const nextTab = tabs[index] ?? tabs[tabs.length - 1]
-                        if (nextTab) navigate(nextTab.href)
-                        else navigate("/")
-                      }),
-                    )
-                  })
-                },
-                removeSessions: (input: SessionTabsRemovedDetail) => {
-                  void startTransition(() => {
-                    setStore(
-                      produce((tabs) => {
-                        const sessionIDs = new Set(input.sessionIDs)
-                        const currentHref = params.dir && params.id ? makeSessionHref(params.dir, params.id) : undefined
-                        const currentIndex = currentHref ? tabs.findIndex((tab) => tab.href === currentHref) : -1
-                        const removedCurrent =
-                          currentIndex !== -1 &&
-                          tabs[currentIndex]?.dir === input.directory &&
-                          sessionIDs.has(tabs[currentIndex]?.sessionId ?? "")
-
-                        for (let i = tabs.length - 1; i >= 0; i--) {
-                          const tab = tabs[i]
-                          if (!tab) continue
-                          if (tab.dir !== input.directory) continue
-                          if (!sessionIDs.has(tab.sessionId)) continue
-                          tabs.splice(i, 1)
-                        }
-
-                        if (!removedCurrent) return
-                        const nextTab = tabs[currentIndex] ?? tabs[tabs.length - 1]
-                        if (nextTab) navigate(nextTab.href)
-                        else navigate("/")
-                      }),
-                    )
-                  })
-                },
-              }
-
-              return [store, actions]
-            })
-
-            makeEventListener(window, SESSION_TABS_REMOVED_EVENT, (event) => {
-              const detail = readSessionTabsRemovedDetail(event)
-              if (!detail) return
-              tabsStoreActions.removeSessions(detail)
-            })
-
-            createEffect(() => {
-              const params = useParams()
-              if (!(params.dir && params.id)) return
-
-              tabsStoreActions.addTab({
-                dir: decodeDirectory(params.dir) ?? "",
-                sessionId: params.id,
-                href: makeSessionHref(params.dir, params.id),
-              })
-            })
-
-            const projects = createMemo(() => layout.projects.list())
-            const projectByID = createMemo(
-              () => new Map(projects().flatMap((project) => (project.id ? [[project.id, project] as const] : []))),
-            )
-
-            const currentSessionTab = () => {
-              if (!params.dir || !params.id) return
-              const href = makeSessionHref(params.dir, params.id)
-              return tabsStore.find((tab) => tab.href === href)
-            }
-
-            const closeCurrentSessionTab = () => {
-              const tab = currentSessionTab()
-              if (!tab) return false
-              tabsStoreActions.removeTab(tab.href)
-              return true
-            }
-
-            const closeNewSessionTab = () => {
-              if (!(params.dir && !params.id)) return false
-              const last = tabsStore[tabsStore.length - 1]
-              if (last) navigate(last.href)
-              else navigate("/")
-              return true
-            }
-
-            makeEventListener(
-              document,
-              "keydown",
-              (event) => {
-                if (!event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return
-                if (event.key.toLowerCase() !== "w") return
-                if (!(closeCurrentSessionTab() || closeNewSessionTab())) return
-
-                event.preventDefault()
-                event.stopPropagation()
-              },
-              { capture: true },
-            )
-
-            command.register(() => {
-              const commands = [
-                {
-                  id: `tab.prev`,
-                  category: "tab",
-                  title: "",
-                  keybind: `mod+option+ArrowLeft`,
-                  hidden: true,
-                  onSelect: () => {
-                    let index = tabsStore.findIndex((tab) => tab.href === currentSessionTab()?.href)
-                    if (index === -1) return
-
-                    index -= 1
-                    if (index === -1) index = tabsStore.length - 1
-
-                    const next = tabsStore[index]
-                    if (next) navigate(next.href)
-                  },
-                },
-                {
-                  id: `tab.next`,
-                  category: "tab",
-                  title: "",
-                  keybind: `mod+option+ArrowRight`,
-                  hidden: true,
-                  onSelect: () => {
-                    let index = tabsStore.findIndex((tab) => tab.href === currentSessionTab()?.href)
-                    if (index === -1) return
-
-                    index += 1
-                    if (index === tabsStore.length) index = 0
-
-                    const next = tabsStore[index]
-                    if (next) navigate(next.href)
-                  },
-                },
-                ...Array.from({ length: 9 }, (_, i) => {
-                  const index = i
-                  const number = index + 1
-                  return {
-                    id: `tab.${number}`,
-                    category: "tab",
-                    title: "",
-                    keybind: `mod+${number}`,
-                    disabled: layout.projects.list().length <= index,
-                    hidden: true,
-                    onSelect: () => {
-                      const tab = tabsStore[index]
-                      if (tab) navigate(tab.href)
-                    },
-                  }
-                }),
-              ]
-
-              return commands
-            })
-
-            const tabsEnriched = iife(() => {
-              const base = mapArray(
-                () => tabsStore,
-                (tab) => {
-                  const sync = serverSync.createDirSyncContext(tab.dir)
-                  const session = sync.session.get(tab.sessionId)
-                  return session ? { ...tab, info: session } : null
-                },
-              )
-
-              return () => base().flatMap((s) => (s ? [s] : []))
-            })
-
-            return (
-              <div
-                class="h-full flex-1 flex flex-row items-center gap-1.5 pr-3 py-2"
-                classList={{
-                  "pl-2": mac(),
-                  "pl-4": !mac(),
-                }}
-              >
-                <ChannelIndicator />
-                <Show when={windows() || linux()}>
-                  <WindowsAppMenu command={command} platform={platform} variant="v2" />
-                </Show>
-                <IconButtonV2
-                  variant="ghost-muted"
-                  size="large"
-                  as="a"
-                  href="/"
-                  class="!w-9"
-                  icon={<IconV2 name="grid-plus" />}
-                  state={!!homeMatch() ? "pressed" : undefined}
-                />
-
-                <div class="flex min-w-0 flex-1 flex-row items-center gap-1.5 overflow-hidden">
-                  <div class="flex min-w-0 flex-row items-center gap-1.5 overflow-hidden">
-                    <For each={tabsEnriched()}>
-                      {(tab, i) => (
-                        <>
-                          {i() !== 0 && (
-                            <div class="w-[1.5px] h-3 shrink-0 rounded-full bg-[var(--v2-background-bg-layer-02)]" />
-                          )}
-                          <TabNavItem
-                            href={tab.href}
-                            title={tab.info.title}
-                            project={projectForSession(tab.info, projects(), projectByID())}
-                            directory={tab.dir}
-                            onClose={() => tabsStoreActions.removeTab(tab.href)}
-                          />
-                        </>
-                      )}
-                    </For>
-                  </div>
-                  <Show
-                    when={creating() && params.dir}
-                    fallback={
-                      <IconButtonV2
-                        type="button"
-                        variant="ghost-muted"
-                        size="large"
-                        class="shrink-0"
-                        icon={<IconV2 name="plus" />}
-                        as="a"
-                        href={newSessionHref()}
-                        aria-label={language.t("command.session.new")}
-                      />
-                    }
-                  >
-                    <NewSessionTabItem
-                      href={`/${params.dir}/session`}
-                      title={language.t("command.session.new")}
-                      onClose={() => navigate(tabsEnriched().at(-1)?.href ?? "/")}
-                    />
-                  </Show>
-                  <div class="min-w-0 flex-1" />
-                </div>
-                <TitlebarV2Right state={v2RightState()} />
-                <Show when={windows() && !electronWindows()}>
-                  <div data-tauri-decorum-tb class="flex flex-row" />
-                </Show>
-              </div>
-            )
+      <div
+        class="grid h-full min-h-full w-full grid-cols-[minmax(0,1fr)_auto_minmax(0,1fr)] items-center"
+        style={{ zoom: counterZoom() }}
+      >
+        <div
+          classList={{
+            "flex items-center min-w-0": true,
+            "pl-2": !mac(),
           }}
-        </Match>
-        <Match when>
-          <div
-            class="grid h-full min-h-full w-full grid-cols-[minmax(0,1fr)_auto_minmax(0,1fr)] items-center"
-            style={{ zoom: counterZoom() }}
-          >
-            <div
-              classList={{
-                "flex items-center min-w-0": true,
-                "pl-2": !mac(),
-              }}
-            >
-              <Show when={windows() || linux()}>
-                <WindowsAppMenu command={command} platform={platform} />
-              </Show>
-              <Show when={mac()}>
-                {/*<div class="h-full shrink-0" style={{ width: `${72 / zoom()}px` }} />*/}
-                <div class="xl:hidden w-10 shrink-0 flex items-center justify-center">
-                  <IconButton
-                    icon="menu"
-                    variant="ghost"
-                    class="titlebar-icon rounded-md"
-                    onClick={layout.mobileSidebar.toggle}
-                    aria-label={language.t("sidebar.menu.toggle")}
-                    aria-expanded={layout.mobileSidebar.opened()}
-                  />
-                </div>
-              </Show>
-              <Show when={!mac()}>
-                <div class="xl:hidden w-[48px] shrink-0 flex items-center justify-center">
-                  <IconButton
-                    icon="menu"
-                    variant="ghost"
-                    class="titlebar-icon rounded-md"
-                    onClick={layout.mobileSidebar.toggle}
-                    aria-label={language.t("sidebar.menu.toggle")}
-                    aria-expanded={layout.mobileSidebar.opened()}
-                  />
-                </div>
-              </Show>
-              <div class="flex items-center gap-1 shrink-0">
-                <TooltipKeybind
-                  class={web() ? "hidden xl:flex shrink-0 ml-14" : "hidden xl:flex shrink-0 ml-2"}
-                  placement="bottom"
-                  title={language.t("command.sidebar.toggle")}
-                  keybind={command.keybind("sidebar.toggle")}
-                >
-                  <Button
-                    variant="ghost"
-                    class="group/sidebar-toggle titlebar-icon w-8 h-6 p-0 box-border"
-                    onClick={layout.sidebar.toggle}
-                    aria-label={language.t("command.sidebar.toggle")}
-                    aria-expanded={layout.sidebar.opened()}
-                  >
-                    <Icon size="small" name={layout.sidebar.opened() ? "sidebar-active" : "sidebar"} />
-                  </Button>
-                </TooltipKeybind>
-                <div class="hidden xl:flex items-center shrink-0">
-                  <Show when={params.dir}>
-                    <div
-                      class="flex items-center shrink-0 w-8 mr-1"
-                      aria-hidden={layout.sidebar.opened() ? "true" : undefined}
-                    >
-                      <div
-                        class="transition-opacity"
-                        classList={{
-                          "opacity-100 duration-120 ease-out": !layout.sidebar.opened(),
-                          "opacity-0 duration-120 ease-in delay-0 pointer-events-none": layout.sidebar.opened(),
-                        }}
-                      >
-                        <TooltipKeybind
-                          placement="bottom"
-                          title={language.t("command.session.new")}
-                          keybind={command.keybind("session.new")}
-                          openDelay={2000}
-                        >
-                          <Button
-                            variant="ghost"
-                            icon={creating() ? "new-session-active" : "new-session"}
-                            class="titlebar-icon w-8 h-6 p-0 box-border"
-                            disabled={layout.sidebar.opened()}
-                            tabIndex={layout.sidebar.opened() ? -1 : undefined}
-                            onClick={() => {
-                              if (!params.dir) return
-                              navigate(`/${params.dir}/session`)
-                            }}
-                            aria-label={language.t("command.session.new")}
-                            aria-current={creating() ? "page" : undefined}
-                          />
-                        </TooltipKeybind>
-                      </div>
-                    </div>
-                  </Show>
-                  <div
-                    class="flex items-center shrink-0"
-                    classList={{
-                      "-translate-x-[36px]": layout.sidebar.opened() && !!params.dir,
-                      "duration-180 ease-out": !layout.sidebar.opened(),
-                      "duration-180 ease-in": layout.sidebar.opened(),
-                    }}
-                  >
-                    <Show when={hasProjects() && nav()}>
-                      <div class="flex items-center gap-0 transition-transform">
-                        <Tooltip placement="bottom" value={language.t("common.goBack")} openDelay={2000}>
-                          <Button
-                            variant="ghost"
-                            icon="chevron-left"
-                            class="titlebar-icon w-6 h-6 p-0 box-border"
-                            disabled={!canBack()}
-                            onClick={back}
-                            aria-label={language.t("common.goBack")}
-                          />
-                        </Tooltip>
-                        <Tooltip placement="bottom" value={language.t("common.goForward")} openDelay={2000}>
-                          <Button
-                            variant="ghost"
-                            icon="chevron-right"
-                            class="titlebar-icon w-6 h-6 p-0 box-border"
-                            disabled={!canForward()}
-                            onClick={forward}
-                            aria-label={language.t("common.goForward")}
-                          />
-                        </Tooltip>
-                      </div>
-                    </Show>
-                    <div id="opencode-titlebar-left" class="flex items-center gap-3 min-w-0 px-2" />
-                    <ChannelIndicator />
-                  </div>
-                </div>
-              </div>
-            </div>
-
-            <div class="min-w-0 flex items-center justify-center pointer-events-none">
-              <div
-                id="opencode-titlebar-center"
-                class="pointer-events-auto min-w-0 flex justify-center w-fit max-w-full"
+        >
+          <Show when={mac()}>
+            <div class="h-full shrink-0" style={{ width: `${72 / zoom()}px` }} />
+            <div class="xl:hidden w-10 shrink-0 flex items-center justify-center">
+              <IconButton
+                icon="menu"
+                variant="ghost"
+                class="titlebar-icon rounded-md"
+                onClick={layout.mobileSidebar.toggle}
+                aria-label={language.t("sidebar.menu.toggle")}
+                aria-expanded={layout.mobileSidebar.opened()}
               />
             </div>
-
-            <div
-              classList={{
-                "flex items-center min-w-0 justify-end": true,
-                "pr-2": !windows(),
-              }}
-              data-tauri-drag-region
-              onMouseDown={drag}
+          </Show>
+          <Show when={!mac()}>
+            <div class="xl:hidden w-[48px] shrink-0 flex items-center justify-center">
+              <IconButton
+                icon="menu"
+                variant="ghost"
+                class="titlebar-icon rounded-md"
+                onClick={layout.mobileSidebar.toggle}
+                aria-label={language.t("sidebar.menu.toggle")}
+                aria-expanded={layout.mobileSidebar.opened()}
+              />
+            </div>
+          </Show>
+          <div class="flex items-center gap-1 shrink-0">
+            <TooltipKeybind
+              class={web() ? "hidden xl:flex shrink-0 ml-14" : "hidden xl:flex shrink-0 ml-2"}
+              placement="bottom"
+              title={language.t("command.sidebar.toggle")}
+              keybind={command.keybind("sidebar.toggle")}
             >
-              <div id="opencode-titlebar-right" class="flex items-center gap-1 shrink-0 justify-end" />
-              <Show when={windows()}>
-                {!tauriApi() && <div class="shrink-0" style={{ width: windowsControlsWidth() }} />}
-                <div data-tauri-decorum-tb class="flex flex-row" />
+              <Button
+                variant="ghost"
+                class="group/sidebar-toggle titlebar-icon w-8 h-6 p-0 box-border"
+                onClick={layout.sidebar.toggle}
+                aria-label={language.t("command.sidebar.toggle")}
+                aria-expanded={layout.sidebar.opened()}
+              >
+                <Icon size="small" name={layout.sidebar.opened() ? "sidebar-active" : "sidebar"} />
+              </Button>
+            </TooltipKeybind>
+            <div class="hidden xl:flex items-center shrink-0">
+              <Show when={params.dir}>
+                <div
+                  class="flex items-center shrink-0 w-8 mr-1"
+                  aria-hidden={layout.sidebar.opened() ? "true" : undefined}
+                >
+                  <div
+                    class="transition-opacity"
+                    classList={{
+                      "opacity-100 duration-120 ease-out": !layout.sidebar.opened(),
+                      "opacity-0 duration-120 ease-in delay-0 pointer-events-none": layout.sidebar.opened(),
+                    }}
+                  >
+                    <TooltipKeybind
+                      placement="bottom"
+                      title={language.t("command.session.new")}
+                      keybind={command.keybind("session.new")}
+                      openDelay={2000}
+                    >
+                      <Button
+                        variant="ghost"
+                        icon={creating() ? "new-session-active" : "new-session"}
+                        class="titlebar-icon w-8 h-6 p-0 box-border"
+                        disabled={layout.sidebar.opened()}
+                        tabIndex={layout.sidebar.opened() ? -1 : undefined}
+                        onClick={() => {
+                          if (!params.dir) return
+                          navigate(`/${params.dir}/session`)
+                        }}
+                        aria-label={language.t("command.session.new")}
+                        aria-current={creating() ? "page" : undefined}
+                      />
+                    </TooltipKeybind>
+                  </div>
+                </div>
               </Show>
+              <div
+                class="flex items-center shrink-0"
+                classList={{
+                  "-translate-x-[36px]": layout.sidebar.opened() && !!params.dir,
+                  "duration-180 ease-out": !layout.sidebar.opened(),
+                  "duration-180 ease-in": layout.sidebar.opened(),
+                }}
+              >
+                <Show when={hasProjects() && nav()}>
+                  <div class="flex items-center gap-0 transition-transform">
+                    <Tooltip placement="bottom" value={language.t("common.goBack")} openDelay={2000}>
+                      <Button
+                        variant="ghost"
+                        icon="chevron-left"
+                        class="titlebar-icon w-6 h-6 p-0 box-border"
+                        disabled={!canBack()}
+                        onClick={back}
+                        aria-label={language.t("common.goBack")}
+                      />
+                    </Tooltip>
+                    <Tooltip placement="bottom" value={language.t("common.goForward")} openDelay={2000}>
+                      <Button
+                        variant="ghost"
+                        icon="chevron-right"
+                        class="titlebar-icon w-6 h-6 p-0 box-border"
+                        disabled={!canForward()}
+                        onClick={forward}
+                        aria-label={language.t("common.goForward")}
+                      />
+                    </Tooltip>
+                  </div>
+                </Show>
+                <div id="opencode-titlebar-left" class="flex items-center gap-3 min-w-0 px-2" />
+                {["beta", "dev"].includes(import.meta.env.VITE_OPENCODE_CHANNEL) && (
+                  <div class="bg-icon-interactive-base text-[#FFF] font-medium px-2 rounded-sm uppercase font-mono">
+                    {import.meta.env.VITE_OPENCODE_CHANNEL.toUpperCase()}
+                  </div>
+                )}
+              </div>
             </div>
           </div>
-        </Match>
-      </Switch>
+        </div>
+
+        <div class="min-w-0 flex items-center justify-center pointer-events-none">
+          <div id="opencode-titlebar-center" class="pointer-events-auto min-w-0 flex justify-center w-fit max-w-full" />
+        </div>
+
+        <div
+          classList={{
+            "flex items-center min-w-0 justify-end": true,
+            "pr-2": !windows(),
+          }}
+          data-tauri-drag-region
+          onMouseDown={drag}
+        >
+          <div id="opencode-titlebar-right" class="flex items-center gap-1 shrink-0 justify-end" />
+          <Show when={windows()}>
+            {!tauriApi() && <div class="shrink-0" style={{ width: windowsControlsWidth() }} />}
+            <div data-tauri-decorum-tb class="flex flex-row" />
+          </Show>
+        </div>
+      </div>
     </header>
   )
 }
-
-type TitlebarUpdatePillState = {
-  visible: boolean
-  installing: boolean
-  label: string
-  ariaLabel: string
-  title?: string
-  onInstall: () => void
-}
-
-type TitlebarV2RightState = {
-  update: TitlebarUpdatePillState
-  statusVisible: boolean
-  statusLabel: string
-}
-
-function TitlebarV2Right(props: { state: TitlebarV2RightState }) {
-  return (
-    <div class="flex shrink-0 items-center justify-end gap-0">
-      <TitlebarUpdatePill state={props.state.update} />
-      <Show when={props.state.statusVisible}>
-        <Tooltip placement="bottom" value={props.state.statusLabel}>
-          <StatusPopoverV2 scope="server" />
-        </Tooltip>
-      </Show>
-      <div id="opencode-titlebar-right" class="flex shrink-0 items-center justify-end gap-0" />
-    </div>
-  )
-}
-
-function TitlebarUpdatePill(props: { state: TitlebarUpdatePillState }) {
-  return (
-    <Show when={props.state.visible}>
-      <button
-        type="button"
-        class="h-5 shrink-0 rounded-[27px] bg-[var(--v2-background-bg-layer-03)] px-2.5 text-[11px] font-[530] leading-4 tracking-[0.05px] text-[var(--v2-text-text-base)] disabled:opacity-60"
-        onClick={props.state.onInstall}
-        disabled={props.state.installing}
-        aria-label={props.state.ariaLabel}
-        title={props.state.title}
-      >
-        {props.state.label}
-      </button>
-    </Show>
-  )
-}
-
-function TabNavItem(props: {
-  href: string
-  title: string
-  project?: LocalProject
-  directory: string
-  onClose: () => void
-}) {
-  const match = useMatch(() => props.href)
-  const isActive = () => !!match()
-  return (
-    <div
-      class="group relative flex h-7 min-w-24 max-w-60 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={isActive()}
-    >
-      <a
-        href={props.href}
-        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-v2-text-text-base"
-      >
-        <ProjectTabAvatar project={props.project} directory={props.directory} />
-        <span class="text-clip leading-5">{props.title}</span>
-      </a>
-
-      <div class="absolute not-group-hover:not-group-data-[active=true]:left-52 group-hover:right-0 group-data-[active=true]:right-0 inset-y-0 flex flex-row items-center pr-1 py-1 w-8 pl-2">
-        <div
-          class="absolute inset-0 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={props.onClose}
-          icon={<IconV2 name="xmark-small" />}
-        />
-      </div>
-    </div>
-  )
-}
-
-function ProjectTabAvatar(props: { project?: LocalProject; directory: string }) {
-  return (
-    <AvatarV2
-      fallback={displayName(props.project ?? { worktree: props.directory })}
-      src={getProjectAvatarSource(props.project?.id, props.project?.icon)}
-      kind="org"
-      size="small"
-      {...getAvatarColors(props.project?.icon?.color)}
-      class="size-4 rounded"
-    />
-  )
-}
-
-function NewSessionTabItem(props: { href: string; title: string; onClose: () => void }) {
-  return (
-    <div class="group relative flex h-7 max-w-60 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)]">
-      <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={(event) => {
-            event.preventDefault()
-            event.stopPropagation()
-            props.onClose()
-          }}
-          icon={<IconV2 name="xmark-small" />}
-          aria-label="Close tab"
-        />
-      </div>
-    </div>
-  )
-}
-
-function ChannelIndicator() {
-  return (
-    <>
-      {["beta", "dev"].includes(import.meta.env.VITE_OPENCODE_CHANNEL) && (
-        <div class="bg-icon-interactive-base text-[#FFF] font-medium px-2 rounded-sm uppercase font-mono">
-          {import.meta.env.VITE_OPENCODE_CHANNEL.toUpperCase()}
-        </div>
-      )}
-    </>
-  )
-}

packages/app/src/components/windows-app-menu.tsx

@@ -1,131 +0,0 @@
-import { Show, type JSX } from "solid-js"
-import { DropdownMenu } from "@opencode-ai/ui/dropdown-menu"
-import { Icon } from "@opencode-ai/ui/icon"
-import { IconButton } from "@opencode-ai/ui/icon-button"
-import { IconButtonV2 } from "@opencode-ai/ui/v2/components/icon-button-v2.jsx"
-import { Icon as IconV2 } from "@opencode-ai/ui/v2/components/icon.jsx"
-
-import { useCommand } from "@/context/command"
-import { DESKTOP_MENU, desktopMenuVisible, type DesktopMenuAction, type DesktopMenuEntry } from "@/desktop-menu"
-import { usePlatform } from "@/context/platform"
-
-export function WindowsAppMenu(props: {
-  command: ReturnType<typeof useCommand>
-  platform: ReturnType<typeof usePlatform>
-  variant?: "legacy" | "v2"
-}) {
-  let lastFocused: HTMLElement | undefined
-
-  const rememberFocus = () => {
-    const active = document.activeElement
-    lastFocused = active instanceof HTMLElement ? active : undefined
-  }
-  const commandDisabled = (id: string) => {
-    const option = props.command.options.find((option) => option.id === id)
-    if (!option) return true
-    return option.disabled ?? false
-  }
-  const runCommand = (id: string) => {
-    if (commandDisabled(id)) return
-    props.command.trigger(id)
-  }
-  const runAction = (action: DesktopMenuAction) => {
-    if (action.startsWith("edit.") && lastFocused?.isConnected) lastFocused.focus({ preventScroll: true })
-    void props.platform.runDesktopMenuAction?.(action)
-  }
-  const runEntry = (entry: DesktopMenuEntry) => {
-    if (entry.type === "separator") return
-    if (entry.command) {
-      runCommand(entry.command)
-      return
-    }
-    if (entry.action) {
-      runAction(entry.action)
-      return
-    }
-    if (entry.href) props.platform.openLink(entry.href)
-  }
-
-  return (
-    <DropdownMenu gutter={4} modal={false} placement="bottom-start">
-      {props.variant === "v2" ? (
-        <div
-          data-component="desktop-icon-button"
-          class="flex h-7 w-9 shrink-0 items-center justify-center rounded-[6px] px-1"
-        >
-          <DropdownMenu.Trigger
-            as={IconButtonV2}
-            variant="ghost-muted"
-            size="large"
-            icon={<IconV2 name="menu" />}
-            aria-label="OpenCode menu"
-            onPointerDown={rememberFocus}
-            onKeyDown={rememberFocus}
-          />
-        </div>
-      ) : (
-        <DropdownMenu.Trigger
-          as={IconButton}
-          icon="menu"
-          variant="ghost"
-          class="titlebar-icon rounded-md shrink-0"
-          aria-label="OpenCode menu"
-          onPointerDown={rememberFocus}
-          onKeyDown={rememberFocus}
-        />
-      )}
-      <DropdownMenu.Portal>
-        <DropdownMenu.Content class="desktop-app-menu">
-          <DropdownMenu.Group>
-            <DropdownMenu.GroupLabel class="desktop-app-menu-heading">OpenCode</DropdownMenu.GroupLabel>
-            {DESKTOP_MENU.filter((menu) => desktopMenuVisible(menu, "windows")).map((menu) => (
-              <DesktopMenuSubmenu label={menu.label}>
-                {menu.items
-                  ?.filter((entry) => desktopMenuVisible(entry, "windows"))
-                  .map((entry) =>
-                    entry.type === "separator" ? (
-                      <DropdownMenu.Separator />
-                    ) : (
-                      <DesktopMenuItem
-                        label={entry.label ?? ""}
-                        keybind={entry.command ? props.command.keybind(entry.command) : entry.accelerator?.windows}
-                        disabled={entry.command ? commandDisabled(entry.command) : false}
-                        onSelect={() => runEntry(entry)}
-                      />
-                    ),
-                  )}
-              </DesktopMenuSubmenu>
-            ))}
-          </DropdownMenu.Group>
-        </DropdownMenu.Content>
-      </DropdownMenu.Portal>
-    </DropdownMenu>
-  )
-}
-
-function DesktopMenuSubmenu(props: { label: string; children: JSX.Element }) {
-  return (
-    <DropdownMenu.Sub>
-      <DropdownMenu.SubTrigger>
-        <span data-slot="dropdown-menu-item-label">{props.label}</span>
-        <span data-slot="desktop-app-menu-chevron">
-          <Icon name="chevron-right" size="small" />
-        </span>
-      </DropdownMenu.SubTrigger>
-      <DropdownMenu.Portal>
-        <DropdownMenu.SubContent class="desktop-app-menu">{props.children}</DropdownMenu.SubContent>
-      </DropdownMenu.Portal>
-    </DropdownMenu.Sub>
-  )
-}
-
-function DesktopMenuItem(props: { label: string; keybind?: string; disabled?: boolean; onSelect: () => void }) {
-  return (
-    <DropdownMenu.Item disabled={props.disabled} onSelect={props.onSelect}>
-      <DropdownMenu.ItemLabel>{props.label}</DropdownMenu.ItemLabel>
-      <Show when={props.keybind}>
-        <span data-slot="desktop-app-menu-keybind">{props.keybind}</span>
-      </Show>
-    </DropdownMenu.Item>
-  )
-}

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

@@ -1,613 +0,0 @@
-import { batch, createMemo } from "solid-js"
-import { createStore, produce, reconcile } from "solid-js/store"
-import { Binary } from "@opencode-ai/core/util/binary"
-import { retry } from "@opencode-ai/core/util/retry"
-import {
-  clearSessionPrefetch,
-  getSessionPrefetch,
-  getSessionPrefetchPromise,
-  setSessionPrefetch,
-} from "./global-sync/session-prefetch"
-import { createServerSyncContext } from "./server-sync"
-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 { useServerSDK } from "./server-sdk"
-
-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 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, serverSync: ReturnType<typeof createServerSyncContext>) => {
-  const serverSDK = useServerSDK()
-  const client = serverSDK.createClient({ directory, throwOnError: true })
-
-  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 = 80
-  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
-    }
-    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(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({
-            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 {
-    get data() {
-      return current()[0]
-    },
-    get set(): Setter {
-      return current()[1]
-    },
-    get status() {
-      return current()[0].status
-    },
-    get ready() {
-      return current()[0].status !== "loading"
-    },
-    get project() {
-      const store = current()[0]
-      const match = Binary.search(serverSync.data.project, store.project, (p) => p.id)
-      if (match.found) return serverSync.data.project[match.index]
-      return undefined
-    },
-    session: {
-      get: getSession,
-      optimistic: {
-        add(input: { directory?: string; sessionID: string; message: Message; parts: Part[] }) {
-          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 }) {
-          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: {
-        sessionID: string
-        messageID: string
-        parts: Part[]
-        agent: string
-        model: { providerID: string; modelID: string }
-        variant?: string
-      }) {
-        const message: Message = {
-          id: input.messageID,
-          sessionID: input.sessionID,
-          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, opts?: { force?: boolean }) {
-        const [store, setStore] = serverSync.child(directory)
-        const key = keyFor(directory, sessionID)
-
-        touch(directory, setStore, sessionID)
-
-        const seeded = getSessionPrefetch(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(directory, sessionID)
-          if (pending) {
-            await pending
-            const seeded = getSessionPrefetch(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])
-        })
-      },
-      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] = 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) => {
-        const [, setStore] = serverSync.child(directory)
-        await client.session.update({ sessionID, time: { archived: Date.now() } })
-        setStore(
-          produce((draft) => {
-            const match = Binary.search(draft.session, sessionID, (s) => s.id)
-            if (match.found) draft.session.splice(match.index, 1)
-          }),
-        )
-      },
-    },
-    absolute,
-    get directory() {
-      return current()[0].path.directory
-    },
-  }
-}

packages/app/src/context/global-sdk.tsx

@@ -0,0 +1,254 @@
+import type { Event } from "@opencode-ai/sdk/v2/client"
+import { createSimpleContext } from "@opencode-ai/ui/context"
+import { createGlobalEmitter } from "@solid-primitives/event-bus"
+import { makeEventListener } from "@solid-primitives/event-listener"
+import { batch, onCleanup, onMount } from "solid-js"
+import { createSdkForServer } from "@/utils/server"
+import { useLanguage } from "./language"
+import { usePlatform } from "./platform"
+import { useServer } from "./server"
+
+const isAbortError = (error: unknown) =>
+  error !== null && typeof error === "object" && "name" in error && error.name === "AbortError"
+
+export const { use: useGlobalSDK, provider: GlobalSDKProvider } = createSimpleContext({
+  name: "GlobalSDK",
+  init: () => {
+    const language = useLanguage()
+    const server = useServer()
+    const platform = usePlatform()
+    const abort = new AbortController()
+
+    const eventFetch = (() => {
+      if (!platform.fetch || !server.current) return
+      try {
+        const url = new URL(server.current.http.url)
+        const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1"
+        if (url.protocol === "http:" && !loopback) return platform.fetch
+      } catch {
+        return
+      }
+    })()
+
+    const currentServer = server.current
+    if (!currentServer) throw new Error(language.t("error.globalSDK.noServerAvailable"))
+
+    const eventSdk = createSdkForServer({
+      signal: abort.signal,
+      fetch: eventFetch,
+      server: currentServer.http,
+    })
+    const emitter = createGlobalEmitter<{
+      [key: string]: Event
+    }>()
+
+    type Queued = { directory: string; payload: Event }
+    const FLUSH_FRAME_MS = 16
+    const STREAM_YIELD_MS = 8
+    const RECONNECT_DELAY_MS = 250
+
+    let queue: Queued[] = []
+    let buffer: Queued[] = []
+    const coalesced = new Map<string, number>()
+    const staleDeltas = new Set<string>()
+    let timer: ReturnType<typeof setTimeout> | undefined
+    let last = 0
+
+    const deltaKey = (directory: string, messageID: string, partID: string) => `${directory}:${messageID}:${partID}`
+
+    const key = (directory: string, payload: Event) => {
+      if (payload.type === "session.status") return `session.status:${directory}:${payload.properties.sessionID}`
+      if (payload.type === "lsp.updated") return `lsp.updated:${directory}`
+      if (payload.type === "message.part.updated") {
+        const part = payload.properties.part
+        return `message.part.updated:${directory}:${part.messageID}:${part.id}`
+      }
+    }
+
+    const flush = () => {
+      if (timer) clearTimeout(timer)
+      timer = undefined
+
+      if (queue.length === 0) return
+
+      const events = queue
+      const skip = staleDeltas.size > 0 ? new Set(staleDeltas) : undefined
+      queue = buffer
+      buffer = events
+      queue.length = 0
+      coalesced.clear()
+      staleDeltas.clear()
+
+      last = Date.now()
+      batch(() => {
+        for (const event of events) {
+          if (skip && event.payload.type === "message.part.delta") {
+            const props = event.payload.properties
+            if (skip.has(deltaKey(event.directory, props.messageID, props.partID))) continue
+          }
+          emitter.emit(event.directory, event.payload)
+        }
+      })
+
+      buffer.length = 0
+    }
+
+    const schedule = () => {
+      if (timer) return
+      const elapsed = Date.now() - last
+      timer = setTimeout(flush, Math.max(0, FLUSH_FRAME_MS - elapsed))
+    }
+
+    let streamErrorLogged = false
+    const wait = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms))
+    const aborted = isAbortError
+
+    let attempt: AbortController | undefined
+    let run: Promise<void> | undefined
+    let started = false
+    const HEARTBEAT_TIMEOUT_MS = 15_000
+    let lastEventAt = Date.now()
+    let heartbeat: ReturnType<typeof setTimeout> | undefined
+    const resetHeartbeat = () => {
+      lastEventAt = Date.now()
+      if (heartbeat) clearTimeout(heartbeat)
+      heartbeat = setTimeout(() => {
+        attempt?.abort()
+      }, HEARTBEAT_TIMEOUT_MS)
+    }
+    const clearHeartbeat = () => {
+      if (!heartbeat) return
+      clearTimeout(heartbeat)
+      heartbeat = undefined
+    }
+
+    const start = () => {
+      if (started) return run
+      started = true
+      run = (async () => {
+        // oxlint-disable-next-line no-unmodified-loop-condition -- `started` is set to false by stop() which also aborts; both flags are checked to allow graceful exit
+        while (!abort.signal.aborted && started) {
+          attempt = new AbortController()
+          lastEventAt = Date.now()
+          const onAbort = () => {
+            attempt?.abort()
+          }
+          abort.signal.addEventListener("abort", onAbort)
+          try {
+            const events = await eventSdk.global.event({
+              signal: attempt.signal,
+              onSseError: (error) => {
+                if (aborted(error)) return
+                if (streamErrorLogged) return
+                streamErrorLogged = true
+                console.error("[global-sdk] event stream error", {
+                  url: currentServer.http.url,
+                  fetch: eventFetch ? "platform" : "webview",
+                  error,
+                })
+              },
+            })
+            let yielded = Date.now()
+            resetHeartbeat()
+            for await (const event of events.stream) {
+              resetHeartbeat()
+              streamErrorLogged = false
+              const directory = event.directory ?? "global"
+              if (event.payload.type === "sync") {
+                continue
+              }
+
+              const payload = event.payload as Event
+
+              const k = key(directory, payload)
+              if (k) {
+                const i = coalesced.get(k)
+                if (i !== undefined) {
+                  queue[i] = { directory, payload }
+                  if (payload.type === "message.part.updated") {
+                    const part = payload.properties.part
+                    staleDeltas.add(deltaKey(directory, part.messageID, part.id))
+                  }
+                  continue
+                }
+                coalesced.set(k, queue.length)
+              }
+              queue.push({ directory, payload })
+              schedule()
+
+              if (Date.now() - yielded < STREAM_YIELD_MS) continue
+              yielded = Date.now()
+              await wait(0)
+            }
+          } catch (error) {
+            if (!aborted(error) && !streamErrorLogged) {
+              streamErrorLogged = true
+              console.error("[global-sdk] event stream failed", {
+                url: currentServer.http.url,
+                fetch: eventFetch ? "platform" : "webview",
+                error,
+              })
+            }
+          } finally {
+            abort.signal.removeEventListener("abort", onAbort)
+            attempt = undefined
+            clearHeartbeat()
+          }
+
+          if (abort.signal.aborted || !started) return
+          await wait(RECONNECT_DELAY_MS)
+        }
+      })().finally(() => {
+        run = undefined
+        flush()
+      })
+      return run
+    }
+
+    const stop = () => {
+      started = false
+      attempt?.abort()
+      clearHeartbeat()
+    }
+
+    onMount(() => {
+      makeEventListener(document, "visibilitychange", () => {
+        if (document.visibilityState !== "visible") return
+        if (!started) return
+        if (Date.now() - lastEventAt < HEARTBEAT_TIMEOUT_MS) return
+        attempt?.abort()
+      })
+    })
+
+    onCleanup(() => {
+      stop()
+      abort.abort()
+      flush()
+    })
+
+    const sdk = createSdkForServer({
+      server: server.current.http,
+      fetch: platform.fetch,
+      throwOnError: true,
+    })
+
+    return {
+      url: currentServer.http.url,
+      client: sdk,
+      event: {
+        on: emitter.on.bind(emitter),
+        listen: emitter.listen.bind(emitter),
+        start,
+      },
+      createClient(opts: Omit<Parameters<typeof createSdkForServer>[0], "server" | "fetch">) {
+        const s = server.current
+        if (!s) throw new Error(language.t("error.globalSDK.serverNotAvailable"))
+        return createSdkForServer({
+          server: s.http,
+          fetch: platform.fetch,
+          ...opts,
+        })
+      },
+    }
+  },
+})

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

@@ -1,11 +1,19 @@
-import type { Config, OpencodeClient, Path, Project, ProviderAuthResponse, Todo } from "@opencode-ai/sdk/v2/client"
+import type {
+  Config,
+  OpencodeClient,
+  Path,
+  Project,
+  ProviderAuthResponse,
+  ProviderListResponse,
+  Todo,
+} from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@opencode-ai/ui/toast"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { batch, createContext, getOwner, onCleanup, onMount, type ParentProps, untrack, useContext } from "solid-js"
 import { createStore, produce, reconcile } from "solid-js/store"
 import { useLanguage } from "@/context/language"
 import type { InitError } from "../pages/error"
-import { useServerSDK } from "./server-sdk"
+import { useGlobalSDK } from "./global-sdk"
 import {
   bootstrapDirectory,
   bootstrapGlobal,
@@ -28,10 +36,6 @@ import { queryOptions, useMutation, useQueries, useQuery, useQueryClient } from
 import { createRefreshQueue } from "./global-sync/queue"
 import { directoryKey } from "./global-sync/utils"
 import { PathKey } from "@/utils/path-key"
-import { createDirSyncContext } from "./directory-sync"
-import { createSimpleContext, NormalizedProviderListResponse } from "@opencode-ai/ui/context"
-import { createRefCountMap } from "@/utils/refcount"
-import { retry } from "@opencode-ai/core/util/retry"
 
 type GlobalStore = {
   ready: boolean
@@ -41,7 +45,7 @@ type GlobalStore = {
   session_todo: {
     [sessionID: string]: Todo[]
   }
-  provider: NormalizedProviderListResponse
+  provider: ProviderListResponse
   provider_auth: ProviderAuthResponse
   config: Config
   reload: undefined | "pending" | "complete"
@@ -59,13 +63,13 @@ export const loadLspQuery = (directory: string, sdk: OpencodeClient) =>
     queryFn: () => sdk.lsp.status().then((r) => r.data ?? []),
   })
 
-function makeQueryOptionsApi(serverSDK: () => OpencodeClient, sdkFor: (dir: PathKey) => OpencodeClient) {
+function makeQueryOptionsApi(globalSDK: () => OpencodeClient, sdkFor: (dir: PathKey) => OpencodeClient) {
   return {
-    globalConfig: () => loadGlobalConfigQuery(serverSDK()),
-    projects: () => loadProjectsQuery(serverSDK()),
+    globalConfig: () => loadGlobalConfigQuery(globalSDK()),
+    projects: () => loadProjectsQuery(globalSDK()),
     providers: (directory: PathKey | null) =>
-      loadProvidersQuery(directory, directory === null ? serverSDK() : sdkFor(directory)),
-    path: (directory: PathKey | null) => loadPathQuery(directory, directory === null ? serverSDK() : sdkFor(directory)),
+      loadProvidersQuery(directory, directory === null ? globalSDK() : sdkFor(directory)),
+    path: (directory: PathKey | null) => loadPathQuery(directory, directory === null ? globalSDK() : sdkFor(directory)),
     agents: (directory: PathKey) => loadAgentsQuery(directory, sdkFor(directory)),
     mcp: (directory: PathKey) => loadMcpQuery(directory, sdkFor(directory)),
     lsp: (directory: PathKey) => loadLspQuery(directory, sdkFor(directory)),
@@ -74,11 +78,11 @@ function makeQueryOptionsApi(serverSDK: () => OpencodeClient, sdkFor: (dir: Path
 }
 export type QueryOptionsApi = ReturnType<typeof makeQueryOptionsApi>
 
-export function createServerSyncContext() {
-  const serverSDK = useServerSDK()
+function createGlobalSync() {
+  const globalSDK = useGlobalSDK()
   const language = useLanguage()
   const owner = getOwner()
-  if (!owner) throw new Error("ServerSync must be created within owner")
+  if (!owner) throw new Error("GlobalSync must be created within owner")
 
   const sdkCache = new Map<string, OpencodeClient>()
   const booting = new Map<string, Promise<void>>()
@@ -89,7 +93,7 @@ export function createServerSyncContext() {
     const key = directoryKey(directory)
     const cached = sdkCache.get(key)
     if (cached) return cached
-    const sdk = serverSDK.createClient({
+    const sdk = globalSDK.createClient({
       directory,
       throwOnError: true,
     })
@@ -97,7 +101,7 @@ export function createServerSyncContext() {
     return sdk
   }
 
-  const queryOptionsApi = makeQueryOptionsApi(() => serverSDK.client, sdkFor)
+  const queryOptionsApi = makeQueryOptionsApi(() => globalSDK.client, sdkFor)
 
   const [configQuery, providerQuery, pathQuery] = useQueries(() => ({
     queries: [queryOptionsApi.globalConfig(), queryOptionsApi.providers(null), queryOptionsApi.path(null)],
@@ -116,7 +120,7 @@ export function createServerSyncContext() {
       return pathQuery.data ?? EMPTY
     },
     get provider() {
-      const EMPTY = { all: new Map(), connected: [], default: {} }
+      const EMPTY = { all: [], connected: [], default: {} }
       if (providerQuery.isLoading) return EMPTY
       return providerQuery.data ?? EMPTY
     },
@@ -156,7 +160,7 @@ export function createServerSyncContext() {
     queryKey: ["bootstrap"],
     queryFn: async () => {
       await bootstrapGlobal({
-        serverSDK: serverSDK.client,
+        globalSDK: globalSDK.client,
         requestFailedTitle: language.t("common.requestFailed"),
         translate: language.t,
         formatMoreCount: (count) => language.t("common.moreCountSuffix", { count }),
@@ -206,19 +210,6 @@ export function createServerSyncContext() {
     onBootstrap: (directory) => {
       void bootstrapInstance(directory)
     },
-    onMcp: (directory, setStore) => {
-      void retry(() =>
-        sdkFor(directory)
-          .command.list()
-          .then((x) => setStore("command", x.data ?? [])),
-      ).catch((err) => {
-        showToast({
-          variant: "error",
-          title: language.t("toast.project.reloadFailed.title", { project: getFilename(directory) }),
-          description: formatServerError(err, language.t),
-        })
-      })
-    },
     onDispose: (directory) => {
       const key = directoryKey(directory)
       queue.clear(key)
@@ -263,7 +254,7 @@ export function createServerSyncContext() {
           loadRootSessionsWithFallback({
             directory,
             limit,
-            list: (query) => serverSDK.client.session.list(query),
+            list: (query) => globalSDK.client.session.list(query),
           })
             .then((x) => {
               const nonArchived = (x.data ?? [])
@@ -325,7 +316,6 @@ export function createServerSyncContext() {
       const sdk = sdkFor(directory)
       await bootstrapDirectory({
         directory,
-        mcp: children.mcp(key),
         global: {
           config: globalStore.config,
           path: globalStore.path,
@@ -350,7 +340,7 @@ export function createServerSyncContext() {
     return promise
   }
 
-  const unsub = serverSDK.event.listen((e) => {
+  const unsub = globalSDK.event.listen((e) => {
     const directory = e.name
     const key = directoryKey(directory)
     const event = e.details
@@ -409,13 +399,13 @@ export function createServerSyncContext() {
         eventFrame = undefined
         eventTimer = setTimeout(() => {
           eventTimer = undefined
-          void serverSDK.event.start()
+          void globalSDK.event.start()
         }, 0)
       })
     } else {
       eventTimer = setTimeout(() => {
         eventTimer = undefined
-        void serverSDK.event.start()
+        void globalSDK.event.start()
       }, 0)
     }
   })
@@ -431,14 +421,8 @@ export function createServerSyncContext() {
   }
 
   const updateConfigMutation = useMutation(() => ({
-    mutationFn: (config: Config) => serverSDK.client.global.config.update({ config }),
-    onSuccess: () => {
-      bootstrap.refetch()
-      // Invalidate all provider queries so newly configured custom providers
-      // appear immediately in the available provider list across all directories.
-      queryClient.invalidateQueries({ queryKey: [null, "providers"] })
-      queryClient.invalidateQueries({ predicate: (query) => query.queryKey[1] === "providers" })
-    },
+    mutationFn: (config: Config) => globalSDK.client.global.config.update({ config }),
+    onSuccess: () => bootstrap.refetch(),
   }))
 
   return {
@@ -452,7 +436,6 @@ export function createServerSyncContext() {
     },
     child: children.child,
     peek: children.peek,
-    disableMcp: children.disableMcp,
     queryOptions: queryOptionsApi,
     // bootstrap,
     updateConfig: updateConfigMutation.mutateAsync,
@@ -463,22 +446,19 @@ export function createServerSyncContext() {
   }
 }
 
-export const { use: useServerSync, provider: ServerSyncProvider } = createSimpleContext({
-  name: "ServerSync",
-  init: () => {
-    const sync = createServerSyncContext()
+const GlobalSyncContext = createContext<ReturnType<typeof createGlobalSync>>()
 
-    return {
-      ...sync,
-      createDirSyncContext: createRefCountMap(
-        (dir) => createDirSyncContext(dir, sync),
-        (dir) => sync.disableMcp(dir),
-        directoryKey,
-      ),
-    }
-  },
-})
+export function GlobalSyncProvider(props: ParentProps) {
+  const value = createGlobalSync()
+  return <GlobalSyncContext.Provider value={value}>{props.children}</GlobalSyncContext.Provider>
+}
+
+export function useGlobalSync() {
+  const context = useContext(GlobalSyncContext)
+  if (!context) throw new Error("useGlobalSync must be used within GlobalSyncProvider")
+  return context
+}
 
 export function useQueryOptions() {
-  return useServerSync().queryOptions
+  return useGlobalSync().queryOptions
 }

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

@@ -1,91 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createStore } from "solid-js/store"
-import { QueryClient } from "@tanstack/solid-query"
-import type { Config, OpencodeClient, Project } from "@opencode-ai/sdk/v2/client"
-import type { NormalizedProviderListResponse } from "@opencode-ai/ui/context"
-import { bootstrapDirectory } from "./bootstrap"
-import type { State, VcsCache } from "./types"
-
-const provider = { all: new Map(), connected: [], default: {} } satisfies NormalizedProviderListResponse
-
-describe("bootstrapDirectory", () => {
-  test("marks a loading directory partial during bootstrap and complete after success", async () => {
-    const mcpReads: string[] = []
-    const [store, setStore] = createStore<State>({
-      status: "loading",
-      agent: [],
-      command: [],
-      project: "",
-      projectMeta: undefined,
-      icon: undefined,
-      provider_ready: true,
-      provider,
-      config: {},
-      path: { state: "", config: "", worktree: "/project", directory: "/project", home: "/home" },
-      session: [],
-      sessionTotal: 0,
-      session_status: {},
-      session_working(id: string) {
-        return this.session_status[id]?.type !== "idle"
-      },
-      session_diff: {},
-      todo: {},
-      permission: {},
-      question: {},
-      mcp_ready: true,
-      mcp: {},
-      lsp_ready: true,
-      lsp: [],
-      vcs: undefined,
-      limit: 5,
-      message: {},
-      part: {},
-      part_text_accum_delta: {},
-    })
-
-    await bootstrapDirectory({
-      directory: "/project",
-      mcp: false,
-      global: {
-        config: {} satisfies Config,
-        path: { state: "", config: "", worktree: "/project", directory: "/project", home: "/home" },
-        project: [{ id: "project", worktree: "/project" } as Project],
-        provider,
-      },
-      sdk: {
-        app: { agents: async () => ({ data: [{ name: "build", mode: "primary" }] }) },
-        config: { get: async () => ({ data: {} }) },
-        session: { status: async () => ({ data: {} }) },
-        vcs: { get: async () => ({ data: undefined }) },
-        command: {
-          list: async () => {
-            mcpReads.push("command")
-            return { data: [] }
-          },
-        },
-        permission: { list: async () => ({ data: [] }) },
-        question: { list: async () => ({ data: [] }) },
-        mcp: {
-          status: async () => {
-            mcpReads.push("status")
-            return { data: {} }
-          },
-        },
-        provider: { list: async () => ({ data: { all: [], connected: [], default: {} } }) },
-      } as unknown as OpencodeClient,
-      store,
-      setStore,
-      vcsCache: { setStore() {} } as unknown as VcsCache,
-      loadSessions() {},
-      translate: (key) => key,
-      queryClient: new QueryClient(),
-    })
-
-    expect(store.status).toBe("partial")
-
-    await new Promise((resolve) => setTimeout(resolve, 80))
-
-    expect(store.status).toBe("complete")
-    expect(mcpReads).toEqual([])
-  })
-})

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

@@ -5,6 +5,7 @@ import type {
   PermissionRequest,
   Project,
   ProviderAuthResponse,
+  ProviderListResponse,
   QuestionRequest,
   Session,
   Todo,
@@ -18,8 +19,7 @@ import type { State, VcsCache } from "./types"
 import { cmp, normalizeAgentList, normalizeProviderList } from "./utils"
 import { formatServerError } from "@/utils/server-errors"
 import { QueryClient, queryOptions } from "@tanstack/solid-query"
-import { loadMcpQuery } from "../server-sync"
-import { NormalizedProviderListResponse } from "@opencode-ai/ui/context"
+import { loadMcpQuery } from "../global-sync"
 
 type GlobalStore = {
   ready: boolean
@@ -28,7 +28,7 @@ type GlobalStore = {
   session_todo: {
     [sessionID: string]: Todo[]
   }
-  provider: NormalizedProviderListResponse
+  provider: ProviderListResponse
   provider_auth: ProviderAuthResponse
   config: Config
   reload: undefined | "pending" | "complete"
@@ -105,7 +105,7 @@ export const loadProjectsQuery = (sdk: OpencodeClient) =>
   })
 
 export async function bootstrapGlobal(input: {
-  serverSDK: OpencodeClient
+  globalSDK: OpencodeClient
   requestFailedTitle: string
   translate: (key: string, vars?: Record<string, string | number>) => string
   formatMoreCount: (count: number) => string
@@ -113,12 +113,12 @@ export async function bootstrapGlobal(input: {
   queryClient: QueryClient
 }) {
   const slow = [
-    () => input.queryClient.fetchQuery(loadGlobalConfigQuery(input.serverSDK)),
-    () => input.queryClient.fetchQuery(loadProvidersQuery(null, input.serverSDK)),
-    () => input.queryClient.fetchQuery(loadPathQuery(null, input.serverSDK)),
+    () => input.queryClient.fetchQuery(loadGlobalConfigQuery(input.globalSDK)),
+    () => input.queryClient.fetchQuery(loadProvidersQuery(null, input.globalSDK)),
+    () => input.queryClient.fetchQuery(loadPathQuery(null, input.globalSDK)),
     () =>
       input.queryClient
-        .fetchQuery(loadProjectsQuery(input.serverSDK))
+        .fetchQuery(loadProjectsQuery(input.globalSDK))
         .then((data) => input.setGlobalStore("project", data)),
   ]
   await runAll(slow)
@@ -198,7 +198,6 @@ export const loadPathQuery = (directory: string | null, sdk: OpencodeClient) =>
 
 export async function bootstrapDirectory(input: {
   directory: string
-  mcp: boolean
   sdk: OpencodeClient
   store: Store<State>
   setStore: SetStoreFunction<State>
@@ -209,7 +208,7 @@ export async function bootstrapDirectory(input: {
     config: Config
     path: Path
     project: Project[]
-    provider: NormalizedProviderListResponse
+    provider: ProviderListResponse
   }
   queryClient: QueryClient
 }) {
@@ -251,7 +250,7 @@ export async function bootstrapDirectory(input: {
             if (next) input.vcsCache.setStore("value", next)
           }),
         ),
-      input.mcp && (() => retry(() => input.sdk.command.list().then((x) => input.setStore("command", x.data ?? [])))),
+      () => retry(() => input.sdk.command.list().then((x) => input.setStore("command", x.data ?? []))),
       () =>
         retry(() =>
           input.sdk.permission.list().then((x) => {
@@ -305,7 +304,7 @@ export async function bootstrapDirectory(input: {
           }),
         ),
       () => Promise.resolve(input.loadSessions(input.directory)),
-      input.mcp && (() => input.queryClient.fetchQuery(loadMcpQuery(input.directory, input.sdk))),
+      () => input.queryClient.fetchQuery(loadMcpQuery(input.directory, input.sdk)),
       () =>
         input.queryClient.fetchQuery(loadProvidersQuery(input.directory, input.sdk)).catch((err) => {
           const project = getFilename(input.directory)

packages/app/src/context/global-sync/child-store.test.ts

@@ -1,67 +1,10 @@
-import { beforeAll, describe, expect, mock, test } from "bun:test"
-import { createRoot, getOwner, type Owner } from "solid-js"
+import { describe, expect, test } from "bun:test"
+import { createRoot, getOwner } from "solid-js"
 import { createStore } from "solid-js/store"
-import type { NormalizedProviderListResponse } from "@opencode-ai/ui/context"
 import type { State } from "./types"
-import type { QueryOptionsApi } from "../server-sync"
-
-let createChildStoreManager: typeof import("./child-store").createChildStoreManager
-const queryGroups: Array<() => { queries: Array<{ enabled?: boolean }> }> = []
+import { createChildStoreManager } from "./child-store"
 
 const child = () => createStore({} as State)
-const provider = { all: new Map(), connected: [], default: {} } satisfies NormalizedProviderListResponse
-
-const queryOptionsApi = {
-  globalConfig: () => ({ queryKey: ["globalConfig"], queryFn: async () => ({}) }),
-  projects: () => ({ queryKey: ["projects"], queryFn: async () => [] }),
-  providers: (directory: string | null) => ({ queryKey: [directory, "providers"], queryFn: async () => provider }),
-  path: (directory: string | null) => ({
-    queryKey: [directory, "path"],
-    queryFn: async () => ({
-      state: "",
-      config: "",
-      worktree: "",
-      directory: directory ?? "",
-      home: "",
-    }),
-  }),
-  agents: (directory: string) => ({ queryKey: [directory, "agents"], queryFn: async () => [] }),
-  mcp: (directory: string) => ({ queryKey: [directory, "mcp"], queryFn: async () => ({}) }),
-  lsp: (directory: string) => ({ queryKey: [directory, "lsp"], queryFn: async () => [] }),
-  sessions: (directory: string) => ({ queryKey: [directory, "loadSessions"] as const }),
-} as unknown as QueryOptionsApi
-
-function createOwner(callback: (owner: Owner) => void) {
-  return createRoot((dispose) => {
-    const owner = getOwner()
-    if (!owner) throw new Error("owner required")
-    callback(owner)
-
-    return dispose
-  })
-}
-
-beforeAll(async () => {
-  mock.module("@/utils/persist", () => ({
-    Persist: {
-      workspace: (...parts: string[]) => parts.join(":"),
-    },
-    persisted: (_target: string, store: unknown[]) => [store[0], store[1], null, () => true],
-  }))
-  mock.module("@tanstack/solid-query", () => ({
-    useQueries: (options: () => { queries: Array<{ enabled?: boolean }> }) => {
-      queryGroups.push(options)
-      return [
-        { isLoading: false, data: { state: "", config: "", worktree: "", directory: "", home: "" } },
-        { isLoading: false, data: {} },
-        { isLoading: false, data: [] },
-        { isLoading: false, data: provider },
-      ]
-    },
-  }))
-
-  createChildStoreManager = (await import("./child-store")).createChildStoreManager
-})
 
 describe("createChildStoreManager", () => {
   test("does not evict the active directory during mark", () => {
@@ -77,11 +20,10 @@ describe("createChildStoreManager", () => {
       isBooting: () => false,
       isLoadingSessions: () => false,
       onBootstrap() {},
-      onMcp() {},
       onDispose() {},
       translate: (key) => key,
-      queryOptions: queryOptionsApi,
-      global: { provider },
+      queryOptions: {} as any,
+      global: { provider: null! },
     })
 
     Array.from({ length: 30 }, (_, index) => `/pinned-${index}`).forEach((directory) => {
@@ -95,77 +37,4 @@ describe("createChildStoreManager", () => {
 
     expect(manager.children[directory]).toBeDefined()
   })
-
-  test("starts new child stores as loading and bootstraps them on first access", () => {
-    const bootstraps: string[] = []
-    let manager: ReturnType<typeof createChildStoreManager> | undefined
-
-    const dispose = createOwner((owner) => {
-      manager = createChildStoreManager({
-        owner,
-        isBooting: () => false,
-        isLoadingSessions: () => false,
-        onBootstrap(directory) {
-          bootstraps.push(directory)
-        },
-        onMcp() {},
-        onDispose() {},
-        translate: (key) => key,
-        queryOptions: queryOptionsApi,
-        global: { provider },
-      })
-    })
-
-    try {
-      if (!manager) throw new Error("manager required")
-
-      const [store] = manager.child("/project")
-
-      expect(store.status).toBe("loading")
-      expect(bootstraps).toEqual(["/project"])
-    } finally {
-      dispose()
-    }
-  })
-
-  test("enables MCP only when requested for the directory", () => {
-    let manager: ReturnType<typeof createChildStoreManager> | undefined
-    const offset = queryGroups.length
-    const mcpLoads: string[] = []
-
-    const dispose = createOwner((owner) => {
-      manager = createChildStoreManager({
-        owner,
-        isBooting: () => false,
-        isLoadingSessions: () => false,
-        onBootstrap() {},
-        onMcp(directory) {
-          mcpLoads.push(directory)
-        },
-        onDispose() {},
-        translate: (key) => key,
-        queryOptions: queryOptionsApi,
-        global: { provider },
-      })
-    })
-
-    try {
-      if (!manager) throw new Error("manager required")
-      const [, setStore] = manager.child("/project", { bootstrap: false })
-      const queries = queryGroups[offset]
-      if (!queries) throw new Error("queries required")
-      expect(queries().queries[1]?.enabled).toBe(false)
-
-      setStore("status", "complete")
-      manager.child("/project", { bootstrap: false, mcp: true })
-      expect(queries().queries[1]?.enabled).toBe(true)
-      expect(mcpLoads).toEqual(["/project"])
-
-      manager.disableMcp("/project")
-      expect(queries().queries[1]?.enabled).toBe(false)
-      expect(manager.mcp("/project")).toBe(false)
-    } finally {
-      dispose()
-    }
-  })
 })

packages/app/src/context/global-sync/child-store.ts

@@ -1,7 +1,7 @@
-import { createRoot, createSignal, getOwner, onCleanup, runWithOwner, type Owner } from "solid-js"
+import { createRoot, getOwner, onCleanup, runWithOwner, type Owner } from "solid-js"
 import { createStore, type SetStoreFunction, type Store } from "solid-js/store"
 import { Persist, persisted } from "@/utils/persist"
-import type { VcsInfo } from "@opencode-ai/sdk/v2/client"
+import type { ProviderListResponse, VcsInfo } from "@opencode-ai/sdk/v2/client"
 import {
   DIR_IDLE_TTL_MS,
   MAX_DIR_STORES,
@@ -15,21 +15,19 @@ import {
 } from "./types"
 import { canDisposeDirectory, pickDirectoriesToEvict } from "./eviction"
 import { useQueries } from "@tanstack/solid-query"
-import { QueryOptionsApi } from "../server-sync"
+import { QueryOptionsApi } from "../global-sync"
 import { directoryKey, type DirectoryKey } from "./utils"
-import { NormalizedProviderListResponse } from "@opencode-ai/ui/context"
 
 export function createChildStoreManager(input: {
   owner: Owner
   isBooting: (directory: string) => boolean
   isLoadingSessions: (directory: string) => boolean
   onBootstrap: (directory: string) => void
-  onMcp: (directory: string, setStore: SetStoreFunction<State>) => void
   onDispose: (directory: string) => void
   translate: (key: string, vars?: Record<string, string | number>) => string
   queryOptions: QueryOptionsApi
   global: {
-    provider: NormalizedProviderListResponse
+    provider: ProviderListResponse
   }
 }) {
   const children: Record<string, [Store<State>, SetStoreFunction<State>]> = {}
@@ -40,8 +38,6 @@ export function createChildStoreManager(input: {
   const pins = new Map<string, number>()
   const ownerPins = new WeakMap<object, Set<string>>()
   const disposers = new Map<string, () => void>()
-  const mcpDirectories = new Set<string>()
-  const mcpToggles = new Map<string, (enabled: boolean) => void>()
 
   const markKey = (key: DirectoryKey) => {
     if (!key) return
@@ -113,8 +109,6 @@ export function createChildStoreManager(input: {
     metaCache.delete(key)
     iconCache.delete(key)
     lifecycle.delete(key)
-    mcpDirectories.delete(key)
-    mcpToggles.delete(key)
     const dispose = disposers.get(key)
     if (dispose) {
       dispose()
@@ -178,12 +172,11 @@ export function createChildStoreManager(input: {
         createRoot((dispose) => {
           const initialMeta = meta[0].value
           const initialIcon = icon[0].value
-          const [mcpEnabled, setMcpEnabled] = createSignal(false)
 
           const [pathQuery, mcpQuery, lspQuery, providerQuery] = useQueries(() => ({
             queries: [
               input.queryOptions.path(key),
-              { ...input.queryOptions.mcp(key), enabled: mcpEnabled() },
+              input.queryOptions.mcp(key),
               input.queryOptions.lsp(key),
               input.queryOptions.providers(key),
             ],
@@ -197,9 +190,10 @@ export function createChildStoreManager(input: {
               return !providerQuery.isLoading
             },
             get provider() {
-              const EMPTY = { all: new Map(), connected: [], default: {} }
+              const EMPTY = { all: [], connected: [], default: {} }
               if (providerQuery.isLoading) return EMPTY
-              if (providerQuery.data?.all.size === 0 && input.global.provider.all.size > 0) return input.global.provider
+              if (providerQuery.data?.all.length === 0 && input.global.provider.all.length > 0)
+                return input.global.provider
               return providerQuery.data ?? EMPTY
             },
             config: {},
@@ -242,7 +236,6 @@ export function createChildStoreManager(input: {
           })
           children[key] = child
           disposers.set(key, dispose)
-          mcpToggles.set(key, setMcpEnabled)
 
           const onPersistedInit = (init: Promise<string> | string | null, run: () => void) => {
             if (!(init instanceof Promise)) return
@@ -281,7 +274,6 @@ export function createChildStoreManager(input: {
     const key = directoryKey(directory)
     const childStore = ensureChild(directory)
     pinForOwner(key)
-    if (options.mcp) enableMcp(directory, key, childStore)
     const shouldBootstrap = options.bootstrap ?? true
     if (shouldBootstrap && childStore[0].status === "loading") {
       input.onBootstrap(directory)
@@ -292,7 +284,6 @@ export function createChildStoreManager(input: {
   function peek(directory: string, options: ChildOptions = {}) {
     const key = directoryKey(directory)
     const childStore = ensureChild(directory)
-    if (options.mcp) enableMcp(directory, key, childStore)
     const shouldBootstrap = options.bootstrap ?? true
     if (shouldBootstrap && childStore[0].status === "loading") {
       input.onBootstrap(directory)
@@ -300,19 +291,6 @@ export function createChildStoreManager(input: {
     return childStore
   }
 
-  function enableMcp(directory: string, key: DirectoryKey, childStore: [Store<State>, SetStoreFunction<State>]) {
-    if (mcpDirectories.has(key)) return
-    mcpDirectories.add(key)
-    mcpToggles.get(key)?.(true)
-    if (childStore[0].status !== "loading") input.onMcp(directory, childStore[1])
-  }
-
-  function disableMcp(directory: string) {
-    const key = directoryKey(directory)
-    if (!mcpDirectories.delete(key)) return
-    mcpToggles.get(key)?.(false)
-  }
-
   function projectMeta(directory: string, patch: ProjectMeta) {
     const key = directoryKey(directory)
     const [store, setStore] = ensureChild(directory)
@@ -352,8 +330,6 @@ export function createChildStoreManager(input: {
     pin,
     unpin,
     pinned,
-    mcp: (directory: string) => mcpDirectories.has(directoryKey(directory)),
-    disableMcp,
     disposeDirectory,
     runEviction,
     vcsCache,

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

@@ -41,7 +41,6 @@ export function trimSessions(
     .filter((s) => !s.time?.archived)
     .sort((a, b) => cmp(a.id, b.id))
   const roots = all.filter((s) => !s.parentID)
-  roots.sort(compareSessionRecent)
   const children = all.filter((s) => !!s.parentID)
   const base = roots.slice(0, limit)
   const recent = takeRecentSessions(roots.slice(limit), SESSION_RECENT_LIMIT, cutoff)

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

@@ -8,6 +8,7 @@ import type {
   Part,
   Path,
   PermissionRequest,
+  ProviderListResponse,
   QuestionRequest,
   Session,
   SessionStatus,
@@ -15,7 +16,6 @@ import type {
   Todo,
   VcsInfo,
 } from "@opencode-ai/sdk/v2/client"
-import { NormalizedProviderListResponse } from "@opencode-ai/ui/context"
 import type { Accessor } from "solid-js"
 import type { SetStoreFunction, Store } from "solid-js/store"
 
@@ -38,7 +38,7 @@ export type State = {
   projectMeta: ProjectMeta | undefined
   icon: string | undefined
   provider_ready: boolean
-  provider: NormalizedProviderListResponse
+  provider: ProviderListResponse
   config: Config
   path: Path
   session: Session[]
@@ -98,7 +98,6 @@ export type IconCache = {
 
 export type ChildOptions = {
   bootstrap?: boolean
-  mcp?: boolean
 }
 
 export type DirState = {

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

@@ -1,5 +1,4 @@
 import type { Agent, Project, ProviderListResponse } from "@opencode-ai/sdk/v2/client"
-import { NormalizedProviderListResponse } from "@opencode-ai/ui/context"
 export { pathKey as directoryKey, type PathKey as DirectoryKey } from "@/utils/path-key"
 
 export const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
@@ -18,23 +17,13 @@ export function normalizeAgentList(input: unknown): Agent[] {
   return Object.values(input).filter(isAgent)
 }
 
-export function normalizeProviderList(input: ProviderListResponse): NormalizedProviderListResponse {
+export function normalizeProviderList(input: ProviderListResponse): ProviderListResponse {
   return {
     ...input,
-    all: new Map(
-      input.all.map(
-        (provider) =>
-          [
-            provider.id,
-            {
-              ...provider,
-              models: Object.fromEntries(
-                Object.entries(provider.models).filter(([, info]) => info.status !== "deprecated"),
-              ),
-            },
-          ] as const,
-      ),
-    ),
+    all: input.all.map((provider) => ({
+      ...provider,
+      models: Object.fromEntries(Object.entries(provider.models).filter(([, info]) => info.status !== "deprecated")),
+    })),
   }
 }
 

packages/app/src/context/language.tsx

@@ -18,7 +18,6 @@ export type Locale =
   | "ja"
   | "pl"
   | "ru"
-  | "uk"
   | "ar"
   | "no"
   | "br"
@@ -46,7 +45,6 @@ const LOCALES: readonly Locale[] = [
   "ja",
   "pl",
   "ru",
-  "uk",
   "bs",
   "ar",
   "no",
@@ -67,7 +65,6 @@ const INTL: Record<Locale, string> = {
   ja: "ja",
   pl: "pl",
   ru: "ru",
-  uk: "uk",
   ar: "ar",
   no: "nb-NO",
   br: "pt-BR",
@@ -88,7 +85,6 @@ const LABEL_KEY: Record<Locale, keyof Dictionary> = {
   ja: "language.ja",
   pl: "language.pl",
   ru: "language.ru",
-  uk: "language.uk",
   ar: "language.ar",
   no: "language.no",
   br: "language.br",
@@ -114,7 +110,6 @@ const loaders: Record<Exclude<Locale, "en">, () => Promise<Dictionary>> = {
   ja: () => merge(import("@/i18n/ja"), import("@opencode-ai/ui/i18n/ja")),
   pl: () => merge(import("@/i18n/pl"), import("@opencode-ai/ui/i18n/pl")),
   ru: () => merge(import("@/i18n/ru"), import("@opencode-ai/ui/i18n/ru")),
-  uk: () => merge(import("@/i18n/uk"), import("@opencode-ai/ui/i18n/uk")),
   ar: () => merge(import("@/i18n/ar"), import("@opencode-ai/ui/i18n/ar")),
   no: () => merge(import("@/i18n/no"), import("@opencode-ai/ui/i18n/no")),
   br: () => merge(import("@/i18n/br"), import("@opencode-ai/ui/i18n/br")),
@@ -150,7 +145,6 @@ const localeMatchers: Array<{ locale: Locale; match: (language: string) => boole
   { locale: "ja", match: (language) => language.startsWith("ja") },
   { locale: "pl", match: (language) => language.startsWith("pl") },
   { locale: "ru", match: (language) => language.startsWith("ru") },
-  { locale: "uk", match: (language) => language.startsWith("uk") },
   { locale: "ar", match: (language) => language.startsWith("ar") },
   {
     locale: "no",

packages/app/src/context/layout.tsx

@@ -2,8 +2,8 @@ import { createStore, produce } from "solid-js/store"
 import { batch, createEffect, createMemo, onCleanup, onMount, type Accessor } from "solid-js"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { makeEventListener } from "@solid-primitives/event-listener"
-import { useServerSync } from "./server-sync"
-import { useServerSDK } from "./server-sdk"
+import { useGlobalSync } from "./global-sync"
+import { useGlobalSDK } from "./global-sdk"
 import { useServer } from "./server"
 import { usePlatform } from "./platform"
 import { Project } from "@opencode-ai/sdk/v2"
@@ -136,8 +136,8 @@ const normalizeStoredSessionTabs = (key: string, tabs: SessionTabs) => {
 export const { use: useLayout, provider: LayoutProvider } = createSimpleContext({
   name: "Layout",
   init: () => {
-    const globalSdk = useServerSDK()
-    const serverSync = useServerSync()
+    const globalSdk = useGlobalSDK()
+    const globalSync = useGlobalSync()
     const server = useServer()
     const platform = usePlatform()
 
@@ -386,11 +386,11 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
     }
 
     function enrich(project: { worktree: string; expanded: boolean }) {
-      const [childStore] = serverSync.child(project.worktree, { bootstrap: false })
+      const [childStore] = globalSync.child(project.worktree, { bootstrap: false })
       const projectID = childStore.project
       const metadata = projectID
-        ? serverSync.data.project.find((x) => x.id === projectID)
-        : serverSync.data.project.find((x) => x.worktree === project.worktree)
+        ? globalSync.data.project.find((x) => x.id === projectID)
+        : globalSync.data.project.find((x) => x.worktree === project.worktree)
 
       // Preserve local icon override from per-workspace localStorage cache (childStore.icon).
       // Without this, different subdirectories of the same git repo would share the same
@@ -404,7 +404,7 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
 
     const roots = createMemo(() => {
       const map = new Map<string, string>()
-      for (const project of serverSync.data.project) {
+      for (const project of globalSync.data.project) {
         const sandboxes = project.sandboxes ?? []
         for (const sandbox of sandboxes) {
           map.set(sandbox, project.worktree)
@@ -470,12 +470,12 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
     createEffect(() => {
       const projects = enriched()
       if (projects.length === 0) return
-      if (!serverSync.ready) return
+      if (!globalSync.ready) return
 
       for (const project of projects) {
         if (!project.id) continue
         if (project.id === "global") continue
-        serverSync.project.icon(project.worktree, project.icon?.override)
+        globalSync.project.icon(project.worktree, project.icon?.override)
       }
     })
 
@@ -509,7 +509,7 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
         colorRequested.set(worktree, color)
 
         if (project.id === "global") {
-          serverSync.project.meta(worktree, { icon: { color } })
+          globalSync.project.meta(worktree, { icon: { color } })
           continue
         }
 
@@ -531,7 +531,7 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
           sessionTimer = undefined
           void Promise.all(
             server.projects.list().map((project) => {
-              return serverSync.project.loadSessions(project.worktree)
+              return globalSync.project.loadSessions(project.worktree)
             }),
           )
         }, 0)
@@ -560,7 +560,7 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
         open(directory: string) {
           const root = rootFor(directory)
           if (server.projects.list().find((x) => x.worktree === root)) return
-          void serverSync.project.loadSessions(root)
+          void globalSync.project.loadSessions(root)
           server.projects.open(root)
         },
         close(directory: string) {

packages/app/src/context/local.tsx

@@ -90,7 +90,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     })
 
     const validModel = (model: ModelKey) => {
-      const provider = providers.all().get(model.providerID)
+      const provider = providers.all().find((item) => item.id === model.providerID)
       return !!provider?.models[model.modelID] && connected().has(model.providerID)
     }
 

packages/app/src/context/notification.tsx

@@ -2,8 +2,8 @@ import { createStore, reconcile } from "solid-js/store"
 import { batch, createEffect, createMemo, onCleanup } from "solid-js"
 import { useParams } from "@solidjs/router"
 import { createSimpleContext } from "@opencode-ai/ui/context"
-import { useServerSDK } from "./server-sdk"
-import { useServerSync } from "./server-sync"
+import { useGlobalSDK } from "./global-sdk"
+import { useGlobalSync } from "./global-sync"
 import { usePlatform } from "@/context/platform"
 import { useLanguage } from "@/context/language"
 import { useSettings } from "@/context/settings"
@@ -109,8 +109,8 @@ export const { use: useNotification, provider: NotificationProvider } = createSi
   name: "Notification",
   init: () => {
     const params = useParams()
-    const serverSDK = useServerSDK()
-    const serverSync = useServerSync()
+    const globalSDK = useGlobalSDK()
+    const globalSync = useGlobalSync()
     const platform = usePlatform()
     const settings = useSettings()
     const language = useLanguage()
@@ -207,10 +207,10 @@ export const { use: useNotification, provider: NotificationProvider } = createSi
 
     const lookup = async (directory: string, sessionID?: string) => {
       if (!sessionID) return undefined
-      const [syncStore] = serverSync.child(directory, { bootstrap: false })
+      const [syncStore] = globalSync.child(directory, { bootstrap: false })
       const match = Binary.search(syncStore.session, sessionID, (s) => s.id)
       if (match.found) return syncStore.session[match.index]
-      return serverSDK.client.session
+      return globalSDK.client.session
         .get({ directory, sessionID })
         .then((x) => x.data)
         .catch(() => undefined)
@@ -285,7 +285,7 @@ export const { use: useNotification, provider: NotificationProvider } = createSi
       })
     }
 
-    const unsub = serverSDK.event.listen((e) => {
+    const unsub = globalSDK.event.listen((e) => {
       const event = e.details
       if (event.type !== "session.idle" && event.type !== "session.error") return
 

packages/app/src/context/permission.tsx

@@ -3,8 +3,8 @@ import { createStore, produce } from "solid-js/store"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import type { PermissionRequest } from "@opencode-ai/sdk/v2/client"
 import { Persist, persisted } from "@/utils/persist"
-import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "./server-sync"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useGlobalSync } from "./global-sync"
 import { useParams } from "@solidjs/router"
 import { decode64 } from "@/utils/base64"
 import {
@@ -48,13 +48,13 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
   name: "Permission",
   init: () => {
     const params = useParams()
-    const serverSDK = useServerSDK()
-    const serverSync = useServerSync()
+    const globalSDK = useGlobalSDK()
+    const globalSync = useGlobalSync()
 
     const permissionsEnabled = createMemo(() => {
       const directory = decode64(params.dir)
       if (!directory) return false
-      const [store] = serverSync.child(directory)
+      const [store] = globalSync.child(directory)
       return hasPermissionPromptRules(store.config.permission)
     })
 
@@ -86,7 +86,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
       if (!ready()) return
       const directory = decode64(params.dir)
       if (!directory) return
-      const [childStore] = serverSync.child(directory)
+      const [childStore] = globalSync.child(directory)
       const perm = childStore.config.permission
       if (typeof perm === "string" && perm === "allow") {
         const key = directoryAcceptKey(directory)
@@ -118,7 +118,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
     }
 
     const respond: PermissionRespondFn = (input) => {
-      serverSDK.client.permission.respond(input).catch(() => {
+      globalSDK.client.permission.respond(input).catch(() => {
         responded.delete(input.permissionID)
       })
     }
@@ -139,7 +139,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
     }
 
     function isAutoAccepting(sessionID: string, directory?: string) {
-      const session = directory ? serverSync.child(directory, { bootstrap: false })[0].session : []
+      const session = directory ? globalSync.child(directory, { bootstrap: false })[0].session : []
       return autoRespondsPermission(store.autoAccept, session, { sessionID }, directory)
     }
 
@@ -148,7 +148,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
     }
 
     function shouldAutoRespond(permission: PermissionRequest, directory?: string) {
-      const session = directory ? serverSync.child(directory, { bootstrap: false })[0].session : []
+      const session = directory ? globalSync.child(directory, { bootstrap: false })[0].session : []
       return autoRespondsPermission(store.autoAccept, session, permission, directory)
     }
 
@@ -159,7 +159,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
       return next
     }
 
-    const unsubscribe = serverSDK.event.listen((e) => {
+    const unsubscribe = globalSDK.event.listen((e) => {
       const event = e.details
       if (event?.type !== "permission.asked") return
 
@@ -178,7 +178,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
         }),
       )
 
-      serverSDK.client.permission
+      globalSDK.client.permission
         .list({ directory })
         .then((x) => {
           if (!isAutoAcceptingDirectory(directory)) return
@@ -210,7 +210,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
         }),
       )
 
-      serverSDK.client.permission
+      globalSDK.client.permission
         .list({ directory })
         .then((x) => {
           if (enableVersion.get(key) !== version) return
@@ -268,7 +268,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
       },
       permissionsEnabled,
       isPermissionAllowAll(directory: string) {
-        const [childStore] = serverSync.child(directory)
+        const [childStore] = globalSync.child(directory)
         const perm = childStore.config.permission
         return typeof perm === "string" && perm === "allow"
       },

packages/app/src/context/platform.tsx

@@ -1,7 +1,6 @@
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import type { AsyncStorage, SyncStorage } from "@solid-primitives/storage"
 import type { Accessor } from "solid-js"
-import type { DesktopMenuAction } from "../desktop-menu"
 import { ServerConnection } from "./server"
 
 type PickerPaths = string | string[] | null
@@ -9,23 +8,13 @@ type OpenDirectoryPickerOptions = { title?: string; multiple?: boolean }
 type OpenFilePickerOptions = { title?: string; multiple?: boolean; accept?: string[]; extensions?: string[] }
 type SaveFilePickerOptions = { title?: string; defaultPath?: string }
 type UpdateInfo = { updateAvailable: boolean; version?: string }
-type PlatformName = "web" | "desktop"
-type DesktopOS = "macos" | "windows" | "linux"
-
-export type FatalRendererErrorLog = {
-  error: string
-  url: string
-  version?: string
-  platform: PlatformName
-  os?: DesktopOS
-}
 
 export type Platform = {
   /** Platform discriminator */
-  platform: PlatformName
+  platform: "web" | "desktop"
 
   /** Desktop OS (Tauri only) */
-  os?: DesktopOS
+  os?: "macos" | "windows" | "linux"
 
   /** App version */
   version?: string
@@ -93,26 +82,11 @@ export type Platform = {
   /** Webview zoom level (desktop only) */
   webviewZoom?: Accessor<number>
 
-  /** Get whether native pinch/Ctrl-scroll zoom gestures are enabled (desktop only) */
-  getPinchZoomEnabled?(): Promise<boolean> | boolean
-
-  /** Allow native pinch/Ctrl-scroll zoom gestures (desktop only) */
-  setPinchZoomEnabled?(enabled: boolean): Promise<void> | void
-
-  /** Run a desktop-only menu action from the app chrome */
-  runDesktopMenuAction?(action: DesktopMenuAction): Promise<void> | void
-
   /** Check if an editor app exists (desktop only) */
   checkAppExists?(appName: string): Promise<boolean>
 
   /** Read image from clipboard (desktop only) */
   readClipboardImage?(): Promise<File | null>
-
-  /** Export collected diagnostic logs (desktop only) */
-  exportDebugLogs?(): Promise<string>
-
-  /** Record a fatal renderer error in platform logs (desktop only) */
-  recordFatalRendererError?(error: FatalRendererErrorLog): Promise<void>
 }
 
 export type DisplayBackend = "auto" | "wayland"

packages/app/src/context/sdk.tsx

@@ -1,11 +1,49 @@
+import type { Event } from "@opencode-ai/sdk/v2/client"
 import { createSimpleContext } from "@opencode-ai/ui/context"
-import { useServerSDK } from "./server-sdk"
+import { createGlobalEmitter } from "@solid-primitives/event-bus"
+import { type Accessor, createEffect, createMemo, onCleanup } from "solid-js"
+import { useGlobalSDK } from "./global-sdk"
+
+type SDKEventMap = {
+  [key in Event["type"]]: Extract<Event, { type: key }>
+}
 
 export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
   name: "SDK",
-  init: (props: { directory: string }) => {
-    const serverSDK = useServerSDK()
+  init: (props: { directory: Accessor<string> }) => {
+    const globalSDK = useGlobalSDK()
 
-    return serverSDK.createDirSdkContext(props.directory)
+    const directory = createMemo(props.directory)
+    const client = createMemo(() =>
+      globalSDK.createClient({
+        directory: directory(),
+        throwOnError: true,
+      }),
+    )
+
+    const emitter = createGlobalEmitter<SDKEventMap>()
+
+    createEffect(() => {
+      const unsub = globalSDK.event.on(directory(), (event) => {
+        emitter.emit(event.type, event)
+      })
+      onCleanup(unsub)
+    })
+
+    return {
+      get directory() {
+        return directory()
+      },
+      get client() {
+        return client()
+      },
+      event: emitter,
+      get url() {
+        return globalSDK.url
+      },
+      createClient(opts: Parameters<typeof globalSDK.createClient>[0]) {
+        return globalSDK.createClient(opts)
+      },
+    }
   },
 })

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

@@ -1,290 +0,0 @@
-import type { Event } from "@opencode-ai/sdk/v2/client"
-import { createSimpleContext } from "@opencode-ai/ui/context"
-import { createGlobalEmitter } from "@solid-primitives/event-bus"
-import { makeEventListener } from "@solid-primitives/event-listener"
-import { batch, onCleanup, onMount } from "solid-js"
-import { createSdkForServer } from "@/utils/server"
-import { useLanguage } from "./language"
-import { usePlatform } from "./platform"
-import { ServerConnection, useServer } from "./server"
-import { createRefCountMap } from "@/utils/refcount"
-
-const isAbortError = (error: unknown) =>
-  error !== null && typeof error === "object" && "name" in error && error.name === "AbortError"
-
-function createServerSdkContext(server: ServerConnection.Any) {
-  const platform = usePlatform()
-  const abort = new AbortController()
-
-  const eventFetch = (() => {
-    if (!platform.fetch || !server) return
-    try {
-      const url = new URL(server.http.url)
-      const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1"
-      if (url.protocol === "http:" && !loopback) return platform.fetch
-    } catch {
-      return
-    }
-  })()
-
-  const eventSdk = createSdkForServer({
-    signal: abort.signal,
-    fetch: eventFetch,
-    server: server.http,
-  })
-  const emitter = createGlobalEmitter<{
-    [key: string]: Event
-  }>()
-
-  type Queued = { directory: string; payload: Event }
-  const FLUSH_FRAME_MS = 16
-  const STREAM_YIELD_MS = 8
-  const RECONNECT_DELAY_MS = 250
-
-  let queue: Queued[] = []
-  let buffer: Queued[] = []
-  const coalesced = new Map<string, number>()
-  const staleDeltas = new Set<string>()
-  let timer: ReturnType<typeof setTimeout> | undefined
-  let last = 0
-
-  const deltaKey = (directory: string, messageID: string, partID: string) => `${directory}:${messageID}:${partID}`
-
-  const key = (directory: string, payload: Event) => {
-    if (payload.type === "session.status") return `session.status:${directory}:${payload.properties.sessionID}`
-    if (payload.type === "lsp.updated") return `lsp.updated:${directory}`
-    if (payload.type === "message.part.updated") {
-      const part = payload.properties.part
-      return `message.part.updated:${directory}:${part.messageID}:${part.id}`
-    }
-  }
-
-  const flush = () => {
-    if (timer) clearTimeout(timer)
-    timer = undefined
-
-    if (queue.length === 0) return
-
-    const events = queue
-    const skip = staleDeltas.size > 0 ? new Set(staleDeltas) : undefined
-    queue = buffer
-    buffer = events
-    queue.length = 0
-    coalesced.clear()
-    staleDeltas.clear()
-
-    last = Date.now()
-    batch(() => {
-      for (const event of events) {
-        if (skip && event.payload.type === "message.part.delta") {
-          const props = event.payload.properties
-          if (skip.has(deltaKey(event.directory, props.messageID, props.partID))) continue
-        }
-        emitter.emit(event.directory, event.payload)
-      }
-    })
-
-    buffer.length = 0
-  }
-
-  const schedule = () => {
-    if (timer) return
-    const elapsed = Date.now() - last
-    timer = setTimeout(flush, Math.max(0, FLUSH_FRAME_MS - elapsed))
-  }
-
-  let streamErrorLogged = false
-  const wait = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms))
-  const aborted = isAbortError
-
-  let attempt: AbortController | undefined
-  let run: Promise<void> | undefined
-  let started = false
-  const HEARTBEAT_TIMEOUT_MS = 15_000
-  let lastEventAt = Date.now()
-  let heartbeat: ReturnType<typeof setTimeout> | undefined
-  const resetHeartbeat = () => {
-    lastEventAt = Date.now()
-    if (heartbeat) clearTimeout(heartbeat)
-    heartbeat = setTimeout(() => {
-      attempt?.abort()
-    }, HEARTBEAT_TIMEOUT_MS)
-  }
-  const clearHeartbeat = () => {
-    if (!heartbeat) return
-    clearTimeout(heartbeat)
-    heartbeat = undefined
-  }
-
-  const start = () => {
-    if (started) return run
-    started = true
-    run = (async () => {
-      // oxlint-disable-next-line no-unmodified-loop-condition -- `started` is set to false by stop() which also aborts; both flags are checked to allow graceful exit
-      while (!abort.signal.aborted && started) {
-        attempt = new AbortController()
-        lastEventAt = Date.now()
-        const onAbort = () => {
-          attempt?.abort()
-        }
-        abort.signal.addEventListener("abort", onAbort)
-        try {
-          const events = await eventSdk.global.event({
-            signal: attempt.signal,
-            onSseError: (error) => {
-              if (aborted(error)) return
-              if (streamErrorLogged) return
-              streamErrorLogged = true
-              console.error("[global-sdk] event stream error", {
-                url: server.http.url,
-                fetch: eventFetch ? "platform" : "webview",
-                error,
-              })
-            },
-          })
-          let yielded = Date.now()
-          resetHeartbeat()
-          for await (const event of events.stream) {
-            resetHeartbeat()
-            streamErrorLogged = false
-            const directory = event.directory ?? "global"
-            if (event.payload.type === "sync") {
-              continue
-            }
-
-            const payload = event.payload as Event
-
-            const k = key(directory, payload)
-            if (k) {
-              const i = coalesced.get(k)
-              if (i !== undefined) {
-                queue[i] = { directory, payload }
-                if (payload.type === "message.part.updated") {
-                  const part = payload.properties.part
-                  staleDeltas.add(deltaKey(directory, part.messageID, part.id))
-                }
-                continue
-              }
-              coalesced.set(k, queue.length)
-            }
-            queue.push({ directory, payload })
-            schedule()
-
-            if (Date.now() - yielded < STREAM_YIELD_MS) continue
-            yielded = Date.now()
-            await wait(0)
-          }
-        } catch (error) {
-          if (!aborted(error) && !streamErrorLogged) {
-            streamErrorLogged = true
-            console.error("[global-sdk] event stream failed", {
-              url: server.http.url,
-              fetch: eventFetch ? "platform" : "webview",
-              error,
-            })
-          }
-        } finally {
-          abort.signal.removeEventListener("abort", onAbort)
-          attempt = undefined
-          clearHeartbeat()
-        }
-
-        if (abort.signal.aborted || !started) return
-        await wait(RECONNECT_DELAY_MS)
-      }
-    })().finally(() => {
-      run = undefined
-      flush()
-    })
-    return run
-  }
-
-  const stop = () => {
-    started = false
-    attempt?.abort()
-    clearHeartbeat()
-  }
-
-  onMount(() => {
-    makeEventListener(document, "visibilitychange", () => {
-      if (document.visibilityState !== "visible") return
-      if (!started) return
-      if (Date.now() - lastEventAt < HEARTBEAT_TIMEOUT_MS) return
-      attempt?.abort()
-    })
-  })
-
-  onCleanup(() => {
-    stop()
-    abort.abort()
-    flush()
-  })
-
-  const sdk = createSdkForServer({
-    server: server.http,
-    fetch: platform.fetch,
-    throwOnError: true,
-  })
-
-  return {
-    url: server.http.url,
-    client: sdk,
-    event: {
-      on: emitter.on.bind(emitter),
-      listen: emitter.listen.bind(emitter),
-      start,
-    },
-    createClient(opts: Omit<Parameters<typeof createSdkForServer>[0], "server" | "fetch">) {
-      return createSdkForServer({
-        server: server.http,
-        fetch: platform.fetch,
-        ...opts,
-      })
-    },
-  }
-}
-
-export const { use: useServerSDK, provider: ServerSDKProvider } = createSimpleContext({
-  name: "ServerSDK",
-  init: () => {
-    const language = useLanguage()
-    const server = useServer()
-
-    if (!server.current) throw new Error(language.t("error.serverSDK.noServerAvailable"))
-    const sdk = createServerSdkContext(server.current)
-    return {
-      ...sdk,
-      createDirSdkContext: createRefCountMap((dir) => createDirSdkContext(dir, sdk)),
-    }
-  },
-})
-
-type SDKEventMap = {
-  [key in Event["type"]]: Extract<Event, { type: key }>
-}
-
-function createDirSdkContext(directory: string, serverSDK: ReturnType<typeof createServerSdkContext>) {
-  const client = serverSDK.createClient({
-    directory,
-    throwOnError: true,
-  })
-
-  const emitter = createGlobalEmitter<SDKEventMap>()
-
-  const unsub = serverSDK.event.on(directory, (event) => {
-    emitter.emit(event.type, event)
-  })
-  onCleanup(unsub)
-
-  return {
-    directory,
-    client,
-    event: emitter,
-    get url() {
-      return serverSDK.url
-    },
-    createClient(opts: Parameters<typeof serverSDK.createClient>[0]) {
-      return serverSDK.createClient(opts)
-    },
-  }
-}

packages/app/src/context/server.tsx

@@ -1,7 +1,8 @@
 import { createSimpleContext } from "@opencode-ai/ui/context"
-import { type Accessor, batch, createMemo } from "solid-js"
+import { type Accessor, batch, createEffect, createMemo, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import { Persist, persisted } from "@/utils/persist"
+import { useCheckServerHealth } from "@/utils/server-health"
 
 type StoredProject = { worktree: string; expanded: boolean }
 type StoredServer = string | ServerConnection.HttpBase | ServerConnection.Http
@@ -36,30 +37,24 @@ export function resolveServerList(input: {
   props?: Array<ServerConnection.Any>
   stored: StoredServer[]
 }): Array<ServerConnection.Any> {
-  const deduped = new Map<ServerConnection.Key, ServerConnection.Any>(
-    input.props?.map((v) => [ServerConnection.key(v), v]) ?? [],
-  )
-
-  for (const value of input.stored) {
-    const conn: ServerConnection.Http =
+  const servers = [
+    ...input.stored.map((value) =>
       typeof value === "string"
         ? {
             type: "http" as const,
             http: { url: value },
           }
-        : "http" in value
-          ? value
-          : { type: "http", http: value }
-    const key = ServerConnection.key(conn)
+        : value,
+    ),
+    ...(input.props ?? []),
+  ]
 
-    const existing = deduped.get(key)
-    if (existing)
-      deduped.set(key, {
-        ...existing,
-        ...conn,
-        http: { ...existing.http, ...conn.http },
-      })
-    else deduped.set(key, conn)
+  const deduped = new Map<ServerConnection.Key, ServerConnection.Any>()
+  for (const value of servers) {
+    const conn: ServerConnection.Any = "type" in value ? value : { type: "http", http: value }
+    const key = ServerConnection.key(conn)
+    if (deduped.has(key) && conn.type === "http" && !conn.authToken) continue
+    deduped.set(key, conn)
   }
 
   return [...deduped.values()]
@@ -127,7 +122,13 @@ export namespace ServerConnection {
 
 export const { use: useServer, provider: ServerProvider } = createSimpleContext({
   name: "Server",
-  init: (props: { defaultServer: ServerConnection.Key; servers?: Array<ServerConnection.Any> }) => {
+  init: (props: {
+    defaultServer: ServerConnection.Key
+    disableHealthCheck?: boolean
+    servers?: Array<ServerConnection.Any>
+  }) => {
+    const checkServerHealth = useCheckServerHealth()
+
     const [store, setStore, _, ready] = persisted(
       Persist.global("server", ["server.v3"]),
       createStore({
@@ -145,8 +146,36 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
 
     const [state, setState] = createStore({
       active: props.defaultServer,
+      healthy: undefined as boolean | undefined,
     })
 
+    const healthy = () => state.healthy
+
+    function startHealthPolling(conn: ServerConnection.Any) {
+      let alive = true
+      let busy = false
+
+      const run = () => {
+        if (busy) return
+        busy = true
+        void check(conn)
+          .then((next) => {
+            if (!alive) return
+            setState("healthy", next)
+          })
+          .finally(() => {
+            busy = false
+          })
+      }
+
+      run()
+      const interval = setInterval(run, HEALTH_POLL_INTERVAL_MS)
+      return () => {
+        alive = false
+        clearInterval(interval)
+      }
+    }
+
     function setActive(input: ServerConnection.Key) {
       if (state.active !== input) setState("active", input)
     }
@@ -180,6 +209,20 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
 
     const isReady = createMemo(() => ready() && !!state.active)
 
+    const check = (conn: ServerConnection.Any) => checkServerHealth(conn.http).then((x) => x.healthy)
+
+    createEffect(() => {
+      const current_ = current()
+      if (!current_) return
+
+      if (props.disableHealthCheck) {
+        setState("healthy", true)
+        return
+      }
+      setState("healthy", undefined)
+      onCleanup(startHealthPolling(current_))
+    })
+
     const origin = createMemo(() => projectsKey(state.active))
     const projectsList = createMemo(() => store.projects[origin()] ?? [])
     const current: Accessor<ServerConnection.Any | undefined> = createMemo(
@@ -192,6 +235,7 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
 
     return {
       ready: isReady,
+      healthy,
       isLocal,
       get key() {
         return state.active

packages/app/src/context/servers.tsx

@@ -1,20 +0,0 @@
-import { createSimpleContext } from "@opencode-ai/ui/context"
-import { useServer } from "./server"
-import { useServerHealth } from "@/utils/server-health"
-
-export const { use: useServers, provider: ServersProvider } = createSimpleContext({
-  name: "Servers",
-  init: () => {
-    const server = useServer()
-
-    const health = useServerHealth(
-      () => server.list,
-      () => true,
-    )
-
-    return {
-      list: () => server.list,
-      health,
-    }
-  },
-})

packages/app/src/context/settings.tsx

@@ -32,8 +32,6 @@ export interface Settings {
     shellToolPartsExpanded: boolean
     editToolPartsExpanded: boolean
     showSessionProgressBar: boolean
-    showCustomAgents: boolean
-    newLayoutDesigns?: boolean
   }
   updates: {
     startup: boolean
@@ -55,7 +53,6 @@ export interface Settings {
 export const monoDefault = "System Mono"
 export const sansDefault = "System Sans"
 export const terminalDefault = "JetBrainsMono Nerd Font Mono"
-export const newLayoutDesignsDefault = import.meta.env.VITE_OPENCODE_CHANNEL !== "prod"
 
 const monoFallback =
   'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace'
@@ -120,7 +117,6 @@ const defaultSettings: Settings = {
     shellToolPartsExpanded: false,
     editToolPartsExpanded: false,
     showSessionProgressBar: true,
-    showCustomAgents: false,
   },
   updates: {
     startup: true,
@@ -240,14 +236,6 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
         setShowSessionProgressBar(value: boolean) {
           setStore("general", "showSessionProgressBar", value)
         },
-        showCustomAgents: withFallback(() => store.general?.showCustomAgents, defaultSettings.general.showCustomAgents),
-        setShowCustomAgents(value: boolean) {
-          setStore("general", "showCustomAgents", value)
-        },
-        newLayoutDesigns: withFallback(() => store.general?.newLayoutDesigns, newLayoutDesignsDefault),
-        setNewLayoutDesigns(value: boolean) {
-          setStore("general", "newLayoutDesigns", value)
-        },
       },
       updates: {
         startup: withFallback(() => store.updates?.startup, defaultSettings.updates.startup),

packages/app/src/context/sync.tsx

@@ -1,7 +1,19 @@
+import { batch, createMemo } from "solid-js"
+import { createStore, produce, reconcile } from "solid-js/store"
 import { Binary } from "@opencode-ai/core/util/binary"
-import { useServerSync } from "./server-sync"
+import { retry } from "@opencode-ai/core/util/retry"
+import { createSimpleContext } from "@opencode-ai/ui/context"
+import {
+  clearSessionPrefetch,
+  getSessionPrefetch,
+  getSessionPrefetchPromise,
+  setSessionPrefetch,
+} from "./global-sync/session-prefetch"
+import { useGlobalSync } from "./global-sync"
 import { useSDK } from "./sdk"
 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"
 
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 
@@ -9,8 +21,26 @@ 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)
 
+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>
@@ -108,9 +138,482 @@ export function applyOptimisticRemove(draft: OptimisticStore, input: OptimisticR
   delete draft.part[input.messageID]
 }
 
-export const useSync = () => {
-  const serverSync = useServerSync()
-  const sdk = useSDK()
-
-  return serverSync.createDirSyncContext(sdk.directory)
+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 { use: useSync, provider: SyncProvider } = createSimpleContext({
+  name: "Sync",
+  init: () => {
+    const globalSync = useGlobalSync()
+    const sdk = useSDK()
+
+    type Child = ReturnType<(typeof globalSync)["child"]>
+    type Setter = Child[1]
+
+    const current = createMemo(() => globalSync.child(sdk.directory))
+    const target = (directory?: string) => {
+      if (!directory || directory === sdk.directory) return current()
+      return globalSync.child(directory)
+    }
+    const absolute = (path: string) => (current()[0].path.directory + "/" + path).replace("//", "/")
+    const initialMessagePageSize = 80
+    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
+      }
+      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] = globalSync.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(directory, sessionIDs)
+      for (const sessionID of sessionIDs) {
+        globalSync.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 sdk.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 sdk.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] = globalSync.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({
+              directory: input.directory,
+              sessionID: input.sessionID,
+              limit: message.length,
+              cursor: next.cursor,
+              complete: next.complete,
+            })
+          })
+        })
+        .finally(() => {
+          setMeta(
+            produce((draft) => {
+              if (!tracked(input.directory, input.sessionID)) {
+                delete draft.loading[key]
+                return
+              }
+              draft.loading[key] = false
+            }),
+          )
+        })
+    }
+
+    return {
+      get data() {
+        return current()[0]
+      },
+      get set(): Setter {
+        return current()[1]
+      },
+      get status() {
+        return current()[0].status
+      },
+      get ready() {
+        return current()[0].status !== "loading"
+      },
+      get project() {
+        const store = current()[0]
+        const match = Binary.search(globalSync.data.project, store.project, (p) => p.id)
+        if (match.found) return globalSync.data.project[match.index]
+        return undefined
+      },
+      session: {
+        get: getSession,
+        optimistic: {
+          add(input: { directory?: string; sessionID: string; message: Message; parts: Part[] }) {
+            const directory = input.directory ?? sdk.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 }) {
+            const directory = input.directory ?? sdk.directory
+            const [, setStore] = target(input.directory)
+            clearOptimistic(directory, input.sessionID, input.messageID)
+            setOptimisticRemove(setStore as (...args: unknown[]) => void, input)
+          },
+        },
+        addOptimisticMessage(input: {
+          sessionID: string
+          messageID: string
+          parts: Part[]
+          agent: string
+          model: { providerID: string; modelID: string }
+          variant?: string
+        }) {
+          const message: Message = {
+            id: input.messageID,
+            sessionID: input.sessionID,
+            role: "user",
+            time: { created: Date.now() },
+            agent: input.agent,
+            model: { ...input.model, variant: input.variant },
+          }
+          const [, setStore] = target()
+          setOptimistic(sdk.directory, input.sessionID, { message, parts: input.parts })
+          setOptimisticAdd(setStore as (...args: unknown[]) => void, {
+            sessionID: input.sessionID,
+            message,
+            parts: input.parts,
+          })
+        },
+        async sync(sessionID: string, opts?: { force?: boolean }) {
+          const directory = sdk.directory
+          const client = sdk.client
+          const [store, setStore] = globalSync.child(directory)
+          const key = keyFor(directory, sessionID)
+
+          touch(directory, setStore, sessionID)
+
+          const seeded = getSessionPrefetch(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(directory, sessionID)
+            if (pending) {
+              await pending
+              const seeded = getSessionPrefetch(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)
+                      }),
+                    )
+                  })
+
+            const messagesReq =
+              cached && !opts?.force
+                ? Promise.resolve()
+                : loadMessages({
+                    directory,
+                    client,
+                    setStore,
+                    sessionID,
+                    limit,
+                  })
+
+            await Promise.all([sessionReq, messagesReq])
+          })
+        },
+        async diff(sessionID: string, opts?: { force?: boolean }) {
+          const directory = sdk.directory
+          const client = sdk.client
+          const [store, setStore] = globalSync.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 directory = sdk.directory
+          const client = sdk.client
+          const [store, setStore] = globalSync.child(directory)
+          touch(directory, setStore, sessionID)
+          const existing = store.todo[sessionID]
+          const cached = globalSync.data.session_todo[sessionID]
+          if (existing !== undefined) {
+            if (cached === undefined) {
+              globalSync.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" }))
+              globalSync.todo.set(sessionID, list)
+            }),
+          )
+        },
+        history: {
+          more(sessionID: string) {
+            const store = current()[0]
+            const key = keyFor(sdk.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(sdk.directory, sessionID)
+            return meta.loading[key] ?? false
+          },
+          async loadMore(sessionID: string, count?: number) {
+            const directory = sdk.directory
+            const client = sdk.client
+            const [, setStore] = globalSync.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 = sdk.directory) {
+          const [, setStore] = globalSync.child(directory)
+          seenFor(directory).delete(sessionID)
+          evict(directory, setStore, [sessionID])
+        },
+        fetch: async (count = 10) => {
+          const directory = sdk.directory
+          const client = sdk.client
+          const [store, setStore] = globalSync.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) => {
+          const directory = sdk.directory
+          const client = sdk.client
+          const [, setStore] = globalSync.child(directory)
+          await client.session.update({ sessionID, time: { archived: Date.now() } })
+          setStore(
+            produce((draft) => {
+              const match = Binary.search(draft.session, sessionID, (s) => s.id)
+              if (match.found) draft.session.splice(match.index, 1)
+            }),
+          )
+        },
+      },
+      absolute,
+      get directory() {
+        return current()[0].path.directory
+      },
+    }
+  },
+})

packages/app/src/desktop-menu.ts

@@ -1,223 +0,0 @@
-export type DesktopMenuPlatform = "macos" | "windows"
-
-export type DesktopMenuAction =
-  | "app.checkForUpdates"
-  | "app.relaunch"
-  | "edit.undo"
-  | "edit.redo"
-  | "edit.cut"
-  | "edit.copy"
-  | "edit.paste"
-  | "edit.delete"
-  | "edit.selectAll"
-  | "view.reload"
-  | "view.toggleDevTools"
-  | "view.resetZoom"
-  | "view.zoomIn"
-  | "view.zoomOut"
-  | "view.toggleFullscreen"
-  | "window.new"
-  | "window.close"
-  | "window.minimize"
-  | "window.toggleMaximize"
-
-export type DesktopMenuRole =
-  | "about"
-  | "close"
-  | "copy"
-  | "cut"
-  | "hide"
-  | "hideOthers"
-  | "paste"
-  | "quit"
-  | "redo"
-  | "reload"
-  | "resetZoom"
-  | "selectAll"
-  | "toggleDevTools"
-  | "togglefullscreen"
-  | "undo"
-  | "unhide"
-  | "windowMenu"
-  | "zoomIn"
-  | "zoomOut"
-
-export type DesktopMenuItem = {
-  type: "item"
-  label?: string
-  command?: string
-  action?: DesktopMenuAction
-  role?: DesktopMenuRole
-  href?: string
-  accelerator?: Partial<Record<DesktopMenuPlatform, string>>
-  enabled?: "updater"
-  platforms?: DesktopMenuPlatform[]
-}
-
-export type DesktopMenuSeparator = {
-  type: "separator"
-  platforms?: DesktopMenuPlatform[]
-}
-
-export type DesktopMenuEntry = DesktopMenuItem | DesktopMenuSeparator
-
-export type DesktopMenu = {
-  id: string
-  label: string
-  role?: DesktopMenuRole
-  items?: DesktopMenuEntry[]
-  platforms?: DesktopMenuPlatform[]
-}
-
-export const DESKTOP_MENU: DesktopMenu[] = [
-  {
-    id: "app",
-    label: "OpenCode",
-    platforms: ["macos"],
-    items: [
-      { type: "item", role: "about" },
-      { type: "item", label: "Check for Updates...", action: "app.checkForUpdates", enabled: "updater" },
-      { type: "item", label: "Settings", command: "settings.open", accelerator: { macos: "Cmd+," } },
-      { type: "item", label: "Reload Webview", action: "view.reload" },
-      { type: "item", label: "Restart", action: "app.relaunch" },
-      { type: "item", label: "Export Logs...", command: "logs.export" },
-      { type: "separator" },
-      { type: "item", role: "hide" },
-      { type: "item", role: "hideOthers" },
-      { type: "item", role: "unhide" },
-      { type: "separator" },
-      { type: "item", role: "quit" },
-    ],
-  },
-  {
-    id: "file",
-    label: "File",
-    items: [
-      {
-        type: "item",
-        label: "New Session",
-        command: "session.new",
-        accelerator: { macos: "Shift+Cmd+S" },
-      },
-      { type: "item", label: "Open Project...", command: "project.open", accelerator: { macos: "Cmd+O" } },
-      {
-        type: "item",
-        label: "Settings",
-        command: "settings.open",
-        accelerator: { windows: "Ctrl+," },
-        platforms: ["windows"],
-      },
-      {
-        type: "item",
-        label: "New Window",
-        action: "window.new",
-        accelerator: { macos: "Cmd+Shift+N", windows: "Ctrl+Shift+N" },
-      },
-      { type: "separator" },
-      { type: "item", label: "Close Window", action: "window.close", role: "close" },
-    ],
-  },
-  {
-    id: "edit",
-    label: "Edit",
-    items: [
-      { type: "item", label: "Undo", action: "edit.undo", role: "undo", accelerator: { windows: "Ctrl+Z" } },
-      { type: "item", label: "Redo", action: "edit.redo", role: "redo", accelerator: { windows: "Ctrl+Y" } },
-      { type: "separator" },
-      { type: "item", label: "Cut", action: "edit.cut", role: "cut", accelerator: { windows: "Ctrl+X" } },
-      { type: "item", label: "Copy", action: "edit.copy", role: "copy", accelerator: { windows: "Ctrl+C" } },
-      { type: "item", label: "Paste", action: "edit.paste", role: "paste", accelerator: { windows: "Ctrl+V" } },
-      { type: "item", label: "Delete", action: "edit.delete" },
-      {
-        type: "item",
-        label: "Select All",
-        action: "edit.selectAll",
-        role: "selectAll",
-        accelerator: { windows: "Ctrl+A" },
-      },
-    ],
-  },
-  {
-    id: "view",
-    label: "View",
-    items: [
-      { type: "item", label: "Toggle Sidebar", command: "sidebar.toggle", accelerator: { macos: "Cmd+B" } },
-      { type: "item", label: "Toggle Terminal", command: "terminal.toggle", accelerator: { macos: "Ctrl+`" } },
-      { type: "item", label: "Toggle File Tree", command: "fileTree.toggle" },
-      { type: "separator" },
-      { type: "item", label: "Reload", action: "view.reload", role: "reload" },
-      { type: "item", label: "Toggle Developer Tools", action: "view.toggleDevTools", role: "toggleDevTools" },
-      { type: "separator" },
-      {
-        type: "item",
-        label: "Actual Size",
-        action: "view.resetZoom",
-        role: "resetZoom",
-        accelerator: { windows: "Ctrl+0" },
-      },
-      { type: "item", label: "Zoom In", action: "view.zoomIn", role: "zoomIn", accelerator: { windows: "Ctrl++" } },
-      { type: "item", label: "Zoom Out", action: "view.zoomOut", role: "zoomOut", accelerator: { windows: "Ctrl+-" } },
-      { type: "separator" },
-      { type: "item", label: "Toggle Full Screen", action: "view.toggleFullscreen", role: "togglefullscreen" },
-    ],
-  },
-  {
-    id: "go",
-    label: "Go",
-    items: [
-      { type: "item", label: "Back", command: "common.goBack", accelerator: { macos: "Cmd+[" } },
-      { type: "item", label: "Forward", command: "common.goForward", accelerator: { macos: "Cmd+]" } },
-      { type: "separator" },
-      { type: "item", label: "Previous Session", command: "session.previous", accelerator: { macos: "Option+Up" } },
-      { type: "item", label: "Next Session", command: "session.next", accelerator: { macos: "Option+Down" } },
-      { type: "separator" },
-      {
-        type: "item",
-        label: "Previous Project",
-        command: "project.previous",
-        accelerator: { macos: "Cmd+Option+Up" },
-      },
-      {
-        type: "item",
-        label: "Next Project",
-        command: "project.next",
-        accelerator: { macos: "Cmd+Option+Down" },
-      },
-    ],
-  },
-  {
-    id: "window",
-    label: "Window",
-    role: "windowMenu",
-    items: [
-      { type: "item", label: "Minimize", action: "window.minimize" },
-      { type: "item", label: "Maximize", action: "window.toggleMaximize" },
-      { type: "separator" },
-      { type: "item", label: "Close Window", action: "window.close" },
-    ],
-  },
-  {
-    id: "help",
-    label: "Help",
-    items: [
-      { type: "item", label: "OpenCode Documentation", href: "https://opencode.ai/docs" },
-      { type: "item", label: "Support Forum", href: "https://discord.com/invite/opencode" },
-      { type: "item", label: "Export Logs...", command: "logs.export" },
-      { type: "separator" },
-      {
-        type: "item",
-        label: "Share Feedback",
-        href: "https://github.com/anomalyco/opencode/issues/new?template=feature_request.yml",
-      },
-      {
-        type: "item",
-        label: "Report a Bug",
-        href: "https://github.com/anomalyco/opencode/issues/new?template=bug_report.yml",
-      },
-    ],
-  },
-]
-
-export function desktopMenuVisible(item: { platforms?: DesktopMenuPlatform[] }, platform: DesktopMenuPlatform) {
-  return !item.platforms || item.platforms.includes(platform)
-}

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

@@ -1,7 +1,6 @@
-import { useServerSync } from "@/context/server-sync"
+import { useGlobalSync } from "@/context/global-sync"
 import { decode64 } from "@/utils/base64"
 import { useParams } from "@solidjs/router"
-import { Iterable, pipe } from "effect"
 import { createMemo } from "solid-js"
 
 export const popularProviders = [
@@ -17,45 +16,29 @@ export const popularProviders = [
 const popularProviderSet = new Set(popularProviders)
 
 export function useProviders() {
-  const serverSync = useServerSync()
+  const globalSync = useGlobalSync()
   const params = useParams()
   const dir = createMemo(() => decode64(params.dir) ?? "")
   const providers = () => {
     if (dir()) {
-      const [projectStore] = serverSync.child(dir())
+      const [projectStore] = globalSync.child(dir())
       if (projectStore.provider_ready) return projectStore.provider
     }
-    return serverSync.data.provider
+    return globalSync.data.provider
   }
   return {
     all: () => providers().all,
     default: () => providers().default,
-    popular: () =>
-      pipe(
-        providers().all,
-        Iterable.map(([, p]) => p),
-        Iterable.filter((p) => popularProviderSet.has(p.id)),
-        (v) => Array.from(v),
-      ),
+    popular: () => providers().all.filter((p) => popularProviderSet.has(p.id)),
     connected: () => {
       const connected = new Set(providers().connected)
-      return pipe(
-        providers().all,
-        Iterable.map(([, p]) => p),
-        Iterable.filter((p) => connected.has(p.id)),
-        (v) => Array.from(v),
-      )
+      return providers().all.filter((p) => connected.has(p.id))
     },
     paid: () => {
       const connected = new Set(providers().connected)
-      return [
-        ...Iterable.filter(
-          providers().all,
-          ([id]) =>
-            connected.has(id) &&
-            (id !== "opencode" || Object.values(providers().all.get(id)?.models ?? {}).some((m) => m.cost?.input)),
-        ),
-      ]
+      return providers().all.filter(
+        (p) => connected.has(p.id) && (p.id !== "opencode" || Object.values(p.models).some((m) => m.cost?.input)),
+      )
     },
   }
 }

packages/app/src/i18n/ar.ts

@@ -413,7 +413,7 @@ export const dict = {
   "error.page.version": "الإصدار: {{version}}",
   "error.dev.rootNotFound":
     "لم يتم العثور على العنصر الجذري. هل نسيت إضافته إلى index.html؟ أو ربما تمت كتابة سمة id بشكل خاطئ؟",
-  "error.serverSync.connectFailed": "تعذر الاتصال بالخادم. هل هناك خادم يعمل في `{{url}}`؟",
+  "error.globalSync.connectFailed": "تعذر الاتصال بالخادم. هل هناك خادم يعمل في `{{url}}`؟",
   "directory.error.invalidUrl": "دليل غير صالح في عنوان URL.",
   "error.chain.unknown": "خطأ غير معروف",
   "error.chain.causedBy": "بسبب:",
@@ -837,8 +837,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "غير معروف",
   "error.page.circular": "[دائري]",
-  "error.serverSDK.noServerAvailable": "لا يوجد خادم متاح",
-  "error.serverSDK.serverNotAvailable": "الخادم غير متاح",
+  "error.globalSDK.noServerAvailable": "لا يوجد خادم متاح",
+  "error.globalSDK.serverNotAvailable": "الخادم غير متاح",
   "error.childStore.persistedCacheCreateFailed": "فشل إنشاء ذاكرة التخزين المؤقت الدائمة",
   "error.childStore.persistedProjectMetadataCreateFailed": "فشل إنشاء بيانات تعريف المشروع الدائمة",
   "error.childStore.persistedProjectIconCreateFailed": "فشل إنشاء أيقونة المشروع الدائمة",

packages/app/src/i18n/br.ts

@@ -414,7 +414,7 @@ export const dict = {
   "error.page.version": "Versão: {{version}}",
   "error.dev.rootNotFound":
     "Elemento raiz não encontrado. Você esqueceu de adicioná-lo ao seu index.html? Ou talvez o atributo id foi escrito incorretamente?",
-  "error.serverSync.connectFailed": "Não foi possível conectar ao servidor. Há um servidor executando em `{{url}}`?",
+  "error.globalSync.connectFailed": "Não foi possível conectar ao servidor. Há um servidor executando em `{{url}}`?",
   "directory.error.invalidUrl": "Diretório inválido na URL.",
   "error.chain.unknown": "Erro desconhecido",
   "error.chain.causedBy": "Causado por:",
@@ -850,8 +850,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "desconhecido",
   "error.page.circular": "[Circular]",
-  "error.serverSDK.noServerAvailable": "Nenhum servidor disponível",
-  "error.serverSDK.serverNotAvailable": "Servidor indisponível",
+  "error.globalSDK.noServerAvailable": "Nenhum servidor disponível",
+  "error.globalSDK.serverNotAvailable": "Servidor indisponível",
   "error.childStore.persistedCacheCreateFailed": "Falha ao criar cache persistente",
   "error.childStore.persistedProjectMetadataCreateFailed": "Falha ao criar metadados de projeto persistentes",
   "error.childStore.persistedProjectIconCreateFailed": "Falha ao criar ícone de projeto persistente",

packages/app/src/i18n/bs.ts

@@ -462,7 +462,7 @@ export const dict = {
   "error.dev.rootNotFound":
     "Korijenski element nije pronađen. Da li si zaboravio da ga dodaš u index.html? Ili je možda id atribut pogrešno napisan?",
 
-  "error.serverSync.connectFailed": "Nije moguće povezati se na server. Da li server radi na `{{url}}`?",
+  "error.globalSync.connectFailed": "Nije moguće povezati se na server. Da li server radi na `{{url}}`?",
   "directory.error.invalidUrl": "Nevažeći direktorij u URL-u.",
 
   "error.chain.unknown": "Nepoznata greška",
@@ -926,8 +926,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "nepoznato",
   "error.page.circular": "[Kružno]",
-  "error.serverSDK.noServerAvailable": "Nema dostupnog servera",
-  "error.serverSDK.serverNotAvailable": "Server nije dostupan",
+  "error.globalSDK.noServerAvailable": "Nema dostupnog servera",
+  "error.globalSDK.serverNotAvailable": "Server nije dostupan",
   "error.childStore.persistedCacheCreateFailed": "Nije uspjelo kreiranje trajnog keša",
   "error.childStore.persistedProjectMetadataCreateFailed": "Nije uspjelo kreiranje trajnih metapodataka projekta",
   "error.childStore.persistedProjectIconCreateFailed": "Nije uspjelo kreiranje trajne ikone projekta",

packages/app/src/i18n/da.ts

@@ -459,7 +459,7 @@ export const dict = {
   "error.dev.rootNotFound":
     "Rodelement ikke fundet. Har du glemt at tilføje det til din index.html? Eller måske er id-attributten stavet forkert?",
 
-  "error.serverSync.connectFailed": "Kunne ikke forbinde til server. Kører der en server på `{{url}}`?",
+  "error.globalSync.connectFailed": "Kunne ikke forbinde til server. Kører der en server på `{{url}}`?",
   "directory.error.invalidUrl": "Ugyldig mappe i URL.",
 
   "error.chain.unknown": "Ukendt fejl",
@@ -920,8 +920,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "ukendt",
   "error.page.circular": "[Cirkulær]",
-  "error.serverSDK.noServerAvailable": "Ingen server tilgængelig",
-  "error.serverSDK.serverNotAvailable": "Server ikke tilgængelig",
+  "error.globalSDK.noServerAvailable": "Ingen server tilgængelig",
+  "error.globalSDK.serverNotAvailable": "Server ikke tilgængelig",
   "error.childStore.persistedCacheCreateFailed": "Kunne ikke oprette vedvarende cache",
   "error.childStore.persistedProjectMetadataCreateFailed": "Kunne ikke oprette vedvarende projektmetadata",
   "error.childStore.persistedProjectIconCreateFailed": "Kunne ikke oprette vedvarende projektikon",

packages/app/src/i18n/de.ts

@@ -421,7 +421,7 @@ export const dict = {
   "error.page.version": "Version: {{version}}",
   "error.dev.rootNotFound":
     "Wurzelelement nicht gefunden. Haben Sie vergessen, es in Ihre index.html aufzunehmen? Oder wurde das id-Attribut falsch geschrieben?",
-  "error.serverSync.connectFailed": "Verbindung zum Server fehlgeschlagen. Läuft ein Server unter `{{url}}`?",
+  "error.globalSync.connectFailed": "Verbindung zum Server fehlgeschlagen. Läuft ein Server unter `{{url}}`?",
   "directory.error.invalidUrl": "Ungültiges Verzeichnis in der URL.",
   "error.chain.unknown": "Unbekannter Fehler",
   "error.chain.causedBy": "Verursacht durch:",
@@ -862,8 +862,8 @@ export const dict = {
   "common.key.insert": "Einfg",
   "common.unknown": "unbekannt",
   "error.page.circular": "[Zirkulär]",
-  "error.serverSDK.noServerAvailable": "Kein Server verfügbar",
-  "error.serverSDK.serverNotAvailable": "Server nicht verfügbar",
+  "error.globalSDK.noServerAvailable": "Kein Server verfügbar",
+  "error.globalSDK.serverNotAvailable": "Server nicht verfügbar",
   "error.childStore.persistedCacheCreateFailed": "Dauerhafter Cache konnte nicht erstellt werden",
   "error.childStore.persistedProjectMetadataCreateFailed": "Dauerhafte Projektmetadaten konnten nicht erstellt werden",
   "error.childStore.persistedProjectIconCreateFailed": "Dauerhaftes Projekticon konnte nicht erstellt werden",

packages/app/src/i18n/en.ts

@@ -221,7 +221,6 @@ export const dict = {
   "common.loading": "Loading",
   "common.loading.ellipsis": "...",
   "common.cancel": "Cancel",
-  "common.clear": "Clear",
   "common.open": "Open",
   "common.connect": "Connect",
   "common.disconnect": "Disconnect",
@@ -417,7 +416,6 @@ export const dict = {
   "language.no": "Norsk",
   "language.br": "Português (Brasil)",
   "language.bs": "Bosanski",
-  "language.uk": "Українська",
   "language.th": "ไทย",
   "language.tr": "Türkçe",
 
@@ -471,7 +469,6 @@ export const dict = {
   "error.page.action.restart": "Restart",
   "error.page.action.report": "Report Error",
   "error.page.action.reported": "Error Reported",
-  "error.page.action.exportLogs": "Export Logs",
   "error.page.action.checking": "Checking...",
   "error.page.action.checkUpdates": "Check for updates",
   "error.page.action.updateTo": "Update to {{version}}",
@@ -483,9 +480,9 @@ export const dict = {
   "error.dev.rootNotFound":
     "Root element not found. Did you forget to add it to your index.html? Or maybe the id attribute got misspelled?",
 
-  "error.serverSync.connectFailed": "Could not connect to server. Is there a server running at `{{url}}`?",
-  "error.serverSDK.noServerAvailable": "No server available",
-  "error.serverSDK.serverNotAvailable": "Server not available",
+  "error.globalSync.connectFailed": "Could not connect to server. Is there a server running at `{{url}}`?",
+  "error.globalSDK.noServerAvailable": "No server available",
+  "error.globalSDK.serverNotAvailable": "Server not available",
   "error.childStore.persistedCacheCreateFailed": "Failed to create persisted cache",
   "error.childStore.persistedProjectMetadataCreateFailed": "Failed to create persisted project metadata",
   "error.childStore.persistedProjectIconCreateFailed": "Failed to create persisted project icon",
@@ -527,15 +524,6 @@ export const dict = {
   "home.recentProjects": "Recent projects",
   "home.empty.title": "No recent projects",
   "home.empty.description": "Get started by opening a local project",
-  "home.title": "Home",
-  "home.projects": "Projects",
-  "home.project.add": "Add project",
-  "home.sessions.search.placeholder": "Search sessions",
-  "home.sessions.empty": "No sessions found",
-  "home.sessions.empty.description": "Start a new session for this project",
-  "home.sessions.group.today": "Today",
-  "home.sessions.group.yesterday": "Yesterday",
-  "home.sessions.group.older": "Older",
 
   "session.tab.session": "Session",
   "session.tab.review": "Review",
@@ -586,9 +574,6 @@ export const dict = {
   "session.revertDock.restore": "Restore message",
 
   "session.new.title": "Build anything",
-  "session.new.project.new": "New project",
-  "session.new.project.search": "Search projects",
-  "session.new.project.add": "Add project",
   "session.new.worktree.main": "Main branch",
   "session.new.worktree.mainWithBranch": "Main branch ({{branch}})",
   "session.new.worktree.create": "Create new worktree",
@@ -769,7 +754,7 @@ export const dict = {
   "settings.general.row.followup.option.queue": "Queue",
   "settings.general.row.followup.option.steer": "Steer",
   "settings.general.row.showFileTree.title": "File tree",
-  "settings.general.row.showFileTree.description": "Show the file tree panel in desktop sessions",
+  "settings.general.row.showFileTree.description": "Show the file tree toggle and panel in desktop sessions",
   "settings.general.row.showNavigation.title": "Navigation controls",
   "settings.general.row.showNavigation.description": "Show the back and forward buttons in the desktop title bar",
   "settings.general.row.showSearch.title": "Command palette",
@@ -778,8 +763,6 @@ export const dict = {
   "settings.general.row.showTerminal.description": "Show the terminal button in the desktop title bar",
   "settings.general.row.showStatus.title": "Server status",
   "settings.general.row.showStatus.description": "Show the server status button in the desktop title bar",
-  "settings.general.row.showCustomAgents.title": "Custom agents",
-  "settings.general.row.showCustomAgents.description": "Show the agent picker in the v2 desktop composer",
   "settings.general.row.reasoningSummaries.title": "Show reasoning summaries",
   "settings.general.row.reasoningSummaries.description": "Display model reasoning summaries in the timeline",
   "settings.general.row.shellToolPartsExpanded.title": "Expand shell tool parts",
@@ -791,10 +774,6 @@ export const dict = {
   "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",
-  "settings.general.row.pinchZoom.description": "Allow trackpad pinch and Ctrl-scroll gestures to zoom",
 
   "settings.general.row.wayland.title": "Use native Wayland",
   "settings.general.row.wayland.description": "Disable X11 fallback on Wayland. Requires restart.",

packages/app/src/i18n/es.ts

@@ -462,7 +462,7 @@ export const dict = {
   "error.dev.rootNotFound":
     "Elemento raíz no encontrado. ¿Olvidaste añadirlo a tu index.html? ¿O tal vez el atributo id está mal escrito?",
 
-  "error.serverSync.connectFailed": "No se pudo conectar al servidor. ¿Hay un servidor ejecutándose en `{{url}}`?",
+  "error.globalSync.connectFailed": "No se pudo conectar al servidor. ¿Hay un servidor ejecutándose en `{{url}}`?",
   "directory.error.invalidUrl": "URL de directorio inválida.",
 
   "error.chain.unknown": "Error desconocido",
@@ -933,8 +933,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "desconocido",
   "error.page.circular": "[Circular]",
-  "error.serverSDK.noServerAvailable": "Ningún servidor disponible",
-  "error.serverSDK.serverNotAvailable": "Servidor no disponible",
+  "error.globalSDK.noServerAvailable": "Ningún servidor disponible",
+  "error.globalSDK.serverNotAvailable": "Servidor no disponible",
   "error.childStore.persistedCacheCreateFailed": "Error al crear caché persistente",
   "error.childStore.persistedProjectMetadataCreateFailed": "Error al crear metadatos de proyecto persistentes",
   "error.childStore.persistedProjectIconCreateFailed": "Error al crear icono de proyecto persistente",

packages/app/src/i18n/fr.ts

@@ -417,7 +417,7 @@ export const dict = {
   "error.page.version": "Version : {{version}}",
   "error.dev.rootNotFound":
     "Élément racine introuvable. Avez-vous oublié de l'ajouter à votre index.html ? Ou peut-être que l'attribut id est mal orthographié ?",
-  "error.serverSync.connectFailed":
+  "error.globalSync.connectFailed":
     "Impossible de se connecter au serveur. Y a-t-il un serveur en cours d'exécution à `{{url}}` ?",
   "directory.error.invalidUrl": "Répertoire invalide dans l'URL.",
   "error.chain.unknown": "Erreur inconnue",
@@ -860,8 +860,8 @@ export const dict = {
   "common.key.insert": "Inser",
   "common.unknown": "inconnu",
   "error.page.circular": "[Circulaire]",
-  "error.serverSDK.noServerAvailable": "Aucun serveur disponible",
-  "error.serverSDK.serverNotAvailable": "Serveur non disponible",
+  "error.globalSDK.noServerAvailable": "Aucun serveur disponible",
+  "error.globalSDK.serverNotAvailable": "Serveur non disponible",
   "error.childStore.persistedCacheCreateFailed": "Échec de la création du cache persistant",
   "error.childStore.persistedProjectMetadataCreateFailed":
     "Échec de la création des métadonnées de projet persistantes",

packages/app/src/i18n/ja.ts

@@ -413,7 +413,7 @@ export const dict = {
   "error.page.version": "バージョン: {{version}}",
   "error.dev.rootNotFound":
     "ルート要素が見つかりません。index.htmlに追加するのを忘れていませんか？またはid属性のスペルが間違っていませんか？",
-  "error.serverSync.connectFailed": "サーバーに接続できませんでした。`{{url}}`でサーバーが実行されていますか？",
+  "error.globalSync.connectFailed": "サーバーに接続できませんでした。`{{url}}`でサーバーが実行されていますか？",
   "directory.error.invalidUrl": "URL内のディレクトリが無効です。",
   "error.chain.unknown": "不明なエラー",
   "error.chain.causedBy": "原因:",
@@ -844,8 +844,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "不明",
   "error.page.circular": "[循環]",
-  "error.serverSDK.noServerAvailable": "利用可能なサーバーがありません",
-  "error.serverSDK.serverNotAvailable": "サーバーが利用できません",
+  "error.globalSDK.noServerAvailable": "利用可能なサーバーがありません",
+  "error.globalSDK.serverNotAvailable": "サーバーが利用できません",
   "error.childStore.persistedCacheCreateFailed": "永続キャッシュの作成に失敗しました",
   "error.childStore.persistedProjectMetadataCreateFailed": "永続プロジェクトメタデータの作成に失敗しました",
   "error.childStore.persistedProjectIconCreateFailed": "永続プロジェクトアイコンの作成に失敗しました",

packages/app/src/i18n/ko.ts

@@ -412,7 +412,7 @@ export const dict = {
   "error.page.version": "버전: {{version}}",
   "error.dev.rootNotFound":
     "루트 요소를 찾을 수 없습니다. index.html에 추가하는 것을 잊으셨나요? 또는 id 속성의 철자가 틀렸을 수 있습니다.",
-  "error.serverSync.connectFailed": "서버에 연결할 수 없습니다. `{{url}}`에서 서버가 실행 중인가요?",
+  "error.globalSync.connectFailed": "서버에 연결할 수 없습니다. `{{url}}`에서 서버가 실행 중인가요?",
   "directory.error.invalidUrl": "URL에 유효하지 않은 디렉터리가 있습니다.",
   "error.chain.unknown": "알 수 없는 오류",
   "error.chain.causedBy": "원인:",
@@ -839,8 +839,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "알 수 없음",
   "error.page.circular": "[순환]",
-  "error.serverSDK.noServerAvailable": "사용 가능한 서버 없음",
-  "error.serverSDK.serverNotAvailable": "서버를 사용할 수 없음",
+  "error.globalSDK.noServerAvailable": "사용 가능한 서버 없음",
+  "error.globalSDK.serverNotAvailable": "서버를 사용할 수 없음",
   "error.childStore.persistedCacheCreateFailed": "영구 캐시 생성 실패",
   "error.childStore.persistedProjectMetadataCreateFailed": "영구 프로젝트 메타데이터 생성 실패",
   "error.childStore.persistedProjectIconCreateFailed": "영구 프로젝트 아이콘 생성 실패",

packages/app/src/i18n/no.ts

@@ -463,7 +463,7 @@ export const dict = {
   "error.dev.rootNotFound":
     "Rotelement ikke funnet. Glemte du å legge det til i index.html? Eller kanskje id-attributten er feilstavet?",
 
-  "error.serverSync.connectFailed": "Kunne ikke koble til server. Kjører det en server på `{{url}}`?",
+  "error.globalSync.connectFailed": "Kunne ikke koble til server. Kjører det en server på `{{url}}`?",
   "directory.error.invalidUrl": "Invalid directory in URL.",
 
   "error.chain.unknown": "Ukjent feil",
@@ -927,8 +927,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "ukjent",
   "error.page.circular": "[Sirkulær]",
-  "error.serverSDK.noServerAvailable": "Ingen server tilgjengelig",
-  "error.serverSDK.serverNotAvailable": "Server ikke tilgjengelig",
+  "error.globalSDK.noServerAvailable": "Ingen server tilgjengelig",
+  "error.globalSDK.serverNotAvailable": "Server ikke tilgjengelig",
   "error.childStore.persistedCacheCreateFailed": "Kunne ikke opprette vedvarende hurtigbuffer",
   "error.childStore.persistedProjectMetadataCreateFailed": "Kunne ikke opprette vedvarende prosjektmetadata",
   "error.childStore.persistedProjectIconCreateFailed": "Kunne ikke opprette vedvarende prosjektikon",

packages/app/src/i18n/parity.test.ts

@@ -12,13 +12,12 @@ import { dict as ko } from "./ko"
 import { dict as no } from "./no"
 import { dict as pl } from "./pl"
 import { dict as ru } from "./ru"
-import { dict as uk } from "./uk"
 import { dict as th } from "./th"
 import { dict as zh } from "./zh"
 import { dict as zht } from "./zht"
 import { dict as tr } from "./tr"
 
-const locales = [ar, br, bs, da, de, es, fr, ja, ko, no, pl, ru, uk, th, tr, zh, zht]
+const locales = [ar, br, bs, da, de, es, fr, ja, ko, no, pl, ru, th, tr, zh, zht]
 const keys = ["command.session.previous.unseen", "command.session.next.unseen"] as const
 
 describe("i18n parity", () => {

packages/app/src/i18n/pl.ts

@@ -414,7 +414,7 @@ export const dict = {
   "error.page.version": "Wersja: {{version}}",
   "error.dev.rootNotFound":
     "Nie znaleziono elementu głównego. Czy zapomniałeś dodać go do swojego index.html? A może atrybut id został błędnie wpisany?",
-  "error.serverSync.connectFailed": "Nie można połączyć się z serwerem. Czy serwer działa pod adresem `{{url}}`?",
+  "error.globalSync.connectFailed": "Nie można połączyć się z serwerem. Czy serwer działa pod adresem `{{url}}`?",
   "directory.error.invalidUrl": "Nieprawidłowy katalog w URL.",
   "error.chain.unknown": "Nieznany błąd",
   "error.chain.causedBy": "Spowodowany przez:",
@@ -848,8 +848,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "nieznany",
   "error.page.circular": "[Cykliczne]",
-  "error.serverSDK.noServerAvailable": "Brak dostępnego serwera",
-  "error.serverSDK.serverNotAvailable": "Serwer niedostępny",
+  "error.globalSDK.noServerAvailable": "Brak dostępnego serwera",
+  "error.globalSDK.serverNotAvailable": "Serwer niedostępny",
   "error.childStore.persistedCacheCreateFailed": "Nie udało się utworzyć trwałej pamięci podręcznej",
   "error.childStore.persistedProjectMetadataCreateFailed": "Nie udało się utworzyć trwałych metadanych projektu",
   "error.childStore.persistedProjectIconCreateFailed": "Nie udało się utworzyć trwałej ikony projektu",

packages/app/src/i18n/ru.ts

@@ -461,7 +461,7 @@ export const dict = {
   "error.dev.rootNotFound":
     "Корневой элемент не найден. Вы забыли добавить его в index.html? Или, может быть, атрибут id был написан неправильно?",
 
-  "error.serverSync.connectFailed": "Не удалось подключиться к серверу. Запущен ли сервер по адресу `{{url}}`?",
+  "error.globalSync.connectFailed": "Не удалось подключиться к серверу. Запущен ли сервер по адресу `{{url}}`?",
   "directory.error.invalidUrl": "Недопустимая директория в URL.",
 
   "error.chain.unknown": "Неизвестная ошибка",
@@ -929,8 +929,8 @@ export const dict = {
   "common.key.insert": "Insert",
   "common.unknown": "неизвестно",
   "error.page.circular": "[Циклично]",
-  "error.serverSDK.noServerAvailable": "Нет доступного сервера",
-  "error.serverSDK.serverNotAvailable": "Сервер недоступен",
+  "error.globalSDK.noServerAvailable": "Нет доступного сервера",
+  "error.globalSDK.serverNotAvailable": "Сервер недоступен",
   "error.childStore.persistedCacheCreateFailed": "Не удалось создать постоянный кэш",
   "error.childStore.persistedProjectMetadataCreateFailed": "Не удалось создать постоянные метаданные проекта",
   "error.childStore.persistedProjectIconCreateFailed": "Не удалось создать постоянный значок проекта",