feat(desktop): add SSH server connections

Co-authored-by: LukeParkerDev <10430890+Hona@users.noreply.github.com>

bun.lock

@@ -432,6 +432,7 @@
         "@types/node": "catalog:",
         "@typescript/native-preview": "catalog:",
         "app-builder-lib": "26.15.7",
+        "drizzle-kit": "catalog:",
         "drizzle-orm": "catalog:",
         "effect": "catalog:",
         "electron": "42.10.1",
@@ -1036,12 +1037,9 @@
     },
   },
   "trustedDependencies": [
-    "esbuild",
-    "tree-sitter-powershell",
-    "protobufjs",
     "electron",
-    "web-tree-sitter",
-    "tree-sitter-bash",
+    "esbuild",
+    "protobufjs",
   ],
   "patchedDependencies": {
     "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-bWKV3fV8Yc+3ILaNRChIYajsRcvEG2OkydsD2KMUXCM=",
-    "aarch64-linux": "sha256-zIavB09LW+BU3GOq0PO7Lqfc3MVchkiOUf3trnAjhRM=",
-    "aarch64-darwin": "sha256-Jlvz7QsXsb8GS9Ty4TmUIfGOawiueZWWEYmyEPms3dc=",
-    "x86_64-darwin": "sha256-TzTDtcDtj1c3+eP2WZAHOfkszxIS06J6QUwlnscLaUM="
+    "x86_64-linux": "sha256-T1JUv8gUrXavDI1HdVGqNRal4y2Bh5QavpR4DV+bJdA=",
+    "aarch64-linux": "sha256-wlbWdEUVWAafgxaZis0Q+SAas8k6hu3s0C39CnMZ2gw=",
+    "aarch64-darwin": "sha256-74rRue8KQWKzgMMb540beqMzp1DUShlPte6qklYCVTs=",
+    "x86_64-darwin": "sha256-ihr3DoLd/4Lw6WbyXzSQXMP4hrVGk/UiRkO2aoQn8vg="
   }
 }

package.json

@@ -146,10 +146,6 @@
     "esbuild",
     "node-pty",
     "protobufjs",
-    "tree-sitter",
-    "tree-sitter-bash",
-    "tree-sitter-powershell",
-    "web-tree-sitter",
     "electron"
   ],
   "overrides": {

packages/ai/AGENTS.md

@@ -81,7 +81,7 @@ export const route = Route.make({
 
 Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry only model id, provider id, and the configured route value. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.
 
-The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider deployment is a 5-15 line `Route.make(...)` call instead of a 300-400 line route clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
+The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider owns a small `Route.make(...)` composition instead of a protocol clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
 
 When a provider supports multiple physical transports, selection remains execution policy below its semantic route. `OpenResponsesChannel.transport(...)` owns the provider-neutral Responses WebSocket concept: it prepares one final request, executes HTTP by default, strips WebSocket-disallowed fields, and passes a generic channel exchange to a per-call `WebSocketChannelExecutor` when supplied. Provider-specific Responses routes opt in with handshake and connection-age policy. `Route.streamPrepared` owns decoding and acknowledges channel completion only after successful full consumption.
 
@@ -115,6 +115,7 @@ Keep provider facades small and explicit:
 - Prefer `apiKey` as provider-specific sugar and `auth` as the explicit override; keep them mutually exclusive in provider option types with `ProviderAuthOption`.
 - Resolve `apiKey` → `Auth` with `AuthOptions.bearer(options, "<PROVIDER>_API_KEY")` (it honors an explicit `auth` override and falls back to `Auth.config(envVar)` so missing keys surface a typed `Authentication` error rather than a runtime crash).
 - Use separate top-level facades for products with different required setup, such as `CloudflareAIGateway` and `CloudflareWorkersAI`.
+- Give every named provider its own file and top-level export. Keep its endpoint, auth defaults, and route setup in that file. Compose shared protocols directly; do not nest named provider presets under generic compatible facades or keep their endpoints in a shared provider profile registry.
 
 `Provider.make(...)` remains available for simple static provider definitions, but new built-in providers should prefer plain configured facades unless a helper removes real duplication without adding runtime behavior.
 

packages/ai/README.md

@@ -461,7 +461,18 @@ const gateway = CloudflareAIGateway.configure({
 }).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
 ```
 
-Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and Anthropic, Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, Z.ai, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint.
+Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazon Bedrock, Azure OpenAI, Baseten, Cerebras, Cloudflare AI Gateway, Cloudflare Workers AI, DeepInfra, DeepSeek, Fireworks, Groq, Mistral, OpenRouter, TogetherAI, and xAI. Z.ai currently exposes image generation. Generic Chat Completions, Responses, and Anthropic Messages-compatible entrypoints support custom endpoints.
+
+Each named provider owns its module, endpoint, authentication, and route setup. Providers with the same wire format compose the shared protocol directly:
+
+```ts
+import { DeepSeek, Fireworks } from "@opencode-ai/ai/providers"
+
+const deepseek = DeepSeek.configure({ apiKey }).model("deepseek-chat")
+const fireworks = Fireworks.configure({ apiKey }).model("accounts/fireworks/models/my-model")
+```
+
+The former `OpenAICompatible.baseten`, `.cerebras`, `.deepinfra`, `.deepseek`, `.fireworks`, `.groq`, and `.togetherai` presets are replaced by the top-level `Baseten`, `Cerebras`, `DeepInfra`, `DeepSeek`, `Fireworks`, `Groq`, and `TogetherAI` exports. Use `CloudflareAIGateway` and `CloudflareWorkersAI` directly; each has its own module. `OpenAICompatible` configures generic endpoints with an explicit `baseURL`.
 
 ### Package-like entrypoints
 
@@ -519,7 +530,15 @@ model("claude-sonnet-4-6", { project: "my-project", location: "global" })
 
 Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path.
 
-Other provider exports listed above remain direct facades until they explicitly implement the package-like contract. Exporting a provider facade does not implicitly make it a catalog-loadable provider package.
+Every named LLM provider listed above also exports `model(modelID, settings)` from its own package entrypoint. The extracted providers are available at:
+
+- `@opencode-ai/ai/providers/baseten`
+- `@opencode-ai/ai/providers/deepseek`
+- `@opencode-ai/ai/providers/fireworks`
+- `@opencode-ai/ai/providers/cloudflare-ai-gateway`
+- `@opencode-ai/ai/providers/cloudflare-workers-ai`
+
+Core resolves known compatible catalog providers through their dedicated entrypoints, including the `fireworks-ai` catalog ID through `providers/fireworks`.
 
 ## Provider options & HTTP overlays
 

packages/ai/script/setup-recording-env.ts

@@ -7,7 +7,8 @@ import { AwsV4Signer } from "aws4fetch"
 import { Config, ConfigProvider, Effect, FileSystem, PlatformError, Redacted } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/unstable/http"
 import * as ProviderShared from "../src/protocols/shared"
-import * as Cloudflare from "../src/providers/cloudflare"
+import { CloudflareAIGateway } from "../src/providers/cloudflare-ai-gateway.js"
+import { CloudflareWorkersAI } from "../src/providers/cloudflare-workers-ai.js"
 
 type Provider = {
   readonly id: string
@@ -120,11 +121,11 @@ const PROVIDERS: ReadonlyArray<Provider> = [
     ],
     validate: (env) =>
       validateChat({
-        url: `${Cloudflare.aiGatewayBaseURL({
+        url: `${CloudflareAIGateway.baseURL({
           accountId: env.CLOUDFLARE_ACCOUNT_ID,
           gatewayId: env.CLOUDFLARE_GATEWAY_ID || undefined,
         })}/chat/completions`,
-        token: Redacted.make(envValue(env, Cloudflare.aiGatewayAuthEnvVars)),
+        token: Redacted.make(envValue(env, CloudflareAIGateway.authEnvVars)),
         tokenHeader: "cf-aig-authorization",
         model: "workers-ai/@cf/meta/llama-3.1-8b-instruct",
       }),
@@ -140,8 +141,8 @@ const PROVIDERS: ReadonlyArray<Provider> = [
     ],
     validate: (env) =>
       validateChat({
-        url: `${Cloudflare.workersAIBaseURL({ accountId: env.CLOUDFLARE_ACCOUNT_ID })}/chat/completions`,
-        token: Redacted.make(envValue(env, Cloudflare.workersAIAuthEnvVars)),
+        url: `${CloudflareWorkersAI.baseURL({ accountId: env.CLOUDFLARE_ACCOUNT_ID })}/chat/completions`,
+        token: Redacted.make(envValue(env, CloudflareWorkersAI.authEnvVars)),
         model: "@cf/meta/llama-3.1-8b-instruct",
       }),
   },

packages/ai/src/protocols/bedrock-converse.ts

@@ -415,10 +415,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
 
 // System prompts share the cache-point convention: emit the text block, then
 // optionally a positional `cachePoint` marker.
-const lowerSystem = (
-  breakpoints: BedrockCache.Breakpoints,
-  system: ReadonlyArray<LLMRequest["system"][number]>,
-) => {
+const lowerSystem = (breakpoints: BedrockCache.Breakpoints, system: ReadonlyArray<LLMRequest["system"][number]>) => {
   const content = system
     .filter((part) => part.text.length > 0)
     .flatMap((part) => textWithCache(breakpoints, part.text, part.cache))
@@ -431,7 +428,7 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request:
   const generation = request.generation
   // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
   // tools → system → messages order to favour the highest-impact prefixes.
-  const breakpoints = BedrockCache.breakpoints()
+  const breakpoints = BedrockCache.breakpoints(request.model.id)
   const toolConfig = (() => {
     if (flattened.tools.length === 0) return undefined
     return {

packages/ai/src/protocols/gemini.ts

@@ -639,6 +639,14 @@ const step = (state: ParserState, event: GeminiEvent) => {
       : state.usage,
   }
   const candidate = event.candidates?.[0]
+  if (candidate?.finishReason && mapFinishReason(candidate.finishReason, state.hasToolCalls) === "error")
+    return Effect.fail(
+      ProviderShared.eventError(
+        state.route,
+        `Gemini stopped with ${candidate.finishReason}`,
+        ProviderShared.encodeJson(event),
+      ),
+    )
   if (!candidate?.content)
     return Effect.succeed([
       { ...nextState, finishReason: candidate?.finishReason ?? nextState.finishReason },

packages/ai/src/protocols/mistral-chat.ts

@@ -9,6 +9,8 @@ import {
   AIError,
   InvalidProviderOutputError,
   LLMEvent,
+  ProviderInternalError,
+  UnknownProviderError,
   Usage,
   type FinishReasonDetails,
   type LLMRequest,
@@ -700,6 +702,16 @@ const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event:
     normalized: mapFinishReason(choice.finish_reason),
     raw: choice.finish_reason,
   }
+  if (finishReason.normalized === "error") {
+    const details = {
+      message: `Mistral Chat stopped with ${finishReason.raw}`,
+      body: ProviderShared.encodeJson(event),
+    }
+    return yield* new AIError({
+      reason:
+        finishReason.raw === "network_error" ? new ProviderInternalError(details) : new UnknownProviderError(details),
+    })
+  }
   const incomplete = finishReason.normalized === "length" || finishReason.normalized === "content-filter"
   if (!incomplete && Object.keys(withTools.pendingTools).length > 0)
     return yield* ProviderShared.eventError(

packages/ai/src/protocols/utils/bedrock-cache.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import type { CacheHint } from "../../schema/index.js"
-import { newBreakpoints, ttlBucket, type Breakpoints } from "./cache.js"
+import { newBreakpoints, ttlBucket } from "./cache.js"
 
 // Bedrock cache markers are positional: emit a `cachePoint` block immediately
 // after the content the caller wants treated as a cacheable prefix. Bedrock
@@ -13,24 +13,46 @@ export const CachePointBlock = Schema.Struct({
 })
 export type CachePointBlock = Schema.Schema.Type<typeof CachePointBlock>
 
-// Callers pass a shared counter through every `block()` call site so the
-// four-breakpoint budget is respected across `system`, `messages`, and `tools`.
+const LEGACY_CLAUDE = ["anthropic.claude-instant", "anthropic.claude-v1", "anthropic.claude-v2", "anthropic.claude-3-"]
+
+// These legacy Claude releases support explicit caching, but only for five minutes.
+const CLAUDE_5M = [
+  "anthropic.claude-3-5-sonnet-20241022-v2:0",
+  "anthropic.claude-3-5-haiku-20241022-v1:0",
+  "anthropic.claude-3-7-sonnet-20250219-v1:0",
+  "anthropic.claude-sonnet-4-20250514-v1:0",
+  "anthropic.claude-opus-4-20250514-v1:0",
+  "anthropic.claude-opus-4-1-20250805-v1:0",
+]
+
+// Callers share the four-breakpoint budget across system, messages, and tools.
 export const BEDROCK_BREAKPOINT_CAP = 4
 
-export type { Breakpoints } from "./cache.js"
-export const breakpoints = () => newBreakpoints(BEDROCK_BREAKPOINT_CAP)
+export const breakpoints = (modelID: string) => {
+  // Substring matching also handles regional prefixes and model-bearing ARNs.
+  const short = CLAUDE_5M.some((id) => modelID.includes(id))
+  return {
+    ...newBreakpoints(BEDROCK_BREAKPOINT_CAP),
+    // Assume modern Claude releases retain caching support; older generations need an explicit exception.
+    // Other model families use implicit caching where available.
+    supported: modelID.includes("anthropic.claude-") && (short || !LEGACY_CLAUDE.some((id) => modelID.includes(id))),
+    ttl1h: !short,
+  }
+}
+export type Breakpoints = ReturnType<typeof breakpoints>
 
 const DEFAULT_5M: CachePointBlock = { cachePoint: { type: "default" } }
 const DEFAULT_1H: CachePointBlock = { cachePoint: { type: "default", ttl: "1h" } }
 
 export const block = (breakpoints: Breakpoints, cache: CacheHint | undefined): CachePointBlock | undefined => {
+  if (!breakpoints.supported) return undefined
   if (cache?.type !== "ephemeral" && cache?.type !== "persistent") return undefined
   if (breakpoints.remaining <= 0) {
     breakpoints.dropped += 1
     return undefined
   }
   breakpoints.remaining -= 1
-  return ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
+  return breakpoints.ttl1h && ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
 }
 
 export * as BedrockCache from "./bedrock-cache.js"

packages/ai/src/providers/baseten.ts

@@ -0,0 +1,60 @@
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
+
+export const id = ProviderID.make("baseten")
+const baseURL = "https://inference.baseten.co/v1"
+
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
+
+export const route = Route.make({
+  id: "baseten-chat",
+  provider: id,
+  providerMetadataKey: "baseten",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  framing: OpenAIChat.framing,
+})
+
+export const routes = [route]
+
+export const configure = (input: LanguageModelOptions = {}) => {
+  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const configured = route.with({
+    ...defaults,
+    endpoint: { baseURL: endpoint ?? baseURL },
+    auth: AuthOptions.bearer(input, "BASETEN_API_KEY"),
+  })
+  return {
+    id,
+    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
+    configure,
+  }
+}
+
+export const provider = configure()
+
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
+
+export * as Baseten from "./baseten.js"

packages/ai/src/providers/cerebras.ts

@@ -1,12 +1,13 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import type { RouteDefaultsInput } from "../route/client.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
-import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cerebras")
+const baseURL = "https://api.cerebras.ai/v1"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -20,19 +21,22 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = OpenAICompatibleChat.route.with({
+export const route = Route.make({
   id: "cerebras-chat",
   provider: id,
-  endpoint: { baseURL: profiles.cerebras.baseURL },
+  providerMetadataKey: "cerebras",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  framing: OpenAIChat.framing,
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: baseURL ?? profiles.cerebras.baseURL },
+    endpoint: { baseURL: endpoint ?? baseURL },
     auth: AuthOptions.bearer(input, "CEREBRAS_API_KEY"),
   })
   return {

packages/ai/src/providers/cloudflare-ai-gateway.ts

@@ -0,0 +1,98 @@
+import type { Config, Redacted } from "effect"
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { Auth } from "../route/auth.js"
+import type { AtLeastOne, ProviderAuthOption } from "../route/auth-options.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
+
+export const id = ProviderID.make("cloudflare-ai-gateway")
+export const authEnvVars = ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"] as const
+
+type GatewayURL = AtLeastOne<{
+  readonly accountId: string
+  readonly baseURL: string
+}> & {
+  readonly gatewayId?: string
+}
+
+export type LanguageModelOptions = GatewayURL &
+  Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
+    readonly gatewayApiKey?: string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export type Settings = ProviderPackage.Settings &
+  GatewayURL & {
+    readonly apiKey?: string
+    readonly gatewayApiKey?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export const baseURL = (input: GatewayURL) => {
+  if (input.baseURL) return input.baseURL
+  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
+  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
+}
+
+const auth = (input: LanguageModelOptions) => {
+  if ("auth" in input && input.auth) return input.auth
+  const gateway = Auth.optional(input.gatewayApiKey, "gatewayApiKey")
+    .orElse(Auth.config(authEnvVars[0]))
+    .orElse(Auth.config(authEnvVars[1]))
+    .pipe(Auth.bearerHeader("cf-aig-authorization"))
+  if (!("apiKey" in input) || input.apiKey === undefined) return gateway
+  if (input.gatewayApiKey === undefined) return Auth.bearer(input.apiKey)
+  return Auth.bearerHeader("cf-aig-authorization", input.gatewayApiKey).andThen(Auth.bearer(input.apiKey))
+}
+
+export const route = Route.make({
+  id: "cloudflare-ai-gateway",
+  provider: id,
+  providerMetadataKey: "cloudflare-ai-gateway",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions"),
+  framing: OpenAIChat.framing,
+})
+
+export const routes = [route]
+
+export const configure = (input: LanguageModelOptions) => {
+  const {
+    accountId: _accountId,
+    gatewayId: _gatewayId,
+    apiKey: _apiKey,
+    gatewayApiKey: _gatewayApiKey,
+    baseURL: _baseURL,
+    auth: _auth,
+    ...defaults
+  } = input
+  const configured = route.with({
+    ...defaults,
+    endpoint: { baseURL: baseURL(input) },
+    auth: auth(input),
+  })
+  return {
+    id,
+    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
+    configure,
+  }
+}
+
+export const provider = { id, configure }
+
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    gatewayApiKey: settings.gatewayApiKey,
+    baseURL: baseURL(settings),
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
+
+export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"

packages/ai/src/providers/cloudflare-workers-ai.ts

@@ -0,0 +1,71 @@
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
+
+export const id = ProviderID.make("cloudflare-workers-ai")
+export const authEnvVars = ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"] as const
+
+type WorkersAIURL = AtLeastOne<{
+  readonly accountId: string
+  readonly baseURL: string
+}>
+
+export type LanguageModelOptions = WorkersAIURL &
+  Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export type Settings = ProviderPackage.Settings &
+  WorkersAIURL & {
+    readonly apiKey?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export const baseURL = (input: WorkersAIURL) => {
+  if (input.baseURL) return input.baseURL
+  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
+  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
+}
+
+export const route = Route.make({
+  id: "cloudflare-workers-ai",
+  provider: id,
+  providerMetadataKey: "cloudflare-workers-ai",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions"),
+  framing: OpenAIChat.framing,
+})
+
+export const routes = [route]
+
+export const configure = (input: LanguageModelOptions) => {
+  const { accountId: _accountId, apiKey: _apiKey, auth: _auth, baseURL: _baseURL, ...defaults } = input
+  const configured = route.with({
+    ...defaults,
+    endpoint: { baseURL: baseURL(input) },
+    auth: AuthOptions.bearer(input, authEnvVars),
+  })
+  return {
+    id,
+    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
+    configure,
+  }
+}
+
+export const provider = { id, configure }
+
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    baseURL: baseURL(settings),
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
+
+export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js"

packages/ai/src/providers/cloudflare.ts

@@ -1,133 +0,0 @@
-import type { Config, Redacted } from "effect"
-import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
-import { Auth } from "../route/auth.js"
-import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
-import type { RouteDefaultsInput } from "../route/client.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const aiGatewayID = ProviderID.make("cloudflare-ai-gateway")
-export const workersAIID = ProviderID.make("cloudflare-workers-ai")
-export const aiGatewayAuthEnvVars = ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"] as const
-export const workersAIAuthEnvVars = ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"] as const
-
-type CloudflareSecret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
-
-type GatewayURL = AtLeastOne<{
-  readonly accountId: string
-  readonly baseURL: string
-}> & {
-  readonly gatewayId?: string
-}
-
-export type AIGatewayOptions = GatewayURL &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
-    readonly gatewayApiKey?: CloudflareSecret
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-type WorkersAIURL = AtLeastOne<{
-  readonly accountId: string
-  readonly baseURL: string
-}>
-
-export type WorkersAIOptions = WorkersAIURL &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export const aiGatewayBaseURL = (input: GatewayURL) => {
-  if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
-  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
-}
-
-const aiGatewayAuth = (input: AIGatewayOptions) => {
-  if ("auth" in input && input.auth) return input.auth
-  const gateway = Auth.optional(input.gatewayApiKey, "gatewayApiKey")
-    .orElse(Auth.config("CLOUDFLARE_API_TOKEN"))
-    .orElse(Auth.config("CF_AIG_TOKEN"))
-    .pipe(Auth.bearerHeader("cf-aig-authorization"))
-  if (!("apiKey" in input) || input.apiKey === undefined) return gateway
-  if (input.gatewayApiKey === undefined) return Auth.bearer(input.apiKey)
-  return Auth.bearerHeader("cf-aig-authorization", input.gatewayApiKey).andThen(Auth.bearer(input.apiKey))
-}
-
-export const workersAIBaseURL = (input: WorkersAIURL) => {
-  if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
-  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
-}
-
-const workersAIAuth = (input: WorkersAIOptions) => {
-  return AuthOptions.bearer(input, workersAIAuthEnvVars)
-}
-
-export const aiGatewayRoute = OpenAICompatibleChat.route.with({
-  id: "cloudflare-ai-gateway",
-  provider: aiGatewayID,
-})
-
-export const workersAIRoute = OpenAICompatibleChat.route.with({
-  id: "cloudflare-workers-ai",
-  provider: workersAIID,
-})
-
-export const routes = [aiGatewayRoute, workersAIRoute]
-
-const aiGatewayDefaults = (options: AIGatewayOptions) => {
-  const {
-    accountId: _accountId,
-    gatewayId: _gatewayId,
-    apiKey: _apiKey,
-    gatewayApiKey: _gatewayApiKey,
-    baseURL: _baseURL,
-    auth: _auth,
-    ...rest
-  } = options
-  return rest
-}
-
-const workersAIDefaults = (options: WorkersAIOptions) => {
-  const { accountId: _accountId, apiKey: _apiKey, auth: _auth, baseURL: _baseURL, ...rest } = options
-  return rest
-}
-
-const configureAIGateway = (options: AIGatewayOptions) => {
-  const route = aiGatewayRoute.with({
-    ...aiGatewayDefaults(options),
-    endpoint: { baseURL: aiGatewayBaseURL(options) },
-    auth: aiGatewayAuth(options),
-  })
-  return {
-    id: aiGatewayID,
-    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure: configureAIGateway,
-  }
-}
-
-const configureWorkersAI = (options: WorkersAIOptions) => {
-  const route = workersAIRoute.with({
-    ...workersAIDefaults(options),
-    endpoint: { baseURL: workersAIBaseURL(options) },
-    auth: workersAIAuth(options),
-  })
-  return {
-    id: workersAIID,
-    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure: configureWorkersAI,
-  }
-}
-
-export const CloudflareAIGateway = {
-  id: aiGatewayID,
-  configure: configureAIGateway,
-}
-
-export const CloudflareWorkersAI = {
-  id: workersAIID,
-  configure: configureWorkersAI,
-}

packages/ai/src/providers/deepinfra.ts

@@ -1,12 +1,13 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import type { RouteDefaultsInput } from "../route/client.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
-import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("deepinfra")
+const baseURL = "https://api.deepinfra.com/v1/openai"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -20,21 +21,24 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = OpenAICompatibleChat.route.with({
+export const route = Route.make({
   id: "deepinfra-chat",
   provider: id,
-  endpoint: { baseURL: profiles.deepinfra.baseURL },
+  providerMetadataKey: "deepinfra",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  framing: OpenAIChat.framing,
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
-  const root = baseURL?.replace(/\/+$/, "")
+  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const root = endpoint?.replace(/\/+$/, "")
   const configured = route.with({
     ...defaults,
     endpoint: {
-      baseURL: root === undefined ? profiles.deepinfra.baseURL : root.endsWith("/openai") ? root : `${root}/openai`,
+      baseURL: root === undefined ? baseURL : root.endsWith("/openai") ? root : `${root}/openai`,
     },
     auth: AuthOptions.bearer(input, "DEEPINFRA_API_KEY"),
   })

packages/ai/src/providers/deepseek.ts

@@ -0,0 +1,64 @@
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
+
+export const id = ProviderID.make("deepseek")
+const baseURL = "https://api.deepseek.com/v1"
+
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
+
+export const route = Route.make({
+  id: "deepseek-chat",
+  provider: id,
+  providerMetadataKey: "deepseek",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  framing: OpenAIChat.framing,
+})
+
+export const routes = [route]
+
+export const configure = (input: LanguageModelOptions = {}) => {
+  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const configured = route.with({
+    ...defaults,
+    endpoint: { baseURL: endpoint ?? baseURL },
+    auth: AuthOptions.bearer(input, "DEEPSEEK_API_KEY"),
+  })
+  return {
+    id,
+    model: (modelID: string | ModelID) =>
+      configured.model<OpenAIProviderOptionsInput>({
+        id: modelID,
+        compatibility: { maxTokensField: "max_tokens", supportsStore: false },
+      }),
+    configure,
+  }
+}
+
+export const provider = configure()
+
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
+
+export * as DeepSeek from "./deepseek.js"

packages/ai/src/providers/fireworks.ts

@@ -0,0 +1,60 @@
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
+
+export const id = ProviderID.make("fireworks")
+const baseURL = "https://api.fireworks.ai/inference/v1"
+
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
+
+export const route = Route.make({
+  id: "fireworks-chat",
+  provider: id,
+  providerMetadataKey: "fireworks",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  framing: OpenAIChat.framing,
+})
+
+export const routes = [route]
+
+export const configure = (input: LanguageModelOptions = {}) => {
+  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const configured = route.with({
+    ...defaults,
+    endpoint: { baseURL: endpoint ?? baseURL },
+    auth: AuthOptions.bearer(input, "FIREWORKS_API_KEY"),
+  })
+  return {
+    id,
+    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
+    configure,
+  }
+}
+
+export const provider = configure()
+
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
+
+export * as Fireworks from "./fireworks.js"

packages/ai/src/providers/google-vertex-chat.ts

@@ -1,6 +1,7 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
-import type { RouteDefaultsInput } from "../route/client.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
@@ -24,10 +25,13 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-const route = OpenAICompatibleChat.route.with({
+const route = Route.make({
   id: "google-vertex-chat",
   provider: id,
   providerMetadataKey: "vertex",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions"),
+  framing: OpenAIChat.framing,
 })
 
 export const routes = [route]

packages/ai/src/providers/google-vertex-responses.ts

@@ -1,6 +1,7 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js"
-import type { RouteDefaultsInput } from "../route/client.js"
+import { OpenResponses } from "../protocols/open-responses.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
@@ -24,11 +25,14 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenResponsesProviderOptionsInput
 }
 
-const route = OpenAICompatibleResponses.route.with({
+const route = Route.make({
   id: "google-vertex-responses",
   provider: id,
   providerMetadataKey: "vertex",
-  providerOptions: { store: false },
+  protocol: OpenResponses.protocol,
+  endpoint: Endpoint.path(OpenResponses.PATH),
+  transport: OpenResponses.httpTransport,
+  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })
 
 export const routes = [route]

packages/ai/src/providers/groq.ts

@@ -7,10 +7,10 @@ import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { ProviderID, type ModelID, type LLMRequest } from "../schema/index.js"
-import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("groq")
+const baseURL = "https://api.groq.com/openai/v1"
 
 export type ProviderOptions = Pick<OpenAIProviderOptionsInput, "reasoningEffort"> & {
   /** Controls visible reasoning on GPT-OSS; other models always use parsed reasoning. */
@@ -73,15 +73,15 @@ export const route = Route.make({
   provider: id,
   providerMetadataKey: "openai",
   protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: profiles.groq.baseURL }),
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
   framing: OpenAIChat.framing,
 })
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: baseURL ?? profiles.groq.baseURL },
+    endpoint: { baseURL: endpoint ?? baseURL },
     auth: AuthOptions.bearer(input, "GROQ_API_KEY"),
   })
   return {

packages/ai/src/providers/index.ts

@@ -3,10 +3,13 @@ export * as AnthropicCompatible from "./anthropic-compatible.js"
 export * as AmazonBedrock from "./amazon-bedrock.js"
 export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js"
 export * as Azure from "./azure.js"
+export * as Baseten from "./baseten.js"
 export * as Cerebras from "./cerebras.js"
-export * as Cloudflare from "./cloudflare.js"
-export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare.js"
+export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"
+export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js"
 export * as DeepInfra from "./deepinfra.js"
+export * as DeepSeek from "./deepseek.js"
+export * as Fireworks from "./fireworks.js"
 export * as Google from "./google.js"
 export * as GoogleVertex from "./google-vertex.js"
 export * as GoogleVertexChat from "./google-vertex-chat.js"

packages/ai/src/providers/openai-compatible-profile.ts

@@ -1,20 +0,0 @@
-export interface OpenAICompatibleProfile {
-  readonly provider: string
-  readonly baseURL: string
-}
-
-export const profiles = {
-  baseten: { provider: "baseten", baseURL: "https://inference.baseten.co/v1" },
-  cerebras: { provider: "cerebras", baseURL: "https://api.cerebras.ai/v1" },
-  deepinfra: { provider: "deepinfra", baseURL: "https://api.deepinfra.com/v1/openai" },
-  deepseek: { provider: "deepseek", baseURL: "https://api.deepseek.com/v1" },
-  fireworks: { provider: "fireworks", baseURL: "https://api.fireworks.ai/inference/v1" },
-  groq: { provider: "groq", baseURL: "https://api.groq.com/openai/v1" },
-  openrouter: { provider: "openrouter", baseURL: "https://openrouter.ai/api/v1" },
-  togetherai: { provider: "togetherai", baseURL: "https://api.together.xyz/v1" },
-  xai: { provider: "xai", baseURL: "https://api.x.ai/v1" },
-} as const satisfies Record<string, OpenAICompatibleProfile>
-
-export const byProvider: Record<string, OpenAICompatibleProfile> = Object.fromEntries(
-  Object.values(profiles).map((profile) => [profile.provider, profile]),
-)

packages/ai/src/providers/openai-compatible.ts

@@ -1,9 +1,8 @@
 import { ProviderID, type ModelID } from "../schema/index.js"
-import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("openai-compatible")
@@ -22,12 +21,6 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
 export const routes = [OpenAICompatibleChat.route]
 
 export const configure = (input: GenericModelOptions) => {
@@ -47,22 +40,6 @@ export const configure = (input: GenericModelOptions) => {
   }
 }
 
-const define = (profile: OpenAICompatibleProfile) => {
-  const configureProfile = (input: FamilyModelOptions = {}) => {
-    const facade = configure({
-      ...input,
-      baseURL: input.baseURL ?? profile.baseURL,
-      provider: profile.provider,
-    })
-    return {
-      id: ProviderID.make(profile.provider),
-      model: facade.model,
-      configure: configureProfile,
-    }
-  }
-  return configureProfile()
-}
-
 export const provider = {
   id,
   configure,
@@ -78,10 +55,4 @@ export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsIn
     providerOptions: settings.providerOptions,
   }).model(modelID)
 
-export const baseten = define(profiles.baseten)
-export const cerebras = define(profiles.cerebras)
-export const deepinfra = define(profiles.deepinfra)
-export const deepseek = define(profiles.deepseek)
-export const fireworks = define(profiles.fireworks)
-export const groq = define(profiles.groq)
-export const togetherai = define(profiles.togetherai)
+export * as OpenAICompatible from "./openai-compatible.js"

packages/ai/src/providers/openrouter.ts

@@ -5,13 +5,12 @@ import { Protocol } from "../route/protocol.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { ProviderID, type CacheHint, type ModelID } from "../schema/index.js"
 import type { ProviderPackage } from "../provider-package.js"
-import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
-import * as OpenAIChat from "../protocols/openai-chat.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js"
 import { isRecord } from "../protocols/shared.js"
 
-export const profile = OpenAICompatibleProfiles.profiles.openrouter
-export const id = ProviderID.make(profile.provider)
+export const id = ProviderID.make("openrouter")
+const baseURL = "https://openrouter.ai/api/v1"
 const ADAPTER = "openrouter"
 
 type OpenRouterString<Known extends string> = Known | (string & {})
@@ -162,20 +161,20 @@ const bodyOptions = (input: unknown) => {
 
 export const route = Route.make({
   id: ADAPTER,
-  provider: profile.provider,
+  provider: id,
   providerMetadataKey: "openrouter",
   protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
   framing: OpenAIChat.framing,
 })
 
 export const routes = [route]
 
 const configuredRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input
   return route.with({
     ...rest,
-    endpoint: { baseURL: baseURL ?? profile.baseURL },
+    endpoint: { baseURL: endpoint ?? baseURL },
     auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
   })
 }

packages/ai/src/providers/togetherai.ts

@@ -1,12 +1,13 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import type { RouteDefaultsInput } from "../route/client.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
-import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("togetherai")
+const baseURL = "https://api.together.xyz/v1"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -20,19 +21,22 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = OpenAICompatibleChat.route.with({
+export const route = Route.make({
   id: "togetherai-chat",
   provider: id,
-  endpoint: { baseURL: profiles.togetherai.baseURL },
+  providerMetadataKey: "togetherai",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  framing: OpenAIChat.framing,
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: baseURL ?? profiles.togetherai.baseURL },
+    endpoint: { baseURL: endpoint ?? baseURL },
     auth: AuthOptions.bearer(input, ["TOGETHER_API_KEY", "TOGETHER_AI_API_KEY"]),
   })
   return {

packages/ai/src/providers/xai.ts

@@ -2,9 +2,7 @@ import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
-import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
-import * as OpenAIChat from "../protocols/openai-chat.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
 import { OpenResponsesChannel } from "../protocols/open-responses-channel.js"
 import { XAIResponses } from "../protocols/xai-responses.js"
 import { XAIImages } from "../protocols/xai-images.js"
@@ -12,6 +10,7 @@ import type { OpenAIOptionsInput } from "./openai-options.js"
 import type { ProviderPackage } from "../provider-package.js"
 
 export const id = ProviderID.make("xai")
+const baseURL = "https://api.x.ai/v1"
 
 export type XAIProviderOptionsInput = OpenAIOptionsInput & { readonly contextManagement?: never }
 
@@ -37,7 +36,7 @@ const responsesRoute = Route.make({
   provider: id,
   providerMetadataKey: "xai",
   protocol: XAIResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
+  endpoint: Endpoint.path("/responses", { baseURL }),
   transport: OpenResponsesChannel.transport({
     id: "openai-responses",
     name: "xAI Responses",
@@ -51,8 +50,8 @@ const chatRoute = Route.make({
   provider: id,
   providerMetadataKey: "xai",
   protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-  transport: OpenAICompatibleChat.route.transport,
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  framing: OpenAIChat.framing,
   headers: ({ request }): Record<string, string> =>
     request.promptCacheKey ? { "x-grok-conv-id": request.promptCacheKey } : {},
 })
@@ -62,19 +61,19 @@ export const routes = [responsesRoute, chatRoute]
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "XAI_API_KEY")
 
 const configuredResponsesRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input
   return responsesRoute.with({
     ...rest,
-    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
+    endpoint: { baseURL: endpoint ?? baseURL },
     auth: auth(input),
   })
 }
 
 const configuredChatRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input
   return chatRoute.with({
     ...rest,
-    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
+    endpoint: { baseURL: endpoint ?? baseURL },
     auth: auth(input),
   })
 }
@@ -88,7 +87,7 @@ export const configure = (input: LanguageModelOptions = {}) => {
     XAIImages.model({
       id: modelID,
       auth: auth(input),
-      baseURL: input.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
+      baseURL: input.baseURL ?? baseURL,
       headers: input.headers,
       http: input.http === undefined ? undefined : HttpOptions.make(input.http),
     })

packages/ai/test/auth-options.types.ts

@@ -6,7 +6,8 @@ import * as AmazonBedrock from "../src/providers/amazon-bedrock.js"
 import * as Anthropic from "../src/providers/anthropic.js"
 import * as AnthropicCompatible from "../src/providers/anthropic-compatible.js"
 import * as Azure from "../src/providers/azure.js"
-import * as Cloudflare from "../src/providers/cloudflare.js"
+import { CloudflareWorkersAI } from "../src/providers/cloudflare-workers-ai.js"
+import { DeepSeek } from "../src/providers/deepseek.js"
 import * as Google from "../src/providers/google.js"
 import * as GoogleVertex from "../src/providers/google-vertex.js"
 import * as GoogleVertexChat from "../src/providers/google-vertex-chat.js"
@@ -263,10 +264,10 @@ XAI.configure({ apiKey: "xai-key" }).responses("grok-4", {})
 // @ts-expect-error xAI Chat selectors only accept model ids.
 XAI.configure({ apiKey: "xai-key" }).chat("grok-4", {})
 
-OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat")
+DeepSeek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat")
 // @ts-expect-error OpenAI-compatible family selectors only accept model ids.
-OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat", {})
+DeepSeek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat", {})
 
-Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama")
+CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama")
 // @ts-expect-error Cloudflare Workers AI model selectors only accept model ids.
-Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama", {})
+CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama", {})

packages/ai/test/exports.test.ts

@@ -3,8 +3,11 @@ import { AIError, ImageInput, LanguageModel, LLM, LLMClient, Provider } from "@o
 import { Route, Protocol, WebSocketTransport } from "@opencode-ai/ai/route"
 import { Provider as ProviderSubpath } from "@opencode-ai/ai/provider"
 import {
+  Baseten,
   CloudflareAIGateway,
   CloudflareWorkersAI,
+  DeepSeek,
+  Fireworks,
   OpenAI,
   OpenAICompatible,
   OpenRouter,
@@ -48,7 +51,13 @@ describe("public exports", () => {
     expect(OpenAI.model).toBeFunction()
     expect(OpenAI.provider.responses).toBe(OpenAI.responses)
     expect(OpenAI.configure({ apiKey: "fixture" }).responses).toBeFunction()
-    expect(OpenAICompatible.deepseek.model).toBeFunction()
+    for (const provider of [Baseten, DeepSeek, Fireworks]) {
+      expect(provider.configure).toBeFunction()
+      expect(provider.model).toBeFunction()
+    }
+    for (const name of ["baseten", "cerebras", "deepinfra", "deepseek", "fireworks", "groq", "togetherai"]) {
+      expect(OpenAICompatible).not.toHaveProperty(name)
+    }
     expect(
       OpenAICompatibleResponses.configure({ baseURL: "https://responses.test/v1" }).model("fixture").route.id,
     ).toBe("openai-compatible-responses")

packages/ai/test/provider-options/openai-compatible.types.ts

@@ -1,7 +1,7 @@
 import { LLM } from "../../src/index.js"
 import { OpenAICompatible } from "../../src/providers.js"
 
-const model = OpenAICompatible.deepseek.model("deepseek-chat")
+const model = OpenAICompatible.configure({ baseURL: "https://compatible.example/v1" }).model("test-model")
 
 LLM.request({ model, prompt: "Hello", providerOptions: { store: false } })
 

packages/ai/test/provider-package.test.ts

@@ -32,6 +32,11 @@ describe("provider package entrypoints", () => {
       import("@opencode-ai/ai/providers/cerebras"),
       import("@opencode-ai/ai/providers/deepinfra"),
       import("@opencode-ai/ai/providers/groq"),
+      import("@opencode-ai/ai/providers/baseten"),
+      import("@opencode-ai/ai/providers/deepseek"),
+      import("@opencode-ai/ai/providers/fireworks"),
+      import("@opencode-ai/ai/providers/cloudflare-ai-gateway"),
+      import("@opencode-ai/ai/providers/cloudflare-workers-ai"),
     ])
 
     for (const module of modules) expect(module.model).toBeFunction()
@@ -60,6 +65,27 @@ describe("provider package entrypoints", () => {
     expect(deepinfra.route.defaults.http?.body).toEqual(settings.body)
   })
 
+  test("maps Cloudflare package settings onto provider-owned models", async () => {
+    const modules = await Promise.all([
+      import("@opencode-ai/ai/providers/cloudflare-ai-gateway"),
+      import("@opencode-ai/ai/providers/cloudflare-workers-ai"),
+    ])
+    for (const provider of modules) {
+      const selected = provider.model("provider-model", {
+        accountId: "account",
+        apiKey: "fixture",
+        headers: { "x-application": "opencode" },
+        body: { custom: true },
+        providerOptions: { reasoningEffort: "high" },
+      })
+      expect(selected.provider).toBe(provider.id)
+      expect(selected.route.endpoint.baseURL).toBe(provider.baseURL({ accountId: "account" }))
+      expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
+      expect(selected.route.defaults.http?.body).toEqual({ custom: true })
+      expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" })
+    }
+  })
+
   test("maps OpenRouter and xAI package settings onto executable models", async () => {
     const OpenRouter = await import("@opencode-ai/ai/providers/openrouter")
     const XAI = await import("@opencode-ai/ai/providers/xai")

packages/ai/test/provider/bedrock-converse-cache.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { CacheHint, LLM, Message, ToolCallPart } from "../../src/index.js"
+import { AmazonBedrock } from "../../src/providers.js"
+import { compileRequest } from "../../src/route/client.js"
+import { it } from "../lib/effect.js"
+
+const bedrock = AmazonBedrock.configure({ apiKey: "fixture" })
+
+describe("Bedrock Converse cache policy", () => {
+  for (const id of [
+    "deepseek.r1-v1:0",
+    "meta.llama3-3-70b-instruct-v1:0",
+    "mistral.mistral-large-2402-v1:0",
+    "qwen.qwen3-coder-480b-a35b-v1:0",
+    "openai.gpt-oss-120b-1:0",
+    "cohere.command-r-v1:0",
+    "anthropic.claude-instant-v1",
+    "anthropic.claude-v1",
+    "anthropic.claude-v2",
+    "anthropic.claude-v2:1",
+    "anthropic.claude-3-haiku-20240307-v1:0",
+    "anthropic.claude-3-sonnet-20240229-v1:0",
+    "anthropic.claude-3-opus-20240229-v1:0",
+    "anthropic.claude-3-5-sonnet-20240620-v1:0",
+    "amazon.nova-lite-v1:0",
+    "global.amazon.nova-2-lite-v1:0",
+    "custom-model",
+    "arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/abc123",
+  ]) {
+    for (const policy of [undefined, "auto", "none", { tools: true, system: true, messages: { tail: 3 } }] as const) {
+      it.effect(`omits checkpoints for ${id} (${JSON.stringify(policy)})`, () =>
+        Effect.gen(function* () {
+          // Exercise both automatic placement and manual hints at every lowering site.
+          const cache = policy === "none" ? new CacheHint({ type: "ephemeral", ttlSeconds: 3600 }) : undefined
+          const prepared = yield* compileRequest(
+            LLM.request({
+              model: bedrock.model(id),
+              cache: policy,
+              system: [{ type: "text", text: "System prefix", cache }],
+              tools: [{ name: "lookup", description: "Lookup", inputSchema: { type: "object" }, cache }],
+              messages: [
+                Message.user([{ type: "text", text: "Question", cache }]),
+                Message.system([{ type: "text", text: "Update", cache }]),
+                Message.assistant([
+                  { type: "text", text: "Answer", cache },
+                  { type: "reasoning", text: "Unsigned reasoning", cache },
+                  ToolCallPart.make({ id: "call_1", name: "lookup", input: {} }),
+                ]),
+                Message.tool({ id: "call_1", name: "lookup", result: "Result", cache }),
+              ],
+            }),
+          )
+
+          expect(JSON.stringify(prepared.body)).not.toContain("cachePoint")
+          expect(prepared.body).toMatchObject({
+            modelId: id,
+            system: [{ text: "System prefix" }],
+            toolConfig: { tools: [{ toolSpec: { name: "lookup" } }] },
+            messages: [
+              { role: "user", content: [{ text: "Question" }, { text: "<system-update>\nUpdate\n</system-update>" }] },
+              {
+                role: "assistant",
+                content: [{ text: "Answer" }, { text: "Unsigned reasoning" }, { toolUse: { name: "lookup" } }],
+              },
+              { role: "user", content: [{ toolResult: { content: [{ json: "Result" }] } }] },
+            ],
+          })
+        }),
+      )
+    }
+  }
+
+  for (const [id, ttl] of [
+    ["anthropic.claude-3-5-sonnet-20241022-v2:0", undefined],
+    ["us.anthropic.claude-3-5-haiku-20241022-v1:0", undefined],
+    ["eu.anthropic.claude-3-7-sonnet-20250219-v1:0", undefined],
+    ["apac.anthropic.claude-sonnet-4-20250514-v1:0", undefined],
+    ["anthropic.claude-opus-4-20250514-v1:0", undefined],
+    ["anthropic.claude-opus-4-1-20250805-v1:0", undefined],
+    ["anthropic.claude-sonnet-4-5-20250929-v1:0", "1h"],
+    ["global.anthropic.claude-sonnet-99", "1h"],
+    ["anthropic.claude-new-family-99", "1h"],
+    ["arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-6", "1h"],
+    ["arn:aws:bedrock:us-east-1:123456789012:inference-profile/us.anthropic.claude-sonnet-4-6", "1h"],
+  ] as const) {
+    for (const ttlSeconds of [undefined, 3600]) {
+      it.effect(`preserves Claude checkpoints for ${id} (TTL: ${ttlSeconds ?? "default"})`, () =>
+        Effect.gen(function* () {
+          const prepared = yield* compileRequest(
+            LLM.request({
+              model: bedrock.model(id),
+              system: [
+                { type: "text", text: "Agent" },
+                { type: "text", text: "Project" },
+              ],
+              tools: [{ name: "lookup", description: "Lookup", inputSchema: { type: "object" } }],
+              prompt: "Question",
+              cache:
+                ttlSeconds === undefined ? undefined : { tools: true, system: true, messages: { tail: 1 }, ttlSeconds },
+            }),
+          )
+          const marker = {
+            cachePoint: ttlSeconds === undefined || ttl === undefined ? { type: "default" } : { type: "default", ttl },
+          }
+
+          expect(prepared.body).toMatchObject({
+            modelId: id,
+            toolConfig: { tools: [{ toolSpec: { name: "lookup" } }, marker] },
+            system: [{ text: "Agent" }, marker, { text: "Project" }, marker],
+            messages: [{ role: "user", content: [{ text: "Question" }, marker] }],
+          })
+          if (ttlSeconds === undefined || ttl === undefined)
+            expect(JSON.stringify(prepared.body)).not.toContain('"ttl"')
+        }),
+      )
+    }
+  }
+})

packages/ai/test/provider/bedrock-converse.test.ts

@@ -136,7 +136,7 @@ const captureHeaders = (target: LanguageModel) =>
 const model = AmazonBedrock.configure({
   baseURL: "https://bedrock-runtime.test",
   apiKey: "test-bearer",
-}).model("anthropic.claude-3-5-sonnet-20240620-v1:0")
+}).model("anthropic.claude-sonnet-4-5-20250929-v1:0")
 
 const baseRequest = LLM.request({
   id: "req_1",
@@ -155,7 +155,7 @@ describe("Bedrock Converse route", () => {
       const prepared = yield* compileRequest(baseRequest)
 
       expect(prepared.body).toEqual({
-        modelId: "anthropic.claude-3-5-sonnet-20240620-v1:0",
+        modelId: "anthropic.claude-sonnet-4-5-20250929-v1:0",
         system: [{ text: "You are concise." }],
         messages: [{ role: "user", content: [{ text: "Say hello." }] }],
         inferenceConfig: { maxTokens: 64, temperature: 0 },

packages/ai/test/provider/cloudflare.test.ts

@@ -2,7 +2,8 @@ import { describe, expect, test } from "bun:test"
 import { ConfigProvider, Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMEvent } from "../../src/index.js"
-import { CloudflareAIGateway, CloudflareWorkersAI } from "../../src/providers/cloudflare.js"
+import { CloudflareAIGateway } from "../../src/providers/cloudflare-ai-gateway.js"
+import { CloudflareWorkersAI } from "../../src/providers/cloudflare-workers-ai.js"
 import { compileRequest } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
 import { dynamicResponse } from "../lib/http.js"

packages/ai/test/provider/gemini.test.ts

@@ -1643,19 +1643,14 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("maps current blocking and invalid-output finish reasons", () =>
+  it.effect("preserves blocking finishes and rejects invalid-output finish reasons", () =>
     Effect.gen(function* () {
       const reasons = [
         ["MODEL_ARMOR", "content-filter"],
         ["IMAGE_PROHIBITED_CONTENT", "content-filter"],
         ["IMAGE_RECITATION", "content-filter"],
         ["LANGUAGE", "content-filter"],
-        ["UNEXPECTED_TOOL_CALL", "error"],
-        ["NO_IMAGE", "error"],
         ["IMAGE_OTHER", "unknown"],
-        ["TOO_MANY_TOOL_CALLS", "error"],
-        ["MISSING_THOUGHT_SIGNATURE", "error"],
-        ["MALFORMED_RESPONSE", "error"],
       ] as const
 
       for (const [raw, normalized] of reasons) {
@@ -1666,6 +1661,26 @@ describe("Gemini route", () => {
         )
         expect(response.finishReason).toEqual({ normalized, raw })
       }
+
+      for (const raw of [
+        "MALFORMED_FUNCTION_CALL",
+        "UNEXPECTED_TOOL_CALL",
+        "NO_IMAGE",
+        "TOO_MANY_TOOL_CALLS",
+        "MISSING_THOUGHT_SIGNATURE",
+        "MALFORMED_RESPONSE",
+      ]) {
+        const event = { candidates: [{ finishReason: raw, finishMessage: "Provider detail" }], responseId: "failure" }
+        const error = yield* LLMClient.generate(request).pipe(
+          Effect.provide(fixedResponse(sseEvents(event))),
+          Effect.flip,
+        )
+        expect(error).toMatchObject({
+          _tag: "AI.Error",
+          reason: { _tag: "InvalidProviderOutput", body: JSON.stringify(event), http: { status: 200 } },
+          message: `Gemini stopped with ${raw}`,
+        })
+      }
     }),
   )
 

packages/ai/test/provider/golden.recorded.test.ts

@@ -1,7 +1,13 @@
 import * as Anthropic from "../../src/providers/anthropic.js"
 import * as AnthropicCompatible from "../../src/providers/anthropic-compatible.js"
-import { Cerebras, DeepInfra, TogetherAI } from "../../src/providers/index.js"
-import { CloudflareAIGateway, CloudflareWorkersAI } from "../../src/providers/cloudflare.js"
+import {
+  Cerebras,
+  CloudflareAIGateway,
+  CloudflareWorkersAI,
+  DeepInfra,
+  DeepSeek,
+  TogetherAI,
+} from "../../src/providers/index.js"
 import * as Google from "../../src/providers/google.js"
 import * as OpenAI from "../../src/providers/openai.js"
 import * as OpenAICompatible from "../../src/providers/openai-compatible.js"
@@ -45,16 +51,18 @@ const cloudflareAIGatewayWorkers = cloudflareAIGateway.model("workers-ai/@cf/met
 const cloudflareAIGatewayWorkersTools = cloudflareAIGateway.model("workers-ai/@cf/openai/gpt-oss-20b")
 const cloudflareWorkersAI = cloudflareWorkers.model("@cf/meta/llama-3.1-8b-instruct")
 const cloudflareWorkersAITools = cloudflareWorkers.model("@cf/openai/gpt-oss-20b")
-const deepseek = OpenAICompatible.deepseek
-  .configure({ apiKey: process.env.DEEPSEEK_API_KEY ?? "fixture" })
-  .model("deepseek-chat")
+const deepseek = DeepSeek.configure({ apiKey: process.env.DEEPSEEK_API_KEY ?? "fixture" }).model("deepseek-chat")
 const together = TogetherAI.configure({
   apiKey: process.env.TOGETHER_API_KEY ?? process.env.TOGETHER_AI_API_KEY ?? "fixture",
 }).model("meta-llama/Llama-3.3-70B-Instruct-Turbo")
 const cerebras = Cerebras.configure({ apiKey: process.env.CEREBRAS_API_KEY ?? "fixture" }).model("gpt-oss-120b")
-const groq = OpenAICompatible.groq
-  .configure({ apiKey: process.env.GROQ_API_KEY ?? "fixture" })
-  .model("llama-3.3-70b-versatile")
+// These older cassettes exercise generic Chat compatibility. Native Groq request
+// shaping and reasoning are covered by groq.recorded.test.ts.
+const groq = OpenAICompatible.configure({
+  provider: "groq",
+  baseURL: "https://api.groq.com/openai/v1",
+  apiKey: process.env.GROQ_API_KEY ?? "fixture",
+}).model("llama-3.3-70b-versatile")
 const deepInfra = DeepInfra.configure({ apiKey: process.env.DEEPINFRA_API_KEY ?? "fixture" }).model(
   "meta-llama/Llama-3.3-70B-Instruct-Turbo",
 )

packages/ai/test/provider/mistral-chat.test.ts

@@ -600,7 +600,6 @@ describe("Mistral Chat", () => {
         ["stop", "stop"],
         ["model_length", "length"],
         ["tool_calls", "tool-calls"],
-        ["error", "error"],
         ["future_reason", "unknown"],
       ] as const) {
         const response = yield* LLMClient.generate(request).pipe(
@@ -609,6 +608,22 @@ describe("Mistral Chat", () => {
         expect(response.finishReason).toEqual({ normalized, raw })
       }
 
+      for (const [raw, tag] of [
+        ["error", "UnknownProvider"],
+        ["network_error", "ProviderInternal"],
+      ] as const) {
+        const event = { ...chunk({}, raw), diagnostics: { trace: "failure" } }
+        const error = yield* LLMClient.generate(request).pipe(
+          Effect.provide(fixedResponse(sseEvents(event))),
+          Effect.flip,
+        )
+        expect(error).toMatchObject({
+          _tag: "AI.Error",
+          reason: { _tag: tag, body: JSON.stringify(event), http: { status: 200 } },
+          message: `Mistral Chat stopped with ${raw}`,
+        })
+      }
+
       const truncated = yield* LLMClient.generate(request).pipe(
         Effect.provide(
           fixedResponse(

packages/ai/test/provider/native-providers.test.ts

@@ -8,10 +8,13 @@ import {
   Anthropic,
   AnthropicCompatible,
   Azure,
+  Baseten,
   Cerebras,
   CloudflareAIGateway,
   CloudflareWorkersAI,
   DeepInfra,
+  DeepSeek,
+  Fireworks,
   Google,
   GoogleVertex,
   GoogleVertexChat,
@@ -57,6 +60,9 @@ describe("native OpenAI-compatible providers", () => {
         "custom",
       ],
       [Cerebras.configure({ apiKey: "test" }).model("model"), "cerebras"],
+      [Baseten.configure({ apiKey: "test" }).model("model"), "baseten"],
+      [DeepSeek.configure({ apiKey: "test" }).model("model"), "deepseek"],
+      [Fireworks.configure({ apiKey: "test" }).model("model"), "fireworks"],
       [DeepInfra.configure({ apiKey: "test" }).model("model"), "deepinfra"],
       [TogetherAI.configure({ apiKey: "test" }).model("model"), "togetherai"],
       [CloudflareAIGateway.configure({ accountId: "account" }).model("model"), "cloudflare-ai-gateway"],
@@ -87,6 +93,36 @@ describe("native OpenAI-compatible providers", () => {
     expect(cerebras.route.endpoint.baseURL).toBe("https://api.cerebras.ai/v1")
   })
 
+  it.effect("preserves extracted providers' Chat requests and identity through custom endpoints", () =>
+    Effect.gen(function* () {
+      for (const provider of [Baseten, DeepSeek, Fireworks]) {
+        const settings = {
+          apiKey: "fixture",
+          baseURL: "https://gateway.example/v1",
+          providerOptions: { reasoningEffort: "high" },
+        }
+        const selected = provider.configure(settings).model("test-model")
+        expect(selected.provider).toBe(provider.id)
+        expect(selected.route.id).toBe(`${provider.id}-chat`)
+        expect(selected.route.protocol).toBe("openai-chat")
+        expect(selected.route.endpoint.baseURL).toBe(settings.baseURL)
+        const input = {
+          prompt: "Use a tool.",
+          generation: { maxTokens: 48 },
+          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        }
+        const native = yield* compileRequest(LLM.request({ ...input, model: selected }))
+        const generic = yield* compileRequest(
+          LLM.request({
+            ...input,
+            model: OpenAICompatible.configure({ ...settings, provider: provider.id }).model("test-model"),
+          }),
+        )
+        expect(native.body).toEqual(generic.body)
+      }
+    }),
+  )
+
   test("preserves native DeepInfra provider and route identity", () => {
     const deepinfra = DeepInfra.configure({ apiKey: "fixture" }).model("google/gemma-3-27b-it")
     expect(deepinfra).toMatchObject({
@@ -164,7 +200,7 @@ describe("native OpenAI-compatible providers", () => {
   })
 
   test("maps package settings onto native executable models", () => {
-    for (const native of [TogetherAI, Cerebras]) {
+    for (const native of [Baseten, Cerebras, DeepSeek, Fireworks, TogetherAI]) {
       const selected = native.model("provider-model", {
         apiKey: "fixture",
         baseURL: "https://gateway.example/v1",
@@ -183,6 +219,24 @@ describe("native OpenAI-compatible providers", () => {
   it.effect("resolves provider environment credentials and preserves deprecated Together credentials", () =>
     Effect.gen(function* () {
       const scenarios = [
+        {
+          model: Baseten.configure().model("model"),
+          env: { BASETEN_API_KEY: "baseten-secret" },
+          token: "baseten-secret",
+          url: "https://inference.baseten.co/v1/chat/completions",
+        },
+        {
+          model: DeepSeek.configure().model("deepseek-chat"),
+          env: { DEEPSEEK_API_KEY: "deepseek-secret" },
+          token: "deepseek-secret",
+          url: "https://api.deepseek.com/v1/chat/completions",
+        },
+        {
+          model: Fireworks.configure().model("model"),
+          env: { FIREWORKS_API_KEY: "fireworks-secret" },
+          token: "fireworks-secret",
+          url: "https://api.fireworks.ai/inference/v1/chat/completions",
+        },
         {
           model: TogetherAI.configure().model("llama"),
           env: { TOGETHER_API_KEY: "together-primary", TOGETHER_AI_API_KEY: "together-legacy" },

packages/ai/test/provider/openai-compatible-chat.test.ts

@@ -4,7 +4,6 @@ import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMRequest, Message, ToolCallPart, ToolChoice, ToolDefinition } from "../../src/index.js"
 import { Auth, LLMClient } from "../../src/route.js"
 import { compileRequest } from "../../src/route/client.js"
-import * as OpenAICompatible from "../../src/providers/openai-compatible.js"
 import * as OpenAICompatibleChat from "../../src/protocols/openai-compatible-chat.js"
 import { it } from "../lib/effect.js"
 import { dynamicResponse, fixedResponse } from "../lib/http.js"
@@ -41,15 +40,6 @@ const usageChunk = (usage: object) => ({
   usage,
 })
 
-const providerFamilies = [
-  ["baseten", OpenAICompatible.baseten, "https://inference.baseten.co/v1"],
-  ["cerebras", OpenAICompatible.cerebras, "https://api.cerebras.ai/v1"],
-  ["deepinfra", OpenAICompatible.deepinfra, "https://api.deepinfra.com/v1/openai"],
-  ["deepseek", OpenAICompatible.deepseek, "https://api.deepseek.com/v1"],
-  ["fireworks", OpenAICompatible.fireworks, "https://api.fireworks.ai/inference/v1"],
-  ["togetherai", OpenAICompatible.togetherai, "https://api.together.xyz/v1"],
-] as const
-
 describe("OpenAI-compatible Chat route", () => {
   it.effect("prepares generic Chat target", () =>
     Effect.gen(function* () {
@@ -91,39 +81,6 @@ describe("OpenAI-compatible Chat route", () => {
     }),
   )
 
-  test("provides model helpers for compatible provider families", () => {
-    expect(
-      providerFamilies.map(([provider, family]) => {
-        const model = family.configure({ apiKey: "test-key" }).model(`${provider}-model`)
-        return {
-          id: String(model.id),
-          provider: String(model.provider),
-          route: model.route.id,
-          baseURL: model.route.endpoint.baseURL,
-        }
-      }),
-    ).toEqual(
-      providerFamilies.map(([provider, _, baseURL]) => ({
-        id: `${provider}-model`,
-        provider,
-        route: "openai-compatible-chat",
-        baseURL,
-      })),
-    )
-
-    const custom = OpenAICompatible.deepseek
-      .configure({
-        apiKey: "test-key",
-        baseURL: "https://custom.deepseek.test/v1",
-      })
-      .model("deepseek-chat")
-    expect(custom).toMatchObject({
-      provider: "deepseek",
-      route: { id: "openai-compatible-chat" },
-    })
-    expect(custom.route.endpoint.baseURL).toBe("https://custom.deepseek.test/v1")
-  })
-
   it.effect("matches AI SDK compatible basic request body fixture", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(request)

packages/app/component-tests/timeline-detail.spec.ts

@@ -0,0 +1,264 @@
+import { expect, story } from "../../storybook/playwright/story"
+
+story("maps grouped and collapsed switches to the timeline settings", async ({ mount }) => {
+  const component = await mount("settings-timeline-detail--interactive")
+  await component.getByRole("button", { name: "Advanced", exact: true }).click()
+  const shell = component.getByRole("group", { name: "Shell", exact: true })
+  const grouped = shell.getByRole("switch", { name: "Shell grouped", exact: true })
+  const collapsed = shell.getByRole("switch", { name: "Shell collapsed", exact: true })
+  const value = component.locator('[data-slot="timeline-detail-fixture-value"]')
+
+  await expect(component.getByRole("switch")).toHaveCount(9)
+  await expect(component.getByText("Activity", { exact: true })).toHaveCount(0)
+  await expect(grouped).toBeChecked()
+  await expect(collapsed).toBeChecked()
+  await shell.locator('[data-field="placement"] [data-slot="switch-control"]').click()
+  await shell.locator('[data-field="details"] [data-slot="switch-control"]').click()
+  await expect(value).toContainText('"shell":{"placement":"separate","details":"expanded"}')
+  await grouped.focus()
+  await grouped.press("Space")
+  await collapsed.focus()
+  await collapsed.press("Space")
+  await expect(value).toContainText('"shell":{"placement":"grouped","details":"collapsed"}')
+  await expect(component.getByRole("group", { name: "Subagents", exact: true }).getByRole("switch")).toHaveCount(1)
+})
+
+story("replaces hidden switches with solid lines and restores options", async ({ mount, page }) => {
+  const component = await mount("settings-timeline-detail--interactive")
+  await component.getByRole("button", { name: "Advanced", exact: true }).click()
+  const shell = component.getByRole("group", { name: "Shell", exact: true })
+  const visibility = shell.getByRole("button", { name: "Shell visibility" })
+  const label = shell.locator('[data-slot="timeline-detail-activity"] > label')
+  const color = await label.evaluate((element) => getComputedStyle(element).color)
+  const iconColor = await visibility.evaluate((element) => getComputedStyle(element).color)
+  await shell.locator('[data-field="placement"] [data-slot="switch-control"]').click()
+  await shell.locator('[data-field="details"] [data-slot="switch-control"]').click()
+  await visibility.hover()
+  await expect(page.getByRole("tooltip")).toHaveText("Hide")
+  expect(await page.getByRole("tooltip").evaluate((element) => element.getBoundingClientRect().bottom)).toBeLessThan(
+    await visibility.evaluate((element) => element.getBoundingClientRect().top),
+  )
+  await visibility.click()
+
+  await expect(visibility).toHaveAttribute("aria-pressed", "false")
+  await expect(shell.getByRole("switch")).toHaveCount(0)
+  await expect(shell.locator('[data-slot="timeline-detail-unavailable"]')).toHaveCount(2)
+  await expect(shell.locator('[data-slot="timeline-detail-unavailable"]').first()).toHaveCSS(
+    "border-top-style",
+    "solid",
+  )
+  await expect(component.locator('[data-slot="timeline-detail-fixture-value"]')).toContainText(
+    '"shell":{"placement":"hidden","details":"expanded"}',
+  )
+  await expect(label).not.toHaveCSS("color", color)
+  await expect(visibility.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-outline-eye-slash")
+  await component.getByRole("button", { name: "Advanced", exact: true }).hover()
+  await expect(visibility).not.toHaveCSS("color", iconColor)
+  await expect(shell.locator('[data-slot="timeline-detail-unavailable"]').first()).toHaveCSS(
+    "border-top-color",
+    await visibility.evaluate((element) => getComputedStyle(element).color),
+  )
+  await visibility.hover()
+  await expect(page.getByRole("tooltip")).toHaveText("Show")
+  expect(await page.getByRole("tooltip").evaluate((element) => element.getBoundingClientRect().bottom)).toBeLessThan(
+    await visibility.evaluate((element) => element.getBoundingClientRect().top),
+  )
+  await visibility.click()
+
+  await expect(visibility).toHaveAttribute("aria-pressed", "true")
+  await expect(label).toHaveCSS("color", color)
+  await expect(visibility.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-outline-eye")
+  await expect(shell.locator('[data-slot="timeline-detail-unavailable"]')).toHaveCount(0)
+  await expect(shell.getByRole("switch", { name: "Shell grouped", exact: true })).toBeEnabled()
+  await expect(shell.getByRole("switch", { name: "Shell collapsed", exact: true })).toBeEnabled()
+  await expect(shell.getByRole("switch", { name: "Shell grouped", exact: true })).not.toBeChecked()
+  await expect(shell.getByRole("switch", { name: "Shell collapsed", exact: true })).not.toBeChecked()
+})
+
+story("toggles visibility by clicking the activity label", async ({ mount }) => {
+  const component = await mount("settings-timeline-detail--interactive")
+  await component.getByRole("button", { name: "Advanced", exact: true }).click()
+  const shell = component.getByRole("group", { name: "Shell", exact: true })
+  const label = shell.locator('[data-slot="timeline-detail-activity"] > label')
+  const visibility = shell.getByRole("button", { name: "Shell visibility" })
+
+  await expect(label).toHaveCSS("cursor", "default")
+  await label.click()
+  await expect(visibility).toHaveAttribute("aria-pressed", "false")
+  await expect(shell.getByRole("switch")).toHaveCount(0)
+  await expect(shell.locator('[data-slot="timeline-detail-unavailable"]')).toHaveCount(2)
+  await label.click()
+  await expect(visibility).toHaveAttribute("aria-pressed", "true")
+  await expect(shell.getByRole("switch", { name: "Shell grouped", exact: true })).toBeChecked()
+  await expect(shell.getByRole("switch", { name: "Shell collapsed", exact: true })).toBeChecked()
+})
+
+story("only highlights the eye when hovering the icon, not its activity label", async ({ mount }) => {
+  const component = await mount("settings-timeline-detail--interactive")
+  await component.getByRole("button", { name: "Advanced", exact: true }).click()
+  const shell = component.getByRole("group", { name: "Shell", exact: true })
+  const visibility = shell.getByRole("button", { name: "Shell visibility" })
+  const label = shell.locator('[data-slot="timeline-detail-activity"] > label')
+
+  for (const hidden of [false, true]) {
+    if (hidden) await label.click()
+    await visibility.hover()
+    await expect(visibility).not.toHaveCSS("background-color", "rgba(0, 0, 0, 0)")
+    await label.hover()
+    await expect(visibility).toHaveCSS("background-color", "rgba(0, 0, 0, 0)")
+  }
+})
+
+story("opens advanced on returning to custom settings but not presets", async ({ mount }) => {
+  const component = await mount("settings-timeline-detail--interactive")
+  const advanced = component.getByRole("button", { name: "Advanced", exact: true })
+  await expect(advanced).toHaveAttribute("aria-expanded", "false")
+  await advanced.click()
+  await component.locator('[data-category="shell"][data-field="placement"] [data-slot="switch-control"]').click()
+  await expect(component.getByRole("slider")).toHaveAttribute("aria-valuetext", "Custom")
+  await advanced.click()
+  await expect(advanced).toHaveAttribute("aria-expanded", "false")
+  await component.getByRole("button", { name: "Leave settings" }).click()
+  await expect(advanced).toHaveCount(0)
+  await component.getByRole("button", { name: "Return to settings" }).click()
+  await expect(advanced).toHaveAttribute("aria-expanded", "true")
+  await expect(component.getByRole("switch", { name: "Shell grouped", exact: true })).not.toBeChecked()
+
+  await component.getByRole("slider").press("End")
+  await expect(component.getByRole("slider")).toHaveAttribute("aria-valuetext", "Everything")
+  await component.getByRole("button", { name: "Leave settings" }).click()
+  await component.getByRole("button", { name: "Return to settings" }).click()
+  await expect(advanced).toHaveAttribute("aria-expanded", "false")
+})
+
+story("keeps visibility and switches in sync with the preset slider", async ({ mount }) => {
+  const component = await mount("settings-timeline-detail--interactive")
+  await component.getByRole("button", { name: "Advanced", exact: true }).click()
+  const slider = component.getByRole("slider", { name: "Timeline detail" })
+  await slider.focus()
+  await slider.press("Home")
+  await expect(slider).toHaveAttribute("aria-valuetext", "Messages only")
+  await expect(component.getByRole("switch")).toHaveCount(0)
+  await expect(component.locator('[data-slot="timeline-detail-unavailable"]')).toHaveCount(9)
+  await expect(component.locator('[data-action="timeline-detail-visibility"][aria-pressed="false"]')).toHaveCount(6)
+  await component.getByRole("button", { name: "Shell visibility" }).click()
+  await expect(component.getByRole("switch", { name: "Shell grouped", exact: true })).toBeChecked()
+  await expect(slider).toHaveAttribute("aria-valuetext", "Custom")
+  await slider.focus()
+  await slider.press("End")
+  await expect(slider).toHaveAttribute("aria-valuetext", "Everything")
+  await expect(component.getByRole("switch")).toHaveCount(9)
+  await expect(component.locator('[data-slot="timeline-detail-unavailable"]')).toHaveCount(0)
+  await expect(component.locator('[data-action="timeline-detail-visibility"][aria-pressed="true"]')).toHaveCount(6)
+  await expect(component.getByRole("switch", { checked: true })).toHaveCount(0)
+})
+
+for (const direction of ["ltr", "rtl"]) {
+  for (const theme of ["light", "dark"]) {
+    story(`fits narrow and wide layouts in ${direction}, ${theme}`, async ({ mount, page }, testInfo) => {
+      await page.setViewportSize({ width: 900, height: 900 })
+      const component = await mount("settings-timeline-detail--interactive", { globals: { direction, theme } })
+      await expect(component.locator('[data-slot="timeline-detail-summary"]')).toHaveCSS(
+        "color",
+        await component
+          .locator('[data-slot="settings-row-title"]')
+          .evaluate((element) => getComputedStyle(element).color),
+      )
+      await component.getByRole("button", { name: "Advanced", exact: true }).click()
+      const track = component.locator('[data-slot="timeline-detail-track"]')
+      await expect(track).toHaveCSS(
+        "--timeline-detail-track-background",
+        await track.evaluate(
+          (element, theme) =>
+            getComputedStyle(element)
+              .getPropertyValue(theme === "light" ? "--v2-background-bg-layer-04" : "--v2-background-bg-layer-03")
+              .trim(),
+          theme,
+        ),
+      )
+      if (theme === "light") {
+        await expect(track.locator("span").first()).toHaveCSS("background-image", "none")
+        await expect(track).toHaveCSS(
+          "--timeline-detail-marker-background",
+          await track.evaluate((element) => getComputedStyle(element).getPropertyValue("--v2-grey-500").trim()),
+        )
+      }
+      if (theme === "dark") {
+        await expect(track.locator("span").first()).not.toHaveCSS("background-image", "none")
+      }
+      await page.screenshot({ path: testInfo.outputPath(`timeline-${theme}-${direction}.png`) })
+      const list = component.locator('[data-slot="timeline-detail-list"]')
+      await expect(component.locator('[data-slot="timeline-detail-categories"]')).toHaveCSS("margin-top", "0px")
+      for (const [column, field] of [
+        [2, "placement"],
+        [3, "details"],
+      ] as const) {
+        const heading = await component
+          .locator(`[data-slot="timeline-detail-columns"] > :nth-child(${column})`)
+          .evaluate((element) => {
+            const rect = element.getBoundingClientRect()
+            return rect.x + rect.width / 2
+          })
+        const toggle = await component
+          .locator(`[data-category="shell"][data-field="${field}"] [data-slot="switch-control"]`)
+          .evaluate((element) => {
+            const rect = element.getBoundingClientRect()
+            return rect.x + rect.width / 2
+          })
+        expect(Math.abs(heading - toggle)).toBeLessThan(1)
+      }
+      await expect(component.locator('[data-slot="timeline-detail-activity"]').first()).toHaveCSS("gap", "12px")
+      for (const width of [900, 320]) {
+        await page.setViewportSize({ width, height: 900 })
+        await expect(component.getByRole("switch", { name: "Shell grouped", exact: true })).toBeVisible()
+        expect(await list.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true)
+        const visibility = component.getByRole("button", { name: "Shell visibility" })
+        await visibility.focus()
+        await visibility.press("Space")
+        await expect(visibility).toHaveAttribute("aria-pressed", "false")
+        await expect(component.getByRole("switch", { name: "Shell grouped", exact: true })).toHaveCount(0)
+        await expect(
+          component
+            .getByRole("group", { name: "Shell", exact: true })
+            .locator('[data-slot="timeline-detail-unavailable"]'),
+        ).toHaveCount(2)
+        await visibility.press("Space")
+        await expect(visibility).toHaveAttribute("aria-pressed", "true")
+
+        const slider = component.getByRole("slider", { name: "Timeline detail" })
+        const track = component.locator('[data-slot="timeline-detail-track"]')
+        expect(await track.evaluate((element) => element.getBoundingClientRect().width)).toBe(
+          await component
+            .locator('[data-slot="timeline-detail-scale"]')
+            .evaluate((element) => element.getBoundingClientRect().width),
+        )
+        await slider.focus()
+        await slider.press("Home")
+        for (const position of [0, 1, 2, 3, 4]) {
+          if (position > 0) await slider.press("ArrowUp")
+          await expect(track).toHaveCSS("--timeline-detail-progress", `${position * 25}%`)
+          const fill = await track.evaluate((element) => {
+            const style = getComputedStyle(element, "::before")
+            return {
+              fraction: parseFloat(style.width) / element.getBoundingClientRect().width,
+              start: style.getPropertyValue("inset-inline-start"),
+              color: style.backgroundColor,
+              remainder: getComputedStyle(element).backgroundColor,
+            }
+          })
+          expect(fill.fraction).toBeCloseTo(position / 4, 2)
+          expect(fill.start).toBe("0px")
+          expect(fill.color).not.toBe(fill.remainder)
+          const marker = await track.locator("span").nth(position).boundingBox()
+          const bounds = await track.boundingBox()
+          expect(marker).not.toBeNull()
+          expect(bounds).not.toBeNull()
+          expect((marker!.x + marker!.width / 2 - bounds!.x) / bounds!.width).toBeCloseTo(
+            direction === "rtl" ? 1 - position / 4 : position / 4,
+            2,
+          )
+        }
+      }
+    })
+  }
+}

packages/app/e2e/regression/session-project-menu.spec.ts

@@ -53,7 +53,7 @@ for (const direction of ["ltr", "rtl"] as const) {
       await expect(trigger).toBeEnabled()
       await expect(trigger.locator("use")).toHaveAttribute(
         "href",
-        `#opencode-v2-icon-${workspace ? "workspace-isolated" : "monitor"}`,
+        `#opencode-v2-icon-${workspace ? "outline-worktree" : "monitor"}`,
       )
       const background = await trigger.evaluate((element) => getComputedStyle(element).backgroundColor)
       await trigger.hover()
@@ -267,7 +267,7 @@ for (const state of ["closed", "unopened"] as const) {
         messages.resolve()
         await expect(header.getByRole("button", { name: "More options", exact: true })).toBeVisible()
       }
-      await expect(trigger.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-workspace-isolated")
+      await expect(trigger.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-outline-worktree")
       await trigger.click()
       await expect(menu.getByRole("menuitem", { name: fixture.project.name, exact: true })).toBeEnabled()
       await expect(menu.getByRole("menuitem", { name: directory, exact: true })).toBeDisabled()

packages/app/e2e/regression/session-timeline-reasoning-projection.spec.ts

@@ -23,17 +23,21 @@ test("changes timeline presets and saves custom thinking details", async ({ page
   const slider = settings.getByRole("slider", { name: "Timeline detail", exact: true })
   await expect(slider).toBeEnabled()
   await slider.press("Home")
-  for (const [index, name] of ["Everything", "Detailed", "Compact", "Quiet", "Text only"].entries()) {
+  for (const [index, name] of ["Messages only", "Quiet", "Compact", "Detailed", "Everything"].entries()) {
     if (index) await slider.press("ArrowRight")
     await expect(slider).toHaveValue(String(index))
     await expect(slider).toHaveAttribute("aria-valuetext", name)
   }
-  await slider.press("Home")
+  await slider.press("End")
   await settings.getByRole("button", { name: "Advanced", exact: true }).click()
-  await settings.getByRole("button", { name: "Thinking Placement Separate", exact: true }).click()
-  await page.getByRole("option", { name: "Grouped", exact: true }).click()
-  await settings.getByRole("button", { name: "Thinking Details Expanded", exact: true }).click()
-  await page.getByRole("option", { name: "Collapsed", exact: true }).click()
+  const grouped = settings.getByRole("switch", { name: "Thinking grouped", exact: true })
+  const collapsed = settings.getByRole("switch", { name: "Thinking collapsed", exact: true })
+  await expect(grouped).not.toBeChecked()
+  await expect(collapsed).not.toBeChecked()
+  await settings.locator('[data-category="thinking"][data-field="placement"] [data-slot="switch-control"]').click()
+  await settings.locator('[data-category="thinking"][data-field="details"] [data-slot="switch-control"]').click()
+  await expect(grouped).toBeChecked()
+  await expect(collapsed).toBeChecked()
   await expect(slider).toHaveAttribute("aria-valuetext", "Custom")
   await expect
     .poll(() =>

packages/app/e2e/regression/settings-loading.spec.ts

@@ -154,8 +154,8 @@ test("worktree deletion sends the project location separately from the target",
   const settings = page.getByTestId("settings-screen")
   await settings.getByRole("tab", { name: "Worktrees", exact: true }).click()
   await expect(settings.getByText(sandboxes[0], { exact: true })).toBeVisible()
-  await settings.getByRole("button", { name: 'Delete worktree "workspace-1"?', exact: true }).click()
-  const confirmation = page.getByRole("dialog", { name: "Delete worktree", exact: true })
+  await settings.getByRole("button", { name: "Delete “workspace-1”?", exact: true }).click()
+  const confirmation = page.getByRole("dialog", { name: "Delete “workspace-1”?", exact: true })
   const remove = confirmation.getByRole("button", { name: "Delete worktree", exact: true })
   await expect(remove).toBeEnabled()
   const deleting = page.waitForRequest(

packages/app/e2e/regression/settings-scroll.spec.ts

@@ -33,7 +33,7 @@ for (const viewport of [
     const slider = settings.getByRole("slider", { name: "Timeline detail", exact: true })
     await expect(settings).toBeFocused()
     await page.setViewportSize(viewport)
-    await expect(slider).toHaveAccessibleDescription(/Choose how much activity appears in the timeline/)
+    await expect(slider).toHaveAccessibleDescription(/Choose how much detail appears in the session timeline/)
     await expect.poll(() => main.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1)
 
     // Wheel over the outer gutter must not move the entire settings screen.

packages/app/package.json

@@ -10,6 +10,7 @@
     "./i18n/desktop-native": "./src/runtime/i18n/desktop-native.ts",
     "./updater": "./src/shell/updates/types.ts",
     "./wsl/types": "./src/servers/wsl/types.ts",
+    "./ssh": "./src/servers/ssh/types.ts",
     "./vite": "./vite.js",
     "./index.css": "./src/index.css"
   },

packages/app/src/app.tsx

@@ -17,6 +17,8 @@ import { ServerConnection, ServersProvider } from "@/runtime/server/registry"
 import { SettingsProvider } from "@/settings/model"
 import { TabsProvider } from "@/shell/tabs/tabs"
 import { WslServersProvider } from "@/servers/wsl/context"
+import { SshServersProvider } from "@/servers/ssh/context"
+import { SshRestore } from "@/servers/ssh/restore"
 import { ErrorPage } from "@/shell/errors/error"
 import { AppRoutes, File, preloadRoute } from "@/shell/routes/routes"
 
@@ -80,9 +82,11 @@ export function AppBaseProviders(
             >
               <QueryProvider>
                 <WslServersProvider>
-                  <DialogProvider>
-                    <FileComponentProvider component={File}>{props.children}</FileComponentProvider>
-                  </DialogProvider>
+                  <SshServersProvider>
+                    <DialogProvider>
+                      <FileComponentProvider component={File}>{props.children}</FileComponentProvider>
+                    </DialogProvider>
+                  </SshServersProvider>
                 </WslServersProvider>
               </QueryProvider>
             </ErrorBoundary>
@@ -109,6 +113,7 @@ export function AppInterface(props: {
         <BodyTypography />
         <CommandProvider>
           <DesktopCommands />
+          <SshRestore />
           <HighlightsProvider>
             {props.children}
             {rootProps.children}

packages/app/src/composer/editor/interaction.ts

@@ -37,6 +37,7 @@ export type ComposerEditorView = {
   agent?: ComposerSelectControl
   variant?: ComposerSelectControl
   submit: {
+    available?: Accessor<boolean>
     stopping: Accessor<boolean>
     working?: Accessor<boolean>
     queue?: ComposerQueue
@@ -333,6 +334,7 @@ export function createComposerEditor(input: {
       draft.removeAttachment(id)
     },
     canSubmit() {
+      if (input.view.submit.available?.() === false) return false
       if (input.view.draftOnly) return false
       const persisted = draft.state
       if (state.mode === "shell") {
@@ -365,6 +367,7 @@ export function createComposerEditor(input: {
       dispatch({ type: "mode.shell" })
     },
     submit(options?: { alternate?: boolean }) {
+      if (input.view.submit.available?.() === false) return
       if (input.view.draftOnly) return
       input.view.submit.onSubmit(options)
       dispatch({ type: "popover.close" })

packages/app/src/composer/model.ts

@@ -11,7 +11,7 @@ import { useLanguage } from "@/runtime/i18n/language"
 import { useLayout } from "@/shell/state/layout"
 import { usePlatform } from "@/runtime/platform/platform"
 import { useWorkspaceLocation } from "@/workspaces/location"
-import { useData } from "@/runtime/server/current"
+import { useData, useServer } from "@/runtime/server/current"
 import { createSessionTabs } from "@/session/helpers"
 import { showToast } from "@/shell/notifications/toast"
 import { formatServerError } from "@/runtime/server/errors"
@@ -30,6 +30,8 @@ export type ComposerModel = ComposerEditorModel & {
 export function createComposerModel(adapter: ComposerAdapter, options?: { queue?: ComposerQueue }): ComposerModel {
   const sdk = useWorkspaceLocation()
   const data = useData()
+  const server = useServer()
+  const available = () => server.conn.type !== "ssh" || server.ctx.sdk.connection.status() === "connected"
   const files = useFile()
   const layout = useLayout()
   const comments = useComments()
@@ -394,10 +396,12 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
         keybind: () => command.keybindParts("model.variant.cycle"),
       },
       submit: {
+        available,
         stopping,
         working: adapter.working,
         queue: options?.queue,
         onSubmit: (submitOptions) => {
+          if (!available()) return
           const queue = options?.queue
           // Confirming an edit re-admits the queued prompt instead of sending
           // the composer value as a new prompt. Enter keeps it queued in

packages/app/src/desktop.ts

@@ -7,5 +7,8 @@ export { type FatalRendererErrorLog, type Platform, PlatformProvider } from "./r
 export { ServerConnection, useServers } from "./runtime/server/registry"
 export { useTabs } from "./shell/tabs/tabs"
 export { createDraftStore } from "./runtime/persistence/drafts"
+export { createNamespaceStorage, type NamespaceStorage } from "./runtime/persistence/namespace"
+export { flushPersisted } from "./runtime/persistence/persist"
 export { useWslServers } from "./servers/wsl/context"
+export { useSshServers } from "./servers/ssh/context"
 export { type UpdaterPlatform, type UpdaterState } from "./shell/updates/types"

packages/app/src/entry.tsx

@@ -7,6 +7,7 @@ import { loadInitialLocale } from "@/runtime/i18n/language"
 import { PlatformProvider } from "@/runtime/platform/platform"
 import { createWebPlatform } from "@/runtime/platform/web"
 import { isStandalone, PwaRoutePersistence, restorePwaRoute } from "@/runtime/platform/pwa"
+import { KeyboardInsets } from "@/runtime/platform/keyboard"
 import en from "@/runtime/i18n/en"
 import zh from "@/runtime/i18n/zh"
 import { authFromToken } from "@/runtime/server/api"
@@ -92,6 +93,7 @@ if (root instanceof HTMLElement && root.dataset.opencodeMounted === undefined) {
               canonicalLocalServer={ServerConnection.key(server)}
               servers={[server]}
             >
+              <KeyboardInsets />
               {standalone && <PwaRoutePersistence />}
             </AppInterface>
           </AppBaseProviders>

packages/app/src/home/projects/view.tsx

@@ -365,7 +365,10 @@ function HomeServerRow(props: {
             />
           </span>
           <div class="flex size-4 shrink-0 items-center justify-center -mr-0.5">
-            <ServerHealthIndicator health={props.health} />
+            <ServerHealthIndicator
+              health={props.health}
+              connecting={props.server.type === "ssh" && props.server.connecting}
+            />
           </div>
           <span class="flex min-w-0 items-center gap-1">
             <span class={HOME_PROJECT_NAV_LABEL}>

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

@@ -34,6 +34,8 @@ export const ProviderTipSchema = Persistence.struct({
   dismissedAt: Schema.Finite,
 })
 
+export const WorkspaceTipSchema = ProviderTipSchema
+
 export function NewSessionView(props: {
   composer: ComposerModel
   project: PromptProjectController
@@ -99,7 +101,15 @@ export function NewSessionView(props: {
             </div>
           </div>
         </div>
-        <ProviderTip />
+        <NewSessionTips
+          workspaceEligible={
+            !!props.project.selected() &&
+            props.workspace.bar.visible() &&
+            props.workspace.selection.value() !== "create" &&
+            props.workspace.project.managed() === 0
+          }
+          onWorkspace={() => select("create")}
+        />
       </div>
     </div>
   )
@@ -118,56 +128,90 @@ export function NewSessionStatus(props: { visible: boolean }) {
   )
 }
 
-function ProviderTip() {
+function NewSessionTips(props: { workspaceEligible: boolean; onWorkspace: () => void }) {
   const language = useLanguage()
   const dialog = useDialog()
   const sdk = useWorkspaceLocation()
   const providers = useProviders(() => sdk().directory)
-  const [persistedState, setPersistedState, , persistedReady] = persisted(
+  const [providerState, setProviderState, , providerReady] = persisted(
     Persist.global("new-session.provider-tip"),
     ProviderTipSchema,
     { dismissedAt: 0 },
   )
-  const visible = createMemo(
+  const [workspaceState, setWorkspaceState, , workspaceReady] = persisted(
+    Persist.global("new-session.workspace-tip"),
+    WorkspaceTipSchema,
+    { dismissedAt: 0 },
+  )
+  const workspaceVisible = createMemo(
+    () =>
+      props.workspaceEligible &&
+      workspaceReady() &&
+      Date.now() - workspaceState.dismissedAt >= providerTipDismissalDuration,
+  )
+  const providerVisible = createMemo(
     () =>
       providers.ready() &&
-      persistedReady() &&
+      providerReady() &&
       providers.paid().length === 0 &&
-      Date.now() - persistedState.dismissedAt >= providerTipDismissalDuration,
+      Date.now() - providerState.dismissedAt >= providerTipDismissalDuration,
   )
+  const tip = createMemo<"workspace" | "provider" | undefined>(() => {
+    if (providerVisible()) return "provider"
+    if (workspaceVisible()) return "workspace"
+  })
+  const displayed = createMemo<"workspace" | "provider" | undefined>((previous) => tip() ?? previous)
   const [ref, setRef] = createSignal<HTMLDivElement>()
   const presence = createPresence({
-    show: visible,
+    show: () => tip() !== undefined,
     element: () => ref() ?? null,
   })
-  const openProviders = () => {
+  const open = () => {
+    const current = tip()
+    if (!current) return
+    if (current === "workspace") {
+      setWorkspaceState("dismissedAt", Date.now())
+      props.onWorkspace()
+      return
+    }
     void import("@/providers/connect/dialog").then(({ DialogConnectProvider }) => {
       void dialog.show(() => <DialogConnectProvider directory={sdk().directory} />)
     })
   }
+  const dismiss = () => {
+    const current = tip()
+    if (!current) return
+    if (current === "workspace") {
+      setWorkspaceState("dismissedAt", Date.now())
+      return
+    }
+    setProviderState("dismissedAt", Date.now())
+  }
 
   return (
     <Show when={presence.present()}>
       <div class="pointer-events-none absolute inset-x-0 bottom-4 flex justify-center px-10">
         <div
           ref={setRef}
-          data-component="provider-tip"
-          data-visible={visible()}
-          class="group/provider-tip pointer-events-auto relative flex h-6 max-w-full items-center transition-[opacity,transform] duration-[250ms] ease-[cubic-bezier(0.215,0.61,0.355,1)] motion-reduce:transition-none"
+          data-component="new-session-tip"
+          data-visible={tip() !== undefined}
+          class="group/new-session-tip pointer-events-auto relative flex h-6 max-w-full items-center transition-[opacity,transform] duration-[250ms] ease-[cubic-bezier(0.215,0.61,0.355,1)] motion-reduce:transition-none"
           classList={{ "data-[visible=false]:animate-out fade-out slide-out-to-bottom-4": true }}
         >
           <button
             type="button"
             class="flex h-6 min-w-0 items-center rounded-[4px] pl-1.5 text-[13px] leading-text-compact tracking-[-0.04px] text-v2-text-text-faint transition-[background-color,color] duration-150 ease-in-out hover:bg-v2-overlay-simple-overlay-hover hover:text-v2-text-text-muted focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:text-v2-text-text-muted focus-visible:outline-none"
-            onClick={openProviders}
+            onClick={open}
           >
-            <span class="truncate">{language.t("home.providerTip")}</span>
+            <span class="truncate">
+              {language.t(displayed() === "workspace" ? "home.workspaceTip" : "home.providerTip")}
+            </span>
             <span class="flex size-6 shrink-0 items-center justify-center" aria-hidden="true">
               <Icon name="chevron-down" size="small" class="-rotate-90" />
             </span>
           </button>
           <Tooltip
-            class="hover-reveal absolute left-full top-0 flex h-6 w-7 items-center justify-end delay-0 duration-0 group-hover/provider-tip:delay-[250ms] group-hover/provider-tip:duration-150 group-hover/provider-tip:opacity-100 focus-within:delay-0 focus-within:duration-0 focus-within:opacity-100"
+            class="hover-reveal absolute left-full top-0 flex h-6 w-7 items-center justify-end delay-0 duration-0 group-hover/new-session-tip:delay-[250ms] group-hover/new-session-tip:duration-150 group-hover/new-session-tip:opacity-100 focus-within:delay-0 focus-within:duration-0 focus-within:opacity-100"
             placement="top"
             openDelay={1000}
             value={language.t("common.dismiss")}
@@ -176,7 +220,7 @@ function ProviderTip() {
               type="button"
               class="flex size-6 items-center justify-center rounded-[4px] text-v2-icon-icon-muted transition-[background-color,color] duration-150 ease-in-out hover:bg-v2-overlay-simple-overlay-hover hover:text-v2-icon-icon-base focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:text-v2-icon-icon-base focus-visible:outline-none"
               aria-label={language.t("common.dismiss")}
-              onClick={() => setPersistedState("dismissedAt", Date.now())}
+              onClick={dismiss}
             >
               <Icon name="xmark-small" />
             </button>

packages/app/src/new-session/workspace/controller.ts

@@ -1,5 +1,5 @@
 import { debounce } from "@solid-primitives/scheduled"
-import { createEffect, createMemo, createResource } from "solid-js"
+import { createEffect, createMemo, createResource, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useWorkspaceLocation } from "@/workspaces/location"
 import { useServerSDK } from "@/runtime/server/client"
@@ -11,8 +11,8 @@ import { normalizeProjectInfo } from "@/runtime/server/global-sync/utils"
 import {
   isWorkspaceDirectory,
   isWorkspaceSelection,
+  sameDirectory,
   workspaceDefaultSelection,
-  workspaceDirectories,
   workspaceSelectionDestination,
 } from "@/workspaces/paths"
 
@@ -56,6 +56,50 @@ export function createNewSessionWorkspaceController(input: {
     const current = projectID ? data.project.get(projectID) : undefined
     return current ? normalizeProjectInfo(current) : undefined
   })
+  const worktreeSource = createMemo(
+    () => {
+      const project = currentProject()
+      return project ? { projectID: project.id, directory: project.worktree } : undefined
+    },
+    undefined,
+    { equals: (a, b) => a?.projectID === b?.projectID && a?.directory === b?.directory },
+  )
+  const [worktrees, worktreeActions] = createResource(worktreeSource, async (source) => ({
+    projectID: source.projectID,
+    items: await serverSDK.api.worktree
+      .list({ location: { directory: source.directory } })
+      .catch(() => (currentProject()?.id === source.projectID ? currentProject()?.worktrees : undefined) ?? []),
+  }))
+  onCleanup(
+    serverSDK.event.listen((event) => {
+      if (event.type === "worktree.updated") void worktreeActions.refetch()
+    }),
+  )
+  const worktreeItems = createMemo(() => {
+    const project = currentProject()
+    if (!project) return []
+    const loaded = worktrees.latest
+    return loaded?.projectID === project.id ? loaded.items : project.worktrees
+  })
+  const worktreeDirectories = createMemo(() => {
+    const project = currentProject()
+    if (!project) return []
+    const directories = [
+      ...worktreeItems().map((item) => item.directory),
+      ...project.worktrees.map((item) => item.directory),
+      ...(project.sandboxes ?? []),
+    ]
+    return directories
+      .filter((directory) => !sameDirectory(project.worktree, directory))
+      .filter((directory, index, items) => items.findIndex((item) => sameDirectory(item, directory)) === index)
+  })
+  const managedWorktrees = createMemo(() => {
+    const project = currentProject()
+    if (!project) return 0
+    return worktreeItems().filter(
+      (item) => item.strategy !== undefined && !sameDirectory(project.worktree, item.directory),
+    ).length
+  })
   const visible = createMemo(() =>
     resolveNewSessionGit({
       projectVcs: currentProject()?.vcs,
@@ -66,7 +110,10 @@ export function createNewSessionWorkspaceController(input: {
     const project = currentProject()
     const worktree = input.selectedWorktree()
     if (!project || !worktree) return
-    return isWorkspaceSelection(project, worktree) ? worktree : undefined
+    return isWorkspaceSelection(project, worktree) ||
+      worktreeDirectories().some((item) => sameDirectory(item, worktree))
+      ? worktree
+      : undefined
   })
   const fallback = createMemo(() => {
     const project = currentProject()
@@ -97,7 +144,7 @@ export function createNewSessionWorkspaceController(input: {
       () => undefined,
     )
     const project = currentProject()
-    const directories = project ? [project.worktree, ...workspaceDirectories(project)] : [sdk().directory]
+    const directories = project ? [project.worktree, ...worktreeDirectories()] : [sdk().directory]
     directories.forEach((directory) => void data.location.vcs.sync({ directory }).catch(() => undefined))
   })
   const branch = createMemo(() =>
@@ -122,7 +169,12 @@ export function createNewSessionWorkspaceController(input: {
       workspace: createMemo(() => {
         const project = currentProject()
         const current = value()
-        return current === "create" || (!!project && isWorkspaceDirectory(project, current))
+        return (
+          current === "create" ||
+          (!!project &&
+            (isWorkspaceDirectory(project, current) ||
+              worktreeDirectories().some((item) => sameDirectory(item, current))))
+        )
       }),
       reset: () => {
         input.setSelectedWorktree(undefined)
@@ -142,10 +194,8 @@ export function createNewSessionWorkspaceController(input: {
     },
     project: {
       root: projectRoot,
-      workspaces: () => {
-        const project = currentProject()
-        return project ? workspaceDirectories(project) : []
-      },
+      workspaces: worktreeDirectories,
+      managed: managedWorktrees,
       git: visible,
       branches: () => {
         const current = data.location.vcs.info({ directory: sdk().directory })?.branch.current

packages/app/src/new-session/workspace/selector.tsx

@@ -1,5 +1,6 @@
-import { createMemo, For, Show } from "solid-js"
+import { createMemo, createSignal, For, Show } from "solid-js"
 import { createStore } from "solid-js/store"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { Menu } from "@opencode-ai/ui/menu"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { Icon } from "@opencode-ai/ui/icon"
@@ -25,6 +26,9 @@ export function PromptWorkspaceSelector(props: {
   let searchInput: HTMLInputElement | undefined
   let branchSearchInput: HTMLInputElement | undefined
   let focusSearch = false
+  const branchTruncation = createTruncatedText()
+  const focusWorktreeSearch = () =>
+    requestAnimationFrame(() => requestAnimationFrame(() => searchInput?.focus({ preventScroll: true })))
   let pending: { type: "select"; value: string } | { type: "create"; branch: string } | { type: "viewAll" } | undefined
   const selected = () => (sameDirectory(props.value, props.projectRoot) ? "main" : props.value)
   const workspaces = createMemo(() => {
@@ -34,8 +38,8 @@ export function PromptWorkspaceSelector(props: {
   })
   const icon = () => {
     if (selected() === "main") return "monitor"
-    if (selected() === "create") return "workspace-new"
-    return "workspace-isolated"
+    if (selected() === "create") return "plus"
+    return "outline-worktree"
   }
   const select = (value: string) => {
     pending = { type: "select", value }
@@ -66,13 +70,14 @@ export function PromptWorkspaceSelector(props: {
     <>
       <span class="hidden select-none opacity-50 sm:inline mx-1">/</span>
       <Tooltip
+        appearance={props.onboarding ? "large" : undefined}
         placement="top"
         openDelay={800}
         value={
           props.onboarding ? (
             <div class="flex flex-col gap-1 text-start">
               <div class="flex items-center gap-1.5 font-[530] text-v2-text-text-base">
-                <Icon name="workspace-isolated" size="small" class="shrink-0 text-v2-text-text-accent" />
+                <Icon name="outline-worktree" size="small" class="shrink-0 text-v2-text-text-accent" />
                 <span>{language.t("workspace.onboarding.title")}</span>
               </div>
               <span class="font-[440] text-v2-text-text-muted">{language.t("workspace.onboarding.description")}</span>
@@ -89,7 +94,10 @@ export function PromptWorkspaceSelector(props: {
             aria-description={language.t("session.new.workspace.trigger.tooltip")}
             class="flex h-6 min-w-0 max-w-[203px] items-center gap-1.5 rounded-sm px-1.5 hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed data-[expanded]:text-v2-text-text-muted"
           >
-            <Icon name={icon()} class="shrink-0 text-v2-icon-icon-muted" />
+            <Icon
+              name={icon()}
+              class={`shrink-0 ${selected() === "main" || selected() === "create" ? "text-v2-icon-icon-muted" : "text-v2-icon-icon-accent"}`}
+            />
             <span class="min-w-0 truncate">{label()}</span>
             <Show when={props.onboarding}>
               <span
@@ -109,14 +117,8 @@ export function PromptWorkspaceSelector(props: {
                   <Tooltip
                     placement="right"
                     openDelay={800}
-                    value={
-                      <span class="flex flex-col gap-0.5">
-                        <span>{language.t("session.new.workspace.local")}</span>
-                        <span class="font-[440] text-v2-text-text-muted">
-                          {language.t("session.new.workspace.local.tooltip")}
-                        </span>
-                      </span>
-                    }
+                    value={language.t("session.new.workspace.local.tooltip")}
+                    contentClass="max-w-[140px]"
                     class="min-w-0 flex-1"
                   >
                     <span class="min-w-0 truncate">{language.t("session.new.workspace.local")}</span>
@@ -126,24 +128,22 @@ export function PromptWorkspaceSelector(props: {
                   </Show>
                 </Menu.Item>
                 <Menu.Item onSelect={() => select("create")}>
-                  <Icon name="workspace-new" />
-                  <span class="min-w-0 flex-1 truncate">{language.t("workspace.new")}</span>
+                  <Icon name="plus" />
+                  <Tooltip
+                    placement="right"
+                    openDelay={800}
+                    value={language.t("session.new.workspace.new.tooltip")}
+                    contentClass="max-w-[140px]"
+                    class="min-w-0 flex-1"
+                  >
+                    <span class="min-w-0 truncate">{language.t("workspace.new")}</span>
+                  </Tooltip>
                   <Show when={selected() === "create"}>
                     <Icon name="check" size="small" class="shrink-0" />
                   </Show>
                 </Menu.Item>
               </Menu.Group>
-              <Show
-                when={props.workspaces.length > 0}
-                fallback={
-                  <>
-                    <Menu.Separator class="h-[0.5px]" />
-                    <Menu.Item onSelect={() => (pending = { type: "viewAll" })}>
-                      <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
-                    </Menu.Item>
-                  </>
-                }
-              >
+              <Show when={props.workspaces.length > 0}>
                 <Menu.Separator class="h-[0.5px]" />
                 <Menu.Sub
                   gutter={0}
@@ -156,10 +156,11 @@ export function PromptWorkspaceSelector(props: {
                     }
                     if (!focusSearch || props.workspaces.length < 10) return
                     focusSearch = false
-                    requestAnimationFrame(() => searchInput?.focus())
+                    focusWorktreeSearch()
                   }}
                 >
                   <Menu.SubTrigger
+                    onClick={focusWorktreeSearch}
                     onKeyDown={(event) => {
                       if (
                         event.key === "ArrowRight" ||
@@ -170,7 +171,7 @@ export function PromptWorkspaceSelector(props: {
                         focusSearch = true
                     }}
                   >
-                    <Icon name="workspace-isolated" />
+                    <Icon name="outline-worktree" />
                     <span class="min-w-0 flex-1 truncate">
                       {language.t("session.new.workspace.existing").replace(/(…|\.{3})$/, "")}
                     </span>
@@ -205,7 +206,7 @@ export function PromptWorkspaceSelector(props: {
                       <For each={workspaces()}>
                         {(workspace) => (
                           <Menu.Item onSelect={() => select(workspace)}>
-                            <Icon name="workspace-isolated" />
+                            <Icon name="outline-worktree" />
                             <span class="min-w-0 flex-1 truncate">{getFilename(workspace)}</span>
                             <Show when={selected() === workspace}>
                               <Icon name="check" size="small" class="shrink-0" />
@@ -213,6 +214,11 @@ export function PromptWorkspaceSelector(props: {
                           </Menu.Item>
                         )}
                       </For>
+                      <Show when={search.workspaces.trim() && workspaces().length === 0}>
+                        <div class="px-3 py-4 text-center text-[13px] font-[440] leading-5 text-v2-text-text-muted">
+                          {language.t("session.new.workspace.search.empty")}
+                        </div>
+                      </Show>
                       <Menu.Separator class="h-[0.5px]" />
                       <Menu.Item onSelect={() => (pending = { type: "viewAll" })}>
                         <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
@@ -232,6 +238,7 @@ export function PromptWorkspaceSelector(props: {
         <Tooltip
           placement="top"
           value={language.t("session.new.workspace.fromBranch", { branch: props.branch! })}
+          disabled={!branchTruncation.truncated()}
           class="ms-1 min-w-0 max-w-[220px]"
           contentClass="max-w-[calc(100vw-32px)] break-all"
         >
@@ -245,7 +252,7 @@ export function PromptWorkspaceSelector(props: {
           >
             <Menu.Trigger class="flex h-6 min-w-0 max-w-[220px] items-center gap-1.5 rounded-full bg-v2-background-bg-layer-02 px-2.5 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint transition-colors hover:bg-v2-background-bg-layer-03 hover:text-v2-text-text-muted focus-visible:bg-v2-background-bg-layer-03 focus-visible:text-v2-text-text-muted focus-visible:outline-none data-[expanded]:bg-v2-background-bg-layer-03 data-[expanded]:text-v2-text-text-muted">
               <Icon name="branch-out" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-              <span class="min-w-0 truncate">
+              <span ref={branchTruncation.observe} class="min-w-0 truncate">
                 {language.t("session.new.workspace.fromBranch", { branch: props.branch! })}
               </span>
               <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
@@ -319,6 +326,7 @@ export function PromptWorkspaceSelector(props: {
 
 export function PromptGitStatus(props: { branch?: string; noGit?: boolean; from?: boolean; class?: string }) {
   const language = useLanguage()
+  const truncation = createTruncatedText()
   const label = () => {
     if (props.noGit) return language.t("session.new.git.none")
     if (!props.branch) return undefined
@@ -338,15 +346,27 @@ export function PromptGitStatus(props: { branch?: string; noGit?: boolean; from?
         <Tooltip
           placement="top"
           value={value()}
+          disabled={!truncation.truncated()}
           class={`min-w-0 max-w-[220px] ${props.class ?? ""}`}
           contentClass="max-w-[calc(100vw-32px)] break-all"
         >
           <div class="flex h-6 min-w-0 max-w-[220px] items-center gap-1.5 rounded-full bg-v2-background-bg-layer-02 px-2.5 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint">
             <Icon name={icon()} size="small" class="shrink-0 text-v2-icon-icon-muted" />
-            <span class="min-w-0 truncate">{value()}</span>
+            <span ref={truncation.observe} class="min-w-0 truncate">
+              {value()}
+            </span>
           </div>
         </Tooltip>
       )}
     </Show>
   )
 }
+
+function createTruncatedText() {
+  const [truncated, setTruncated] = createSignal(false)
+  return {
+    truncated,
+    observe: (element: HTMLSpanElement) =>
+      createResizeObserver(element, () => setTruncated(element.scrollWidth > element.clientWidth)),
+  }
+}

packages/app/src/runtime/i18n/en.ts

@@ -2,6 +2,47 @@ import { DESKTOP_NATIVE_ENGLISH } from "./desktop-native"
 
 export const dict = {
   ...DESKTOP_NATIVE_ENGLISH,
+  "ssh.label": "SSH",
+  "ssh.offline": "Not connected to {{host}}. Your draft is preserved; remote work may still be running.",
+  "ssh.placeholder": "ssh user@example.com",
+  "ssh.add": "Add SSH server",
+  "ssh.server.menu.label": "SSH server",
+  "ssh.target": "Host or SSH command",
+  "ssh.connect": "Connect",
+  "ssh.connectTo": "Connect to {{host}}",
+  "ssh.authenticate": "SSH authentication",
+  "ssh.trust": "Trust and connect",
+  "ssh.continue": "Continue",
+  "ssh.retry": "Retry",
+  "ssh.update": "Update and reconnect",
+  "ssh.openProject": "Open project",
+  "ssh.project": "Open project on {{host}}",
+  "ssh.disconnect": "Disconnect",
+  "ssh.forget": "Forget connection",
+  "ssh.stage.disconnected": "Disconnected. The remote server is left running.",
+  "ssh.stage.connecting": "Connecting over SSH…",
+  "ssh.stage.checking": "Checking OpenCode…",
+  "ssh.stage.downloading": "Downloading server…",
+  "ssh.stage.uploading": "Uploading server…",
+  "ssh.stage.starting": "Connecting to OpenCode…",
+  "ssh.stage.ready": "Connected",
+  "ssh.stage.authentication": "Authentication required",
+  "ssh.stage.incompatible": "Server update required",
+  "ssh.stage.failed": "Connection failed",
+  "ssh.error.input":
+    "Enter a host or SSH connection command. Remote commands and unsupported SSH options aren’t allowed.",
+  "ssh.error.connection": "Could not establish the SSH connection. Check your network and SSH configuration.",
+  "ssh.error.platform":
+    "This remote platform is not supported. Automatic setup currently requires Linux or macOS on x64 or arm64.",
+  "ssh.error.version": "The remote service must match this Desktop version before connecting.",
+  "ssh.error.install":
+    "Could not install the remote server. Check connectivity, disk space, and that tar is installed.",
+  "ssh.error.unpublished":
+    "This Desktop version has no published remote server. For development builds, install and start V2 on the host, then retry.",
+  "ssh.error.service": "SSH connected, but the OpenCode server did not become ready.",
+  "ssh.error.host-key":
+    "The host’s identity could not be verified. Verify its fingerprint before updating your SSH known hosts.",
+  "ssh.error.ssh-missing": "OpenSSH was not found. Install an OpenSSH client and ensure ssh is available on PATH.",
   "session.location.unavailable": "Session location unavailable",
   "session.location.description": "Choose another directory to continue this session.",
   "session.location.choose": "Choose directory",
@@ -659,6 +700,7 @@ export const dict = {
   "home.sessions.group.yesterday": "Yesterday",
   "home.sessions.group.older": "Older",
   "home.providerTip": "Connect to 75+ providers to use other models, including Claude, GPT, Gemini, etc",
+  "home.workspaceTip": "Start next session in a new workspace to keep changes isolated",
 
   "session.tab.session": "Session",
   "session.tab.files": "Files",
@@ -993,37 +1035,36 @@ export const dict = {
 
   "settings.timeline.title": "Timeline",
   "settings.timeline.detail": "Timeline detail",
-  "settings.timeline.description": "Choose how much activity appears in the timeline. Messages stay visible.",
+  "settings.timeline.description": "Choose how much detail appears in the session timeline.",
+  "settings.timeline.summary": "{{preset}}:",
   "settings.timeline.preset.everything": "Everything",
   "settings.timeline.preset.detailed": "Detailed",
   "settings.timeline.preset.compact": "Compact",
   "settings.timeline.preset.quiet": "Quiet",
-  "settings.timeline.preset.text-only": "Text only",
+  "settings.timeline.preset.text-only": "Messages only",
   "settings.timeline.description.everything": "Show all activity separately. Expand shell output, edits, and thinking.",
   "settings.timeline.description.detailed":
-    "Expand shell output and edits. Show subagents separately and group other activity in Used.",
-  "settings.timeline.description.compact": "Group all activity in Used with details collapsed.",
-  "settings.timeline.description.quiet": "Group edits and subagents in Used. Hide other activity.",
-  "settings.timeline.description.text-only": "Hide all activity. Show only messages.",
-  "settings.timeline.description.custom": "Use your selected placement and details for each activity category.",
+    "Expand shell output and edits. Show subagents separately and group other activity.",
+  "settings.timeline.description.compact": "Group all activity with details collapsed.",
+  "settings.timeline.description.quiet": "Group edits and subagents. Hide other activity.",
+  "settings.timeline.description.text-only": "Hide all activity.",
+  "settings.timeline.description.custom": "Uses advanced settings.",
   "settings.timeline.custom": "Custom",
   "settings.timeline.advanced": "Advanced",
   "settings.timeline.advanced.description": "Set placement and details for each activity category.",
-  "settings.timeline.advanced.explainer": "Grouped activity goes into Used. Details applies after opening the group.",
-  "settings.timeline.activity": "Activity",
+  "settings.timeline.group": "Group",
+  "settings.timeline.collapse": "Collapse",
+  "settings.timeline.visibility.show": "Show",
+  "settings.timeline.visibility.hide": "Hide",
+  "settings.timeline.visibility.label": "{{activity}} visibility",
+  "settings.timeline.grouped.label": "{{activity}} grouped",
+  "settings.timeline.collapsed.label": "{{activity}} collapsed",
   "settings.timeline.category.shell": "Shell",
   "settings.timeline.category.edit": "Edits",
   "settings.timeline.category.thinking": "Thinking",
   "settings.timeline.category.subagents": "Subagents",
   "settings.timeline.category.notices": "Notices",
   "settings.timeline.category.tools": "Other tools",
-  "settings.timeline.placement.title": "Placement",
-  "settings.timeline.placement.separate": "Separate",
-  "settings.timeline.placement.grouped": "Grouped",
-  "settings.timeline.placement.hidden": "Hidden",
-  "settings.timeline.expansion.title": "Details",
-  "settings.timeline.expansion.collapsed": "Collapsed",
-  "settings.timeline.expansion.expanded": "Expanded",
 
   "settings.general.row.language.title": "Language",
   "settings.general.row.language.description": "Change the display language for OpenCode",
@@ -1250,30 +1291,43 @@ export const dict = {
 
   "workspace.new": "New worktree",
   "common.viewAll": "View all",
-  "session.new.workspace.local.tooltip": "Use current checkout",
-  "session.new.workspace.new.tooltip": "Create isolated checkout",
+  "session.new.workspace.local.tooltip": "Uses project’s current checkout",
+  "session.new.workspace.new.tooltip": "Creates isolated copy from current checkout",
   "session.new.workspace.fromBranch": "from {{branch}}",
   "session.new.workspace.createFrom": "Create from branch",
   "session.new.workspace.branch.search.placeholder": "Search branches",
   "session.new.workspace.trigger.tooltip": "Select where to run session",
   "session.new.workspace.search.placeholder": "Search worktrees",
+  "session.new.workspace.search.empty": "No matching worktrees",
   "settings.tab.workspaces": "Worktrees",
+  "settings.workspaces.description": "Review worktrees and manage disk usage",
   "settings.workspaces.filter.all": "All projects",
-  "settings.workspaces.empty": "No worktrees",
+  "settings.workspaces.empty": "No worktrees yet",
+  "settings.workspaces.empty.description": "Worktrees created in OpenCode will appear here",
   "settings.workspaces.count.one": "{{count}} worktree",
   "settings.workspaces.count.other": "{{count}} worktrees",
   "settings.workspaces.sessions.one": "{{count}} session in {{project}}",
   "settings.workspaces.sessions.other": "{{count}} sessions in {{project}}",
+  "settings.workspaces.sessions.filtered.one": "{{count}} session",
+  "settings.workspaces.sessions.filtered.other": "{{count}} sessions",
   "settings.workspaces.lastActiveSession": "Last active session",
   "settings.workspaces.deleteAll": "Delete all worktrees",
-  "settings.workspaces.deleteAll.confirm": "Delete all {{count}} worktrees?",
-  "settings.workspaces.delete.warning":
-    "The worktree directory and branch will be permanently removed, including any unmerged changes shown below.",
+  "settings.workspaces.deleteAll.confirm.one": "This will permanently delete {{count}} selected worktree.",
+  "settings.workspaces.deleteAll.confirm.other": "This will permanently delete {{count}} selected worktrees.",
+  "settings.workspaces.deleteWithoutSessions": "Delete worktrees without sessions",
+  "settings.workspaces.deleteWithoutSessions.confirm.one":
+    "This will permanently delete {{count}} worktree without linked sessions.",
+  "settings.workspaces.deleteWithoutSessions.confirm.other":
+    "This will permanently delete {{count}} worktrees without linked sessions.",
+  "settings.workspaces.deleteWithoutSessions.warning":
+    "Worktrees with unmerged changes or active locations will be kept.",
+  "settings.workspaces.delete.button": "Delete worktrees",
+  "settings.workspaces.delete.warning": "This permanently deletes the worktree and its branch.",
   "settings.workspaces.deleteAll.warning":
-    "The {{count}} selected worktrees in {{project}} will be permanently removed only if each is clean, inactive, and has no linked sessions.",
+    "Worktrees with unmerged changes, linked sessions, or active locations will be kept.",
   "settings.workspaces.delete.blocked.active": "The active worktree cannot be deleted.",
   "settings.workspaces.delete.blocked.linked":
-    "Linked sessions will remain, but their working directory will be permanently removed.",
+    "Linked sessions will remain, but their working directory will no longer exist.",
   "settings.workspaces.default.title": "Default environment",
   "settings.workspaces.default.description": "Choose where new sessions start",
   "settings.workspaces.default.lastUsed": "Last used per project",
@@ -1284,9 +1338,10 @@ export const dict = {
   "workspace.move.failed": "Failed to move session",
   "workspace.lifecycle.creating": "Creating worktree",
   "workspace.lifecycle.created": "Worktree created",
+  "workspace.lifecycle.deleting": "Deleting…",
   "workspace.lifecycle.starting": "Starting session",
   "workspace.onboarding.title": "Isolate sessions with worktrees",
-  "workspace.onboarding.description": "Each gets its own checkout, so nothing interferes with your local repository",
+  "workspace.onboarding.description": "Each gets its own checkout",
   "workspace.lifecycle.moving": "Moving to worktree",
   "workspace.lifecycle.set": "Worktree set",
   "session.summary.title": "Session details",
@@ -1305,9 +1360,10 @@ export const dict = {
   "workspace.status.checking": "Checking for unmerged changes…",
   "workspace.status.error": "Unable to verify git status.",
   "workspace.status.clean": "No unmerged changes detected.",
-  "workspace.status.dirty": "Unmerged changes detected in this worktree.",
+  "workspace.status.dirty": "Unmerged changes will be lost.",
   "workspace.delete.title": "Delete worktree",
-  "workspace.delete.confirm": 'Delete worktree "{{name}}"?',
+  "workspace.delete.confirm": "Delete “{{name}}”?",
+  "workspace.delete.location": "Location",
   "workspace.delete.button": "Delete worktree",
   "workspace.reset.title": "Reset worktree",
   "workspace.reset.confirm": 'Reset worktree "{{name}}"?',

packages/app/src/runtime/persistence/README.md

@@ -49,6 +49,36 @@ migration rules remain explicit in their schemas.
   invalid entries individually. Valid entries still pass through their codecs.
 - Recovery is not a substitute for an explicit historical shape transformation.
 
+## Writes
+
+The setter returned by `persisted()` only marks the store dirty (`persist.ts`). The store is
+serialized once per save window (`persistSaveDelay`), on owner cleanup, and when the page
+hides, and the write is skipped when the serialized form did not change. Reactive observers
+therefore see every mutation immediately and a burst of setter calls costs one encode. Call
+`flushPersisted()` when a test or a shutdown path needs the write to have happened; the
+desktop platform calls it before flushing its namespaces on shutdown. A real unsaved local
+change wins over a value arriving from another window, and over a stored value that finishes
+loading after the user already edited. A remote value that arrives while the store is dirty
+is held until the save runs; if the local setter calls turned out not to change the
+serialized form, the remote value is adopted instead of being lost.
+
+## Namespaces
+
+On desktop, `platform.storage(name)` returns a `NamespaceStorage` (`namespace.ts`): the
+in-memory truth for one storage namespace, modelled on VS Code's `Storage` class. The
+namespace is loaded from the host once, reads are Map lookups from then on, and writes
+update the cache immediately while being batched into one host round trip per flush
+window (`namespaceFlushDelay`). `flush()` hands the batch to the driver synchronously, so a
+flush on page hide is on the wire before the page goes away; the desktop platform flushes
+every namespace before the IPC runtime is disposed and whenever the window is hidden. Each
+local write carries a sequence number that is kept until the host accepts that exact write;
+until then neither the initial load, a change from another window (`accept`), nor the retry
+of an older failed batch can replace the key. The host also stamps every update with a
+monotonic revision, returned in the ack and carried by change events and loads, so an event
+that reaches a window after a newer ack or load for the same key is recognised as stale and
+dropped; an event held back during an in-flight write is applied after the ack when the host
+ordered it later.
+
 ## Migrations
 
 Describe shipped representations with schemas and transform their typed values
@@ -78,3 +108,28 @@ Storage-key relocation (`previousKey`, workspace aliases, draft storage moves)
 remains separate from schema migration. Draft blob externalization and hydration
 also remain in the storage adapter: composer codecs receive hydrated references,
 not raw ID-only blob documents.
+
+## Large draft content
+
+Draft documents never carry large text inline. Any string of `draftTextThreshold`
+characters or more is split into `draftTextChunk`-sized content-addressed blobs and
+stored as `{ blob: { kind: "text", ids: [...] } }`; reads join the chunks again. A
+content-keyed cache means unchanged chunks are not hashed or sent on later saves, so
+typing after a large paste uploads one chunk per save rather than the paste. Chunk
+boundaries never split a surrogate pair, and a failed upload is evicted so the next save
+retries it.
+
+Blob collection is made safe by validation on write, not by timing. A strict document write
+is refused while it references blob ids the store does not hold, so the previous document
+stays visible; the renderer uploads the missing bytes again from the chunk text or the image
+`Blob` it still holds, renames the references to the ids the uploads returned (content hashes
+normally, fresh ids on a store without WebCrypto), and publishes. This covers a chunk another
+tab collected, and an image the composer kept in its history long after its blob was
+collected. The desktop host additionally refreshes `touched_at` for every blob a written
+document references and collects only blobs unreferenced and untouched for `blobGrace`, so
+repairs stay rare.
+`persisted()` hands the draft store the encoded document (`setDocument`) rather than
+a serialized string, so the store does not re-parse the full document to externalize
+it. Both blob collectors (desktop SQL, browser IndexedDB) keep chunk ids alive. This
+follows VS Code's rule that editor content lives in per-resource backups, not in the
+state database.

packages/app/src/runtime/persistence/consumers.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { Schema } from "effect"
-import { WorkspaceOnboardingSchema, ProviderTipSchema } from "@/new-session/view"
+import { WorkspaceOnboardingSchema, ProviderTipSchema, WorkspaceTipSchema } from "@/new-session/view"
 import { ModelSelectionSchema } from "@/providers/models/selection"
 import { Persistence } from "@/runtime/persistence/schema"
 import { FileViewsSchema } from "@/workspaces/files/view-cache"
@@ -12,6 +12,7 @@ describe("persisted consumer schemas", () => {
   test("onboarding and provider tip retain defaults and validate stored values", () => {
     const onboarding = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceOnboardingSchema, { used: false }))
     const tip = Schema.decodeUnknownSync(Persistence.withInitial(ProviderTipSchema, { dismissedAt: 0 }))
+    const workspaceTip = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceTipSchema, { dismissedAt: 0 }))
     expect(onboarding({})).toEqual({ used: false })
     expect(onboarding({ used: "true" })).toEqual({ used: false })
     expect(onboarding({ used: true })).toEqual({ used: true })
@@ -19,6 +20,7 @@ describe("persisted consumer schemas", () => {
     expect(tip({ dismissedAt: "yesterday" })).toEqual({ dismissedAt: 0 })
     expect(tip({ dismissedAt: Infinity })).toEqual({ dismissedAt: 0 })
     expect(tip({ dismissedAt: 123 })).toEqual({ dismissedAt: 123 })
+    expect(workspaceTip({ dismissedAt: 123 })).toEqual({ dismissedAt: 123 })
   })
 
   test("collapse records recover malformed entries without losing valid siblings", () => {

packages/app/src/runtime/persistence/drafts.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, test } from "bun:test"
+import { createDraftStore, draftTextChunk, draftTextThreshold } from "./drafts"
+
+function memoryDriver() {
+  const documents = new Map<string, string>()
+  const blobs = new Map<string, Blob>()
+  let puts = 0
+  return {
+    documents,
+    blobs,
+    puts: () => puts,
+    driver: {
+      get: async (key: string) => documents.get(key) ?? null,
+      // Like the real stores: report referenced blobs that are not held; a strict write with any
+      // missing is refused.
+      set: async (key: string, value: string, strict: boolean) => {
+        const ids = new Set<string>()
+        JSON.parse(value, (_key, item) => {
+          if (item?.blob && typeof item.blob.id === "string") ids.add(item.blob.id)
+          if (item?.blob && Array.isArray(item.blob.ids)) item.blob.ids.forEach((id: unknown) => ids.add(String(id)))
+          return item
+        })
+        const missing = [...ids].filter((id) => !blobs.has(id))
+        if (!strict || missing.length === 0) documents.set(key, value)
+        return missing
+      },
+      remove: async (key: string) => void documents.delete(key),
+      putBlob: async (blob: Blob) => {
+        puts++
+        const id = `blob-${await blob.text().then((text) => Bun.hash(text).toString(16))}`
+        blobs.set(id, blob)
+        return id
+      },
+      getBlob: async (id: string) => blobs.get(id) ?? null,
+    },
+  }
+}
+
+const large = "x".repeat(draftTextThreshold)
+const paste = Array.from({ length: 3 * draftTextChunk }, (_, i) => String.fromCharCode(97 + (i % 26))).join("")
+
+describe("draft store text externalization", () => {
+  test("large strings become chunk lists and small ones stay inline", async () => {
+    const memory = memoryDriver()
+    const store = createDraftStore(memory.driver)
+    await store.setDocument("doc", {
+      prompt: [
+        { type: "text", content: paste },
+        { type: "text", content: "hi" },
+      ],
+    })
+    const stored = JSON.parse(memory.documents.get("doc")!)
+    expect(stored.prompt[0].content.blob.kind).toBe("text")
+    expect(stored.prompt[0].content.blob.ids).toHaveLength(3)
+    expect(stored.prompt[1].content).toBe("hi")
+    expect(memory.documents.get("doc")!.length).toBeLessThan(400)
+    const chunks = await Promise.all(
+      stored.prompt[0].content.blob.ids.map((id: string) => memory.blobs.get(id)!.text()),
+    )
+    expect(chunks.join("")).toBe(paste)
+  })
+
+  test("appending to a large string re-uploads only the final chunk", async () => {
+    const memory = memoryDriver()
+    const store = createDraftStore(memory.driver)
+    await store.setDocument("doc", { prompt: [{ type: "text", content: paste }] })
+    expect(memory.puts()).toBe(3)
+    await store.setDocument("doc", { prompt: [{ type: "text", content: `${paste}!` }] })
+    expect(memory.puts()).toBe(4)
+    await store.setDocument("doc", { prompt: [{ type: "text", content: `${paste}!` }], cursor: 1 })
+    expect(memory.puts()).toBe(4)
+  })
+
+  test("reads join the chunks again and reuse cached content", async () => {
+    const memory = memoryDriver()
+    const store = createDraftStore(memory.driver)
+    await store.setDocument("doc", { prompt: [{ type: "text", content: paste }] })
+    const fresh = createDraftStore(memory.driver)
+    expect(JSON.parse((await fresh.getItem("doc"))!)).toEqual({ prompt: [{ type: "text", content: paste }] })
+    memory.blobs.clear()
+    expect(JSON.parse((await fresh.getItem("doc"))!)).toEqual({ prompt: [{ type: "text", content: paste }] })
+  })
+
+  test("a missing chunk decodes to empty text instead of failing the document", async () => {
+    const memory = memoryDriver()
+    memory.documents.set(
+      "doc",
+      JSON.stringify({ prompt: [{ type: "text", content: { blob: { kind: "text", ids: ["gone"] } } }] }),
+    )
+    const store = createDraftStore(memory.driver)
+    expect(JSON.parse((await store.getItem("doc"))!)).toEqual({ prompt: [{ type: "text", content: "" }] })
+  })
+
+  test("a cached chunk id the store no longer holds is uploaded again on the next save", async () => {
+    const memory = memoryDriver()
+    const store = createDraftStore(memory.driver)
+    await store.setDocument("doc", { prompt: [{ type: "text", content: large }] })
+    const [id] = JSON.parse(memory.documents.get("doc")!).prompt[0].content.blob.ids
+    await store.setDocument("doc", { prompt: [{ type: "text", content: `${large}!` }] })
+    // Another tab collected the chunk for `large` while this tab still caches its id.
+    memory.blobs.clear()
+    // Undo republishes the cached id; the write reports it missing and the chunk is uploaded again.
+    await store.setDocument("doc", { prompt: [{ type: "text", content: large }] })
+    expect(memory.puts()).toBe(3)
+    const fresh = createDraftStore(memory.driver)
+    expect(JSON.parse((await fresh.getItem("doc"))!).prompt[0].content).toBe(large)
+    expect(memory.blobs.has(id)).toBe(true)
+  })
+
+  test("an image reference whose blob was collected is restored from its object url", async () => {
+    const memory = memoryDriver()
+    const store = createDraftStore(memory.driver)
+    const image = await store.putBlob(new Blob([new Uint8Array([1, 2, 3])], { type: "image/png" }))
+    // The composer kept this reference (for example in its history) while the store collected the bytes.
+    memory.blobs.clear()
+    await store.setDocument("doc", { prompt: [{ type: "image", blob: { id: image.id, url: image.url } }] })
+    expect(memory.blobs.has(image.id)).toBe(true)
+    expect(new Uint8Array(await memory.blobs.get(image.id)!.arrayBuffer())).toEqual(new Uint8Array([1, 2, 3]))
+  })
+
+  test("the previous document stays visible until missing blobs are restored", async () => {
+    const memory = memoryDriver()
+    const store = createDraftStore(memory.driver)
+    await store.setDocument("doc", { prompt: [{ type: "text", content: large }] })
+    await store.setDocument("doc", { prompt: [{ type: "text", content: `${large}!` }] })
+    const before = memory.documents.get("doc")
+    memory.blobs.clear()
+    // Hold the repair upload: while it is pending, another reader must still see the old document.
+    const gate = Promise.withResolvers<void>()
+    const putBlob = memory.driver.putBlob
+    memory.driver.putBlob = async (blob) => {
+      await gate.promise
+      return putBlob(blob)
+    }
+    const saving = store.setDocument("doc", { prompt: [{ type: "text", content: large }] })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(memory.documents.get("doc")).toBe(before)
+    gate.resolve()
+    await saving
+    expect(JSON.parse(memory.documents.get("doc")!).prompt[0].content.blob.ids).toHaveLength(1)
+    const fresh = createDraftStore(memory.driver)
+    expect(JSON.parse((await fresh.getItem("doc"))!).prompt[0].content).toBe(large)
+  })
+
+  test("references are renamed when a restored blob comes back under a different id", async () => {
+    const memory = memoryDriver()
+    // A store without WebCrypto assigns a fresh id to every upload.
+    let counter = 0
+    memory.driver.putBlob = async (blob) => {
+      const id = `random-${counter++}`
+      memory.blobs.set(id, blob)
+      return id
+    }
+    const store = createDraftStore(memory.driver)
+    const image = await store.putBlob(new Blob([new Uint8Array([7])], { type: "image/png" }))
+    await store.setDocument("doc", {
+      prompt: [
+        { type: "text", content: paste },
+        { type: "image", blob: image },
+      ],
+    })
+    const original = JSON.parse(memory.documents.get("doc")!)
+    memory.blobs.clear()
+    await store.setDocument("doc", {
+      prompt: [
+        { type: "text", content: paste },
+        { type: "image", blob: image },
+      ],
+    })
+    const restored = JSON.parse(memory.documents.get("doc")!)
+    expect(restored.prompt[0].content.blob.ids).not.toEqual(original.prompt[0].content.blob.ids)
+    expect(restored.prompt[1].blob.id).not.toBe(original.prompt[1].blob.id)
+    for (const id of [...restored.prompt[0].content.blob.ids, restored.prompt[1].blob.id])
+      expect(memory.blobs.has(id)).toBe(true)
+    const fresh = createDraftStore(memory.driver)
+    const read = JSON.parse((await fresh.getItem("doc"))!)
+    expect(read.prompt[0].content).toBe(paste)
+    expect(read.prompt[1].blob.id).toBe(restored.prompt[1].blob.id)
+    // The renamed ids are what later encodes publish, so saves of the still-live references (the
+    // composer keeps the original image id) upload nothing and keep one stable image id.
+    const puts = counter
+    for (const cursor of [1, 2, 3]) {
+      await store.setDocument("doc", {
+        prompt: [
+          { type: "text", content: paste },
+          { type: "image", blob: image },
+        ],
+        cursor,
+      })
+      expect(JSON.parse(memory.documents.get("doc")!).prompt[1].blob.id).toBe(restored.prompt[1].blob.id)
+    }
+    expect(counter).toBe(puts)
+  })
+
+  test("chunk boundaries never split a surrogate pair", async () => {
+    const memory = memoryDriver()
+    const store = createDraftStore(memory.driver)
+    const text = "x".repeat(draftTextChunk - 1) + "😀tail"
+    await store.setDocument("doc", { prompt: [{ type: "text", content: text }] })
+    const stored = JSON.parse(memory.documents.get("doc")!)
+    const bytes = await Promise.all(stored.prompt[0].content.blob.ids.map((id: string) => memory.blobs.get(id)!.text()))
+    expect(bytes.join("")).toBe(text)
+    expect(bytes[0]!.length).toBe(draftTextChunk + 1)
+    const fresh = createDraftStore(memory.driver)
+    expect(JSON.parse((await fresh.getItem("doc"))!).prompt[0].content).toBe(text)
+  })
+
+  test("a failed chunk upload is retried on the next save instead of being reused", async () => {
+    const memory = memoryDriver()
+    let failNext = true
+    const putBlob = memory.driver.putBlob
+    memory.driver.putBlob = async (blob) => {
+      if (failNext) {
+        failNext = false
+        throw new Error("offline")
+      }
+      return putBlob(blob)
+    }
+    const store = createDraftStore(memory.driver)
+    await expect(store.setDocument("doc", { prompt: [{ type: "text", content: paste }] })).rejects.toThrow("offline")
+    await store.setDocument("doc", { prompt: [{ type: "text", content: `${paste}!` }] })
+    const fresh = createDraftStore(memory.driver)
+    expect(JSON.parse((await fresh.getItem("doc"))!).prompt[0].content).toBe(`${paste}!`)
+  })
+
+  test("setItem still accepts a serialized document", async () => {
+    const memory = memoryDriver()
+    const store = createDraftStore(memory.driver)
+    await store.setItem("doc", JSON.stringify({ prompt: [{ type: "text", content: large }] }))
+    expect(JSON.parse(memory.documents.get("doc")!).prompt[0].content.blob.ids).toHaveLength(1)
+  })
+})

packages/app/src/runtime/persistence/drafts.ts

@@ -5,20 +5,43 @@ export type BlobReference = { id: string; url: string }
 
 type Driver = {
   get(key: string): Promise<string | null>
-  set(key: string, value: string): Promise<void>
+  /**
+   * Store the document and report every blob id it references that the store does not hold. A
+   * strict write is refused (nothing stored) when any are missing, so a document is never visible
+   * with dangling references while its blobs are being restored.
+   */
+  set(key: string, value: string, strict: boolean): Promise<readonly string[]>
   remove(key: string): Promise<void>
   putBlob(blob: Blob): Promise<string>
   getBlob(id: string): Promise<Blob | null>
 }
 
-export type DraftStore = AsyncStorage & { putBlob(blob: Blob): Promise<BlobReference> }
+export type DraftStore = AsyncStorage & {
+  putBlob(blob: Blob): Promise<BlobReference>
+  /** Persist an already-encoded document without re-parsing its serialized form. */
+  setDocument(key: string, document: unknown): Promise<void>
+}
+
+// Strings at least this long leave the document as fixed-size content-addressed chunks. Typing
+// after a large paste changes only the final chunk, so a save uploads one chunk, not the paste.
+export const draftTextThreshold = 16 * 1024
+export const draftTextChunk = 64 * 1024
+const textCacheLimit = 64
+
 const urls = new Map<string, string>()
+// The object URL already pins the Blob for the page's lifetime; keeping the Blob itself lets a
+// collected image be uploaded again without fetching the URL.
+const held = new Map<string, Blob>()
+// Image ids that were restored under a different id (a store without WebCrypto assigns fresh
+// ones); live references still carry the original.
+const aliases = new Map<string, string>()
 
 function blobUrl(id: string, blob: Blob) {
   const existing = urls.get(id)
   if (existing) return existing
   const url = URL.createObjectURL(blob)
   urls.set(id, url)
+  held.set(id, blob)
   return url
 }
 
@@ -56,25 +79,82 @@ export function createDraftStore(driver: Driver): DraftStore {
     const id = await driver.putBlob(blob)
     return { id, url: blobUrl(id, blob) }
   }
-  const encode = async (value: unknown): Promise<unknown> => {
-    if (Array.isArray(value)) return Promise.all(value.map(encode))
+  // Keyed by chunk content so unchanged chunks are never hashed or sent again while the draft is
+  // edited. Bounded because each entry pins up to draftTextChunk characters. A hit is safe even if
+  // the store has since collected the blob: the write reports it missing and it is uploaded again.
+  const chunkIds = new Map<string, Promise<string>>()
+  const chunks = new Map<string, string>()
+  const remember = <V>(cache: Map<string, V>, key: string, value: V) => {
+    cache.set(key, value)
+    if (cache.size > textCacheLimit) cache.delete(cache.keys().next().value!)
+    return value
+  }
+  const upload = (chunk: string) => {
+    const id = driver.putBlob(new Blob([chunk])).then(
+      (id) => {
+        remember(chunks, id, chunk)
+        return id
+      },
+      (error: unknown) => {
+        // A failed upload must not be reused as the answer for this content on later saves.
+        if (chunkIds.get(chunk) === id) chunkIds.delete(chunk)
+        throw error
+      },
+    )
+    return remember(chunkIds, chunk, id)
+  }
+  const externalize = (text: string) => Promise.all(split(text).map((chunk) => chunkIds.get(chunk) ?? upload(chunk)))
+  const loadChunk = async (id: string) => {
+    const cached = chunks.get(id)
+    if (cached !== undefined) return cached
+    const blob = await driver.getBlob(id)
+    // A missing chunk loses that text but keeps the rest of the document decodable.
+    return remember(chunks, id, blob ? await blob.text() : "")
+  }
+  // `sources` collects, for every blob id the encoded document references, a way to produce its
+  // bytes again: the chunk text itself, or the image Blob (or object URL) the reference carries.
+  type Sources = Map<string, { blob: () => Promise<Blob>; chunk?: string }>
+  const encode = async (value: unknown, sources: Sources): Promise<unknown> => {
+    if (typeof value === "string" && value.length >= draftTextThreshold) {
+      const pieces = split(value)
+      const ids = await externalize(value)
+      ids.forEach((id, index) =>
+        sources.set(id, { blob: async () => new Blob([pieces[index]!]), chunk: pieces[index] }),
+      )
+      return { blob: { kind: "text", ids } }
+    }
+    if (Array.isArray(value)) return Promise.all(value.map((entry) => encode(entry, sources)))
     if (!value || typeof value !== "object") return value
     const item = value as Record<string, unknown>
     if (item.type === "image" && typeof item.dataUrl === "string") {
       const blob = await fetch(item.dataUrl).then((response) => response.blob())
       const { dataUrl: _, ...rest } = item
-      return { ...rest, blob: { id: await driver.putBlob(blob) } }
+      const id = await driver.putBlob(blob)
+      sources.set(id, { blob: async () => blob })
+      return { ...rest, blob: { id } }
     }
     if ("blob" in item && item.blob && typeof item.blob === "object") {
       const blob = item.blob as Record<string, unknown>
+      if (blob.kind === "text") return item
       if (typeof blob.id === "string" && blob.id.startsWith("data:")) {
         const data = await fetch(blob.id).then((response) => response.blob())
-        return { ...item, blob: { id: await driver.putBlob(data) } }
+        const id = await driver.putBlob(data)
+        sources.set(id, { blob: async () => data })
+        return { ...item, blob: { id } }
+      }
+      if (typeof blob.id === "string") {
+        // A live reference keeps the id it was created with; publish the id its bytes now live under.
+        const id = aliases.get(blob.id) ?? blob.id
+        const kept = held.get(id)
+        const url = typeof blob.url === "string" ? blob.url : urls.get(id)
+        if (kept) sources.set(id, { blob: async () => kept })
+        else if (url) sources.set(id, { blob: () => fetch(url).then((response) => response.blob()) })
+        return { ...item, blob: { id } }
       }
       return { ...item, blob: { id: blob.id } }
     }
     return Object.fromEntries(
-      await Promise.all(Object.entries(item).map(async ([key, entry]) => [key, await encode(entry)])),
+      await Promise.all(Object.entries(item).map(async ([key, entry]) => [key, await encode(entry, sources)])),
     )
   }
   const decode = async (value: unknown): Promise<unknown> => {
@@ -83,6 +163,9 @@ export function createDraftStore(driver: Driver): DraftStore {
     const item = value as Record<string, unknown>
     if (item.blob && typeof item.blob === "object") {
       const ref = item.blob as Record<string, unknown>
+      if (ref.kind === "text" && Array.isArray(ref.ids)) {
+        return (await Promise.all(ref.ids.map((id) => loadChunk(String(id))))).join("")
+      }
       if (typeof ref.id === "string") {
         const url = await loadBlobUrl(ref.id)
         if (url) return { ...item, blob: { id: ref.id, url } }
@@ -92,6 +175,65 @@ export function createDraftStore(driver: Driver): DraftStore {
       await Promise.all(Object.entries(item).map(async ([key, entry]) => [key, await decode(entry)])),
     )
   }
+  // Upload the bytes behind `ids` again and return the ids they were stored under. Ids are
+  // usually content hashes and come back unchanged, but a store without WebCrypto assigns fresh
+  // ones, so callers must rename references rather than assume.
+  const restore = async (ids: readonly string[], sources: Sources) => {
+    const renamed = new Map<string, string>()
+    await Promise.all(
+      ids.map(async (id) => {
+        const source = sources.get(id)
+        if (!source) return
+        const blob = await source.blob()
+        const next = await driver.putBlob(blob)
+        renamed.set(id, next)
+        if (source.chunk !== undefined) {
+          remember(chunkIds, source.chunk, Promise.resolve(next))
+          remember(chunks, next, source.chunk)
+          return
+        }
+        held.set(next, blob)
+        blobUrl(next, blob)
+        if (next === id) return
+        // Later encodes of the still-live reference resolve straight to the new id. Re-point any
+        // earlier alias chain so lookups stay one step.
+        for (const [from, to] of aliases) if (to === id) aliases.set(from, next)
+        aliases.set(id, next)
+      }),
+    )
+    return renamed
+  }
+  const rename = (value: unknown, renamed: Map<string, string>): unknown => {
+    if (Array.isArray(value)) return value.map((entry) => rename(entry, renamed))
+    if (!value || typeof value !== "object") return value
+    const item = value as Record<string, unknown>
+    if (item.blob && typeof item.blob === "object") {
+      const ref = item.blob as Record<string, unknown>
+      if (Array.isArray(ref.ids))
+        return { ...item, blob: { ...ref, ids: ref.ids.map((id) => renamed.get(String(id)) ?? id) } }
+      if (typeof ref.id === "string") return { ...item, blob: { ...ref, id: renamed.get(ref.id) ?? ref.id } }
+    }
+    return Object.fromEntries(Object.entries(item).map(([key, entry]) => [key, rename(entry, renamed)]))
+  }
+  const setDocument = async (key: string, document: unknown) => {
+    const version = (versions.get(key) ?? 0) + 1
+    versions.set(key, version)
+    const sources: Sources = new Map()
+    const encoded = await encode(document, sources)
+    if (versions.get(key) !== version) return
+    // The store refuses the write while any referenced blob is missing, so the previous document
+    // stays visible until the bytes are back. Covers a blob collected while a cache, another tab,
+    // or the composer's history still held its id.
+    const missing = await driver.set(key, JSON.stringify(encoded), true)
+    if (missing.length === 0) return
+    const renamed = await restore(missing, sources)
+    if (versions.get(key) !== version) return
+    const unrestored = missing.filter((id) => !renamed.has(id))
+    if (unrestored.length)
+      console.error(`[persistence] draft ${key} references blobs with no bytes to restore`, unrestored)
+    // Anything still missing has no bytes anywhere; the owning codec drops such references on read.
+    await driver.set(key, JSON.stringify(rename(encoded, renamed)), false)
+  }
   return {
     getItem: async (key) => {
       const value = await driver.get(key)
@@ -101,12 +243,8 @@ export function createDraftStore(driver: Driver): DraftStore {
       if (Option.isNone(parsed)) return value
       return JSON.stringify(await decode(parsed.value))
     },
-    setItem: async (key, value) => {
-      const version = (versions.get(key) ?? 0) + 1
-      versions.set(key, version)
-      const encoded = JSON.stringify(await encode(JSON.parse(value)))
-      if (versions.get(key) === version) await driver.set(key, encoded)
-    },
+    setItem: (key, value) => setDocument(key, JSON.parse(value)),
+    setDocument,
     removeItem: async (key) => {
       versions.set(key, (versions.get(key) ?? 0) + 1)
       await driver.remove(key)
@@ -115,6 +253,20 @@ export function createDraftStore(driver: Driver): DraftStore {
   }
 }
 
+// Fixed-size pieces, except that a piece never ends between the two halves of a surrogate pair:
+// each piece becomes its own Blob, and an unpaired surrogate would be encoded as U+FFFD.
+function split(text: string) {
+  const pieces: string[] = []
+  for (let start = 0; start < text.length; ) {
+    const end = Math.min(start + draftTextChunk, text.length)
+    const code = text.charCodeAt(end - 1)
+    const stop = end < text.length && code >= 0xd800 && code <= 0xdbff ? end + 1 : end
+    pieces.push(text.slice(start, stop))
+    start = stop
+  }
+  return pieces
+}
+
 export function createBrowserDraftStore(): DraftStore {
   const request = indexedDB.open("opencode-drafts", 1)
   request.addEventListener("upgradeneeded", () => {
@@ -127,11 +279,7 @@ export function createBrowserDraftStore(): DraftStore {
       const transaction = database.transaction(["documents", "blobs"], "readwrite")
       const documents = transaction.objectStore("documents").getAll()
       documents.addEventListener("success", () => {
-        const used = new Set<string>()
-        JSON.parse(`[${documents.result.join(",")}]`, (_key, item) => {
-          if (item?.blob && typeof item.blob.id === "string") used.add(item.blob.id)
-          return item
-        })
+        const used = referenced(`[${documents.result.join(",")}]`)
         const store = transaction.objectStore("blobs")
         const blobs = store.openKeyCursor()
         blobs.addEventListener("success", () => {
@@ -164,7 +312,32 @@ export function createBrowserDraftStore(): DraftStore {
   }
   return createDraftStore({
     get: async (key) => ((await get("documents", key)) as string | undefined) ?? null,
-    set: (key, value) => write("documents", key, value),
+    set: async (key, value, strict) => {
+      // One readwrite transaction over both stores: IndexedDB serialises overlapping readwrite
+      // transactions in creation order, so a later save or removal cannot commit between the
+      // reference check and this write. The put is issued from the last lookup's callback so the
+      // transaction is never left without a pending request.
+      const ids = [...referenced(value)]
+      const transaction = (await db).transaction(["blobs", "documents"], "readwrite")
+      const missing: string[] = []
+      const publish = () => {
+        if (!strict || missing.length === 0) transaction.objectStore("documents").put(value, key)
+      }
+      let remaining = ids.length
+      if (remaining === 0) publish()
+      for (const id of ids) {
+        const lookup = transaction.objectStore("blobs").getKey(id)
+        lookup.addEventListener("success", () => {
+          if (lookup.result === undefined) missing.push(id)
+          if (--remaining === 0) publish()
+        })
+      }
+      return new Promise<string[]>((resolve, reject) => {
+        transaction.addEventListener("complete", () => resolve(missing))
+        transaction.addEventListener("error", () => reject(transaction.error))
+        transaction.addEventListener("abort", () => reject(transaction.error))
+      })
+    },
     remove: (key) => write("documents", key),
     putBlob: async (blob) => {
       const id = await blobID(blob)
@@ -175,6 +348,17 @@ export function createBrowserDraftStore(): DraftStore {
   })
 }
 
+// Every blob id a serialized document (or array of documents) references.
+function referenced(json: string) {
+  const ids = new Set<string>()
+  JSON.parse(json, (_key, item) => {
+    if (item?.blob && typeof item.blob.id === "string") ids.add(item.blob.id)
+    if (item?.blob && Array.isArray(item.blob.ids)) item.blob.ids.forEach((id: unknown) => ids.add(String(id)))
+    return item
+  })
+  return ids
+}
+
 export async function blobDataUrl(blob: BlobReference, mime: string) {
   const data = await fetch(blob.url).then((response) => response.blob())
   return new Promise<string>((resolve, reject) => {

packages/app/src/runtime/persistence/namespace.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, test } from "bun:test"
+import { createNamespaceStorage, type NamespaceDriver, type NamespaceStorage } from "./namespace"
+
+const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+type Call = { kind: string; name: string; insert?: Record<string, string>; remove?: string[] }
+
+// A host with a monotonic revision. Each update is acked to its caller and recorded as an event
+// that the test delivers to other windows whenever it chooses, like the real event stream.
+function host(initial: Record<string, Record<string, string>> = {}) {
+  const data = new Map(Object.entries(initial).map(([name, items]) => [name, new Map(Object.entries(items))]))
+  const calls: Call[] = []
+  const events: { name: string; insert: Record<string, string>; remove: string[]; revision: number }[] = []
+  let revision = 0
+  let fail: (insert: Record<string, string>) => boolean = () => false
+  let gate: Promise<void> | undefined
+  const driver: NamespaceDriver = {
+    items: async (name) => {
+      calls.push({ kind: "items", name })
+      return { items: Object.fromEntries(data.get(name) ?? []), revision }
+    },
+    update: async (name, insert, remove) => {
+      calls.push({ kind: "update", name, insert, remove })
+      await gate
+      if (fail(insert)) throw new Error("disk full")
+      const items = data.get(name) ?? new Map()
+      for (const [key, value] of Object.entries(insert)) items.set(key, value)
+      for (const key of remove) items.delete(key)
+      data.set(name, items)
+      events.push({ name, insert, remove, revision: ++revision })
+      return revision
+    },
+    clear: async (name) => {
+      calls.push({ kind: "clear", name })
+      data.delete(name)
+    },
+  }
+  return {
+    driver,
+    data,
+    calls,
+    events,
+    updates: () => calls.filter((call) => call.kind === "update"),
+    setFail: (value: boolean | ((insert: Record<string, string>) => boolean)) =>
+      (fail = typeof value === "boolean" ? () => value : value),
+    setGate: (value: Promise<void> | undefined) => (gate = value),
+    deliver: (target: NamespaceStorage, index: number) => {
+      const event = events[index]!
+      target.accept(event.insert, event.remove, event.revision)
+    },
+  }
+}
+
+describe("namespace storage", () => {
+  test("loads the namespace once and serves reads from memory", async () => {
+    const h = host({ w: { tabs: "[]", recent: "{}" } })
+    const storage = createNamespaceStorage(h.driver, "w", { delay: 10 })
+    expect(await storage.getItem("tabs")).toBe("[]")
+    expect(await storage.getItem("recent")).toBe("{}")
+    expect(await storage.getItem("missing")).toBeNull()
+    expect(await storage.getLength()).toBe(2)
+    expect(h.calls.filter((call) => call.kind === "items")).toHaveLength(1)
+  })
+
+  test("reads its own writes immediately and coalesces them into one update", async () => {
+    const h = host()
+    const storage = createNamespaceStorage(h.driver, "w", { delay: 10 })
+    void storage.setItem("tabs", "[1]")
+    void storage.setItem("recent", "{}")
+    void storage.setItem("tabs", "[1,2]")
+    void storage.removeItem("recent")
+    expect(await storage.getItem("tabs")).toBe("[1,2]")
+    expect(await storage.getItem("recent")).toBeNull()
+    expect(h.updates()).toHaveLength(0)
+    await wait(30)
+    expect(h.updates()).toEqual([{ kind: "update", name: "w", insert: { tabs: "[1,2]" }, remove: ["recent"] }])
+  })
+
+  test("writes made while loading win over the loaded snapshot", async () => {
+    const h = host({ w: { tabs: "old" } })
+    const storage = createNamespaceStorage(h.driver, "w", { delay: 10 })
+    const read = storage.getItem("tabs")
+    void storage.setItem("tabs", "new")
+    expect(await read).toBe("new")
+  })
+
+  test("flush writes now and resolves after the driver accepted the batch", async () => {
+    const h = host()
+    const storage = createNamespaceStorage(h.driver, "w", { delay: 10_000 })
+    void storage.setItem("tabs", "[1]")
+    await storage.flush()
+    expect(h.data.get("w")?.get("tabs")).toBe("[1]")
+    await storage.flush()
+    expect(h.updates()).toHaveLength(1)
+  })
+
+  test("a failed update keeps unsuperseded changes queued for the next flush", async () => {
+    const h = host()
+    const storage = createNamespaceStorage(h.driver, "w", { delay: 10_000 })
+    h.setFail(true)
+    void storage.setItem("tabs", "[1]")
+    void storage.setItem("recent", "{}")
+    await storage.flush()
+    expect(h.data.get("w")).toBeUndefined()
+    h.setFail(false)
+    void storage.setItem("tabs", "[2]")
+    await storage.flush()
+    expect(Object.fromEntries(h.data.get("w")!)).toEqual({ tabs: "[2]", recent: "{}" })
+  })
+
+  test("a batch is handed to the driver synchronously, not behind an earlier reply", async () => {
+    const h = host()
+    const first = Promise.withResolvers<void>()
+    h.setGate(first.promise)
+    const storage = createNamespaceStorage(h.driver, "w", { delay: 10_000 })
+    void storage.setItem("tabs", "[1]")
+    void storage.flush()
+    void storage.setItem("tabs", "[2]")
+    void storage.flush()
+    // Both batches reached the driver while the first reply is still outstanding.
+    expect(h.updates().map((call) => call.insert)).toEqual([{ tabs: "[1]" }, { tabs: "[2]" }])
+    first.resolve()
+    await storage.flush()
+  })
+
+  test("a pending load or an external change cannot overwrite a value that is in flight", async () => {
+    const loaded = Promise.withResolvers<{ items: Record<string, string>; revision: number }>()
+    const accepted = Promise.withResolvers<number>()
+    const driver: NamespaceDriver = {
+      items: () => loaded.promise,
+      update: () => accepted.promise,
+      clear: async () => undefined,
+    }
+    const storage = createNamespaceStorage(driver, "g", { delay: 10_000 })
+    const read = storage.getItem("model")
+    void storage.setItem("model", "local")
+    void storage.flush()
+    storage.accept({ model: "other-window-older" }, [], 1)
+    loaded.resolve({ items: { model: "snapshot-older" }, revision: 0 })
+    expect(await read).toBe("local")
+    accepted.resolve(2)
+    await storage.flush()
+    expect(await storage.getItem("model")).toBe("local")
+    storage.accept({ model: "other-window-newer" }, [], 3)
+    expect(await storage.getItem("model")).toBe("other-window-newer")
+  })
+
+  test("a failed batch does not requeue a value a later batch already replaced", async () => {
+    const h = host()
+    const first = Promise.withResolvers<void>()
+    h.setGate(first.promise)
+    // The first batch (old) is held at the host and will be rejected; the second (new) succeeds.
+    h.setFail((insert) => insert.tabs === "old")
+    const storage = createNamespaceStorage(h.driver, "w", { delay: 10_000 })
+    void storage.setItem("tabs", "old")
+    void storage.flush()
+    h.setGate(undefined)
+    void storage.setItem("tabs", "new")
+    void storage.flush()
+    await wait(0)
+    expect(h.data.get("w")?.get("tabs")).toBe("new")
+    first.resolve()
+    await storage.flush()
+    await storage.flush()
+    expect(h.updates().map((call) => call.insert)).toEqual([{ tabs: "old" }, { tabs: "new" }])
+    expect(h.data.get("w")?.get("tabs")).toBe("new")
+    expect(await storage.getItem("tabs")).toBe("new")
+  })
+
+  test("an event that reaches a window after a newer ack for the same key is ignored", async () => {
+    const h = host({ g: { model: "start" } })
+    const one = createNamespaceStorage(h.driver, "g", { delay: 10_000 })
+    const two = createNamespaceStorage(h.driver, "g", { delay: 10_000 })
+    await one.getItem("model")
+    await two.getItem("model")
+    void one.setItem("model", "A")
+    await one.flush()
+    void two.setItem("model", "B")
+    await two.flush()
+    // Both writes are acked. Now the event for A, which the host applied before B, reaches two.
+    h.deliver(two, 0)
+    expect(await two.getItem("model")).toBe("B")
+    expect(h.data.get("g")?.get("model")).toBe("B")
+    // One still receives B, which is newer than its own ack.
+    h.deliver(one, 1)
+    expect(await one.getItem("model")).toBe("B")
+  })
+
+  test("an event held back during an in-flight write wins after the ack if the host applied it later", async () => {
+    const h = host()
+    const gate = Promise.withResolvers<void>()
+    h.setGate(gate.promise)
+    const storage = createNamespaceStorage(h.driver, "g", { delay: 10_000 })
+    void storage.setItem("model", "mine")
+    void storage.flush()
+    // Another window's write for the same key landed at the host after ours will.
+    storage.accept({ model: "theirs" }, [], 2)
+    expect(await storage.getItem("model")).toBe("mine")
+    gate.resolve()
+    await storage.flush()
+    expect(await storage.getItem("model")).toBe("theirs")
+  })
+
+  test("the initial load removes a key an older event inserted while the load was in flight", async () => {
+    const loaded = Promise.withResolvers<{ items: Record<string, string>; revision: number }>()
+    const driver: NamespaceDriver = { items: () => loaded.promise, update: async () => 0, clear: async () => undefined }
+    const storage = createNamespaceStorage(driver, "g", { delay: 10_000 })
+    const read = storage.getItem("model")
+    // Host history: insert at 41, delete at 42; the snapshot was taken at 42.
+    storage.accept({ model: "inserted" }, [], 41)
+    loaded.resolve({ items: {}, revision: 42 })
+    expect(await read).toBeNull()
+    // The delete event is older than the floor and must stay a no-op either way.
+    storage.accept({}, ["model"], 42)
+    expect(await storage.getItem("model")).toBeNull()
+    // A key inserted by an event newer than the snapshot survives the load.
+    const second = Promise.withResolvers<{ items: Record<string, string>; revision: number }>()
+    const other = createNamespaceStorage({ ...driver, items: () => second.promise }, "g", { delay: 10_000 })
+    const pending = other.getItem("model")
+    other.accept({ model: "after-snapshot" }, [], 43)
+    second.resolve({ items: {}, revision: 42 })
+    expect(await pending).toBe("after-snapshot")
+  })
+
+  test("an event older than the initial load is ignored", async () => {
+    const h = host({ g: { model: "loaded" } })
+    void h.driver.update("g", { model: "loaded" }, [])
+    await wait(0)
+    const storage = createNamespaceStorage(h.driver, "g", { delay: 10_000 })
+    await storage.getItem("model")
+    storage.accept({ model: "before-load" }, [], 1)
+    expect(await storage.getItem("model")).toBe("loaded")
+    storage.accept({}, ["model"], 2)
+    expect(await storage.getItem("model")).toBeNull()
+  })
+
+  test("clear drops the cache and queued changes and clears the driver", async () => {
+    const h = host({ w: { tabs: "[]" } })
+    const storage = createNamespaceStorage(h.driver, "w", { delay: 10_000 })
+    await storage.getItem("tabs")
+    void storage.setItem("recent", "{}")
+    await storage.clear()
+    expect(await storage.getItem("tabs")).toBeNull()
+    expect(await storage.getItem("recent")).toBeNull()
+    expect(h.calls.map((call) => call.kind)).toEqual(["items", "clear"])
+  })
+})

packages/app/src/runtime/persistence/namespace.ts

@@ -0,0 +1,159 @@
+import type { AsyncStorage } from "@solid-primitives/storage"
+
+// The host-side store for one namespace: one bulk read, one bulk write. The host stamps every
+// update with a monotonic revision and reports it with reads, acks, and change events.
+export type NamespaceDriver = {
+  items(name: string): Promise<{ items: Record<string, string>; revision: number }>
+  update(name: string, insert: Record<string, string>, remove: string[]): Promise<number>
+  clear(name: string): Promise<void>
+}
+
+export type NamespaceStorage = AsyncStorage & {
+  /** Write every queued change now. Resolves when the driver has accepted it. */
+  flush(): Promise<void>
+  /** Apply a change another window made at `revision`, unless this window already holds something newer. */
+  accept(insert: Record<string, string>, remove: string[], revision: number): void
+}
+
+export const namespaceFlushDelay = 100
+
+// In-memory truth for a namespace. Reads load the namespace once and are Map lookups from then
+// on; writes update the cache immediately and are batched into one driver call per flush window,
+// so a burst of setter calls costs one round trip. Mirrors VS Code's Storage class.
+//
+// Two orderings keep the cache correct. Every local write gets a sequence number that stays
+// recorded until the host acks that exact write; while recorded, nothing external may replace
+// the key. Every value the cache holds also carries the host revision it came from, so an event
+// that reaches this window after a newer ack or load is recognised as stale and dropped. Batches
+// are posted as soon as they are cut, never behind an earlier reply, so a flush on pagehide is
+// on the wire before the page goes away.
+export function createNamespaceStorage(
+  driver: NamespaceDriver,
+  name: string,
+  options: { delay?: number } = {},
+): NamespaceStorage {
+  const delay = options.delay ?? namespaceFlushDelay
+  const cache = new Map<string, string>()
+  const local = new Map<string, { seq: number; value: string | null }>()
+  const dirty = new Set<string>()
+  const inflight = new Set<Promise<void>>()
+  // Host revision behind each cached key, and the revision the initial load reflected for all keys.
+  const applied = new Map<string, number>()
+  let floor = -1
+  // The newest external change for a key that arrived while a local write was still in flight.
+  const deferred = new Map<string, { revision: number; value: string | null }>()
+  let seq = 0
+  let loading: Promise<void> | undefined
+  let timer: ReturnType<typeof setTimeout> | undefined
+
+  const place = (key: string, value: string | null, revision: number) => {
+    if (value === null) cache.delete(key)
+    else cache.set(key, value)
+    applied.set(key, revision)
+  }
+
+  // The snapshot is the whole truth at its revision: a key it lacks was deleted by then, even if
+  // an older event inserted it into the cache while the load was in flight.
+  const load = () =>
+    (loading ??= driver.items(name).then((loaded) => {
+      floor = loaded.revision
+      const stale = (key: string) => !local.has(key) && (applied.get(key) ?? -1) <= loaded.revision
+      for (const key of [...cache.keys()]) {
+        if (!(key in loaded.items) && stale(key)) place(key, null, loaded.revision)
+      }
+      for (const [key, value] of Object.entries(loaded.items)) {
+        if (stale(key)) place(key, value, loaded.revision)
+      }
+    }))
+
+  const write = (key: string, value: string | null) => {
+    if (value === null) cache.delete(key)
+    else cache.set(key, value)
+    local.set(key, { seq: ++seq, value })
+    dirty.add(key)
+    timer ??= setTimeout(() => void flush(), delay)
+  }
+
+  // The host accepted this window's value for `key` at `revision`. A change from another window
+  // that was held back meanwhile wins if the host applied it later than ours.
+  const acknowledge = (key: string, revision: number) => {
+    local.delete(key)
+    const later = deferred.get(key)
+    deferred.delete(key)
+    if (later && later.revision > revision) return place(key, later.value, later.revision)
+    applied.set(key, revision)
+  }
+
+  const flush = () => {
+    clearTimeout(timer)
+    timer = undefined
+    if (dirty.size > 0) {
+      const batch = [...dirty].map((key) => ({ key, ...local.get(key)! }))
+      dirty.clear()
+      const insert = Object.fromEntries(batch.filter((entry) => entry.value !== null).map((e) => [e.key, e.value!]))
+      const remove = batch.filter((entry) => entry.value === null).map((entry) => entry.key)
+      const current = (entry: { key: string; seq: number }) => local.get(entry.key)?.seq === entry.seq
+      const request = driver
+        .update(name, insert, remove)
+        .then((revision) => batch.filter(current).forEach((entry) => acknowledge(entry.key, revision)))
+        .catch((error: unknown) => {
+          // Only a value nothing newer has replaced is worth retrying.
+          batch.filter(current).forEach((entry) => dirty.add(entry.key))
+          console.error(`[persistence] flush failed for ${name}`, error)
+        })
+        .finally(() => inflight.delete(request))
+      inflight.add(request)
+    }
+    return Promise.all(inflight).then(() => undefined)
+  }
+
+  const storage: NamespaceStorage = {
+    getItem: async (key) => {
+      await load()
+      return cache.get(key) ?? null
+    },
+    setItem: async (key, value) => write(key, value),
+    removeItem: async (key) => write(key, null),
+    clear: async () => {
+      clearTimeout(timer)
+      timer = undefined
+      cache.clear()
+      local.clear()
+      dirty.clear()
+      applied.clear()
+      deferred.clear()
+      loading = Promise.resolve()
+      await driver.clear(name)
+    },
+    key: async (index: number) => {
+      await load()
+      return [...cache.keys()][index]
+    },
+    getLength: async () => {
+      await load()
+      return cache.size
+    },
+    get length() {
+      return storage.getLength()
+    },
+    flush,
+    accept(insert, remove, revision) {
+      // The initial load already reflects everything up to `floor`.
+      if (revision <= floor) return
+      const changes = [
+        ...Object.entries(insert).map(([key, value]) => [key, value] as const),
+        ...remove.map((key) => [key, null] as const),
+      ]
+      for (const [key, value] of changes) {
+        if (local.has(key)) {
+          const held = deferred.get(key)
+          if (!held || revision > held.revision) deferred.set(key, { revision, value })
+          continue
+        }
+        if (revision <= (applied.get(key) ?? floor)) continue
+        place(key, value, revision)
+      }
+    },
+  }
+  return storage
+}

packages/app/src/runtime/persistence/persist.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, test } from "bun:test"
+import type { AsyncStorage, PersistenceSyncAPI, PersistenceSyncCallback, SyncStorage } from "@solid-primitives/storage"
+import { createRoot } from "solid-js"
+import { createStore } from "solid-js/store"
+import { flushPersisted, persistStore } from "./persist"
+
+const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+type State = { count: number; label: string }
+
+function setup(input: { initial?: string | null | Promise<string | null>; delay?: number; sync?: PersistenceSyncAPI }) {
+  const writes: string[] = []
+  return createRoot((dispose) => {
+    const [store, setStore] = createStore<State>({ count: 0, label: "" })
+    const persist = persistStore({
+      store,
+      setStore,
+      name: "state",
+      // One fixture serves both the sync and the async storage shape.
+      storage: {
+        getItem: () => input.initial ?? null,
+        setItem: (_key: string, value: string) => {
+          writes.push(value)
+        },
+        removeItem: () => {},
+      } as SyncStorage | AsyncStorage,
+      serialize: JSON.stringify,
+      deserialize: JSON.parse,
+      sync: input.sync,
+      delay: input.delay ?? 10,
+    })
+    return { store, set: persist.setStore, persist, writes, dispose }
+  })
+}
+
+describe("persistStore", () => {
+  test("marks the store dirty on set and writes once after the delay", async () => {
+    const value = setup({})
+    value.set("count", 1)
+    value.set("count", 2)
+    value.set("label", "a")
+    expect(value.store.count).toBe(2)
+    expect(value.writes).toEqual([])
+    await wait(30)
+    expect(value.writes).toEqual([JSON.stringify({ count: 2, label: "a" })])
+    value.dispose()
+  })
+
+  test("skips the write when the serialized value did not change", () => {
+    const value = setup({ delay: 10_000 })
+    value.set("count", 1)
+    value.persist.flush()
+    value.set("count", 1)
+    value.persist.flush()
+    expect(value.writes).toHaveLength(1)
+    value.dispose()
+  })
+
+  test("hydrates synchronously from sync storage without writing back", () => {
+    const value = setup({ initial: JSON.stringify({ count: 5, label: "saved" }), delay: 10_000 })
+    expect(value.store).toEqual({ count: 5, label: "saved" })
+    value.persist.flush()
+    expect(value.writes).toEqual([])
+    value.dispose()
+  })
+
+  test("a set made while async storage loads wins over the loaded value", async () => {
+    const loading = Promise.withResolvers<string | null>()
+    const value = setup({ initial: loading.promise, delay: 10_000 })
+    value.set("count", 9)
+    loading.resolve(JSON.stringify({ count: 1, label: "old" }))
+    await loading.promise
+    expect(value.store.count).toBe(9)
+    value.dispose()
+  })
+
+  test("applies another window's value when clean and ignores it while dirty", () => {
+    const listeners: PersistenceSyncCallback[] = []
+    const sent: string[] = []
+    const value = setup({
+      delay: 10_000,
+      sync: [(subscriber) => listeners.push(subscriber), (_key, next) => sent.push(String(next))],
+    })
+    listeners[0]!({ key: "state", newValue: JSON.stringify({ count: 3, label: "remote" }), timeStamp: 0 })
+    expect(value.store).toEqual({ count: 3, label: "remote" })
+    value.set("label", "local")
+    listeners[0]!({ key: "state", newValue: JSON.stringify({ count: 4, label: "remote-2" }), timeStamp: 0 })
+    expect(value.store).toEqual({ count: 3, label: "local" })
+    value.persist.flush()
+    expect(sent).toEqual([JSON.stringify({ count: 3, label: "local" })])
+    value.dispose()
+  })
+
+  test("a remote value arriving during a no-op local set is adopted when the save finds no change", () => {
+    const listeners: PersistenceSyncCallback[] = []
+    const sent: string[] = []
+    const value = setup({
+      delay: 10_000,
+      sync: [(subscriber) => listeners.push(subscriber), (_key, next) => sent.push(String(next))],
+    })
+    value.set("count", 1)
+    value.persist.flush()
+    // Setting the same value again marks the store dirty without changing it.
+    value.set("count", 1)
+    listeners[0]!({ key: "state", newValue: JSON.stringify({ count: 1, label: "remote" }), timeStamp: 0 })
+    expect(value.store.label).toBe("")
+    value.persist.flush()
+    expect(value.store).toEqual({ count: 1, label: "remote" })
+    expect(value.writes).toHaveLength(1)
+    expect(sent).toHaveLength(1)
+    // A later save must not consider the adopted value a local change.
+    value.set("count", 1)
+    value.persist.flush()
+    expect(value.writes).toHaveLength(1)
+    value.dispose()
+  })
+
+  test("a remote revert to the saved value during a no-op local set clears an earlier held change", () => {
+    const listeners: PersistenceSyncCallback[] = []
+    const value = setup({ delay: 10_000, sync: [(subscriber) => listeners.push(subscriber), () => {}] })
+    value.set("label", "saved")
+    value.persist.flush()
+    value.set("label", "saved")
+    listeners[0]!({ key: "state", newValue: JSON.stringify({ count: 0, label: "changed" }), timeStamp: 0 })
+    listeners[0]!({ key: "state", newValue: JSON.stringify({ count: 0, label: "saved" }), timeStamp: 0 })
+    value.persist.flush()
+    expect(value.store).toEqual({ count: 0, label: "saved" })
+    expect(value.writes).toHaveLength(1)
+    value.dispose()
+  })
+
+  test("a remote value arriving during a real local change is dropped in favour of the local one", () => {
+    const listeners: PersistenceSyncCallback[] = []
+    const value = setup({ delay: 10_000, sync: [(subscriber) => listeners.push(subscriber), () => {}] })
+    value.set("count", 1)
+    listeners[0]!({ key: "state", newValue: JSON.stringify({ count: 9, label: "remote" }), timeStamp: 0 })
+    value.persist.flush()
+    expect(value.store).toEqual({ count: 1, label: "" })
+    expect(value.writes).toEqual([JSON.stringify({ count: 1, label: "" })])
+    value.dispose()
+  })
+
+  test("disposing the owner and flushPersisted both save pending changes", () => {
+    const first = setup({ delay: 10_000 })
+    first.set("count", 1)
+    first.dispose()
+    expect(first.writes).toHaveLength(1)
+
+    const second = setup({ delay: 10_000 })
+    second.set("count", 2)
+    flushPersisted()
+    expect(second.writes).toEqual([JSON.stringify({ count: 2, label: "" })])
+    second.dispose()
+    expect(second.writes).toHaveLength(1)
+  })
+})

packages/app/src/runtime/persistence/persist.ts

@@ -0,0 +1,103 @@
+import type { AsyncStorage, PersistenceSyncAPI, SyncStorage } from "@solid-primitives/storage"
+import { getOwner, onCleanup, untrack } from "solid-js"
+import { reconcile, type SetStoreFunction, type Store } from "solid-js/store"
+
+export const persistSaveDelay = 100
+
+const pending = new Set<() => void>()
+
+/** Serialize and write every store with unsaved changes now. */
+export function flushPersisted() {
+  for (const save of [...pending]) save()
+}
+
+// Covers synchronous web storage. Desktop registers its own pagehide handling earlier than this
+// module loads, so its shutdown path calls flushPersisted() itself before flushing namespaces.
+if (typeof document !== "undefined") {
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "hidden") flushPersisted()
+  })
+  window.addEventListener("pagehide", flushPersisted)
+}
+
+// A store whose serialized form is written to storage on a schedule instead of on every setter
+// call. The setter only marks the store dirty; serialization happens once per save window, once
+// per owner cleanup, and when the page hides. Mirrors VS Code's Memento.
+export function persistStore<T extends object>(input: {
+  store: Store<T>
+  setStore: SetStoreFunction<T>
+  name: string
+  storage: SyncStorage | AsyncStorage
+  serialize: (value: T) => string
+  deserialize: (raw: string) => T
+  sync?: PersistenceSyncAPI
+  delay?: number
+  /** Replaces `storage.setItem` for stores whose storage can take the value itself. */
+  write?: (value: T, serialized: string) => void
+}) {
+  const delay = input.delay ?? persistSaveDelay
+  let dirty = false
+  let touched = false
+  let last: string | undefined
+  // The newest value another window wrote while this store was dirty; applied at save time if the
+  // local setter calls turned out not to change anything.
+  let remote: string | undefined
+  let timer: ReturnType<typeof setTimeout> | undefined
+
+  const save = () => {
+    clearTimeout(timer)
+    timer = undefined
+    pending.delete(save)
+    if (!dirty) return
+    dirty = false
+    const held = remote
+    remote = undefined
+    const next = untrack(() => input.serialize(input.store))
+    if (next === last) {
+      if (held !== undefined && held !== last) hydrate(held)
+      return
+    }
+    last = next
+    input.sync?.[1](input.name, next)
+    if (input.write) return input.write(input.store, next)
+    void input.storage.setItem(input.name, next)
+  }
+
+  // Solid's setter overloads are too deep to spread generically; the wrapper only forwards.
+  const apply = input.setStore as unknown as (...values: unknown[]) => void
+  const setStore = ((...values: unknown[]) => {
+    apply(...values)
+    dirty = true
+    touched = true
+    pending.add(save)
+    timer ??= setTimeout(save, delay)
+  }) as unknown as SetStoreFunction<T>
+
+  const hydrate = (raw: string) => {
+    last = raw
+    input.setStore(reconcile(input.deserialize(raw)))
+  }
+  const init = input.storage.getItem(input.name)
+  // A value the user already changed is newer than whatever storage held.
+  if (init instanceof Promise) void init.then((raw) => raw && !touched && hydrate(raw))
+  else if (init) hydrate(init)
+
+  input.sync?.[0]((data) => {
+    if (data.key !== input.name || (data.url ?? location.href) !== location.href) return
+    if (!data.newValue) return
+    // A real unsaved local change wins over another window's write, as in VS Code's storage
+    // service; whether the change is real is only known when the store is serialized. Every
+    // remote value replaces the held one, including a revert to `last`, so the save sees the
+    // other window's final state rather than an intermediate one.
+    if (dirty) {
+      remote = data.newValue
+      return
+    }
+    if (data.newValue === last) return
+    hydrate(data.newValue)
+  })
+
+  if (getOwner()) onCleanup(save)
+
+  return { setStore, init, flush: save }
+}

packages/app/src/runtime/persistence/storage.ts

@@ -1,14 +1,15 @@
 import { Platform, usePlatform } from "@/runtime/platform/platform"
-import { makePersisted, messageSync, type AsyncStorage, type SyncStorage } from "@solid-primitives/storage"
+import { messageSync, type AsyncStorage, type SyncStorage } from "@solid-primitives/storage"
 import { checksum } from "@opencode-ai/util/encode"
 import { createResource, onCleanup, type Accessor } from "solid-js"
 import { createStore, type SetStoreFunction, type Store } from "solid-js/store"
 import { Option, Schema } from "effect"
 import { pathKey } from "@/workspaces/path-key"
 import { ScopedKey, ServerScope } from "@/runtime/server/scope"
+import { persistStore } from "./persist"
 import { Persistence } from "./schema"
 
-type InitType = Promise<string> | string | null
+type InitType = Promise<string | null> | string | null
 type PersistedWithReady<T> = [
   Store<T>,
   SetStoreFunction<T>,
@@ -483,6 +484,7 @@ export function persisted<S extends Schema.ConstraintCodec<object, unknown>>(
   const initialized = Persistence.withInitial(schema, initial)
   const json = Schema.fromJsonString(initialized)
   const decode = Schema.decodeUnknownOption(json)
+  const encode = Schema.encodeSync(initialized)
   const serialize = Schema.encodeSync(json)
   const normalize = (raw: string) => {
     const value = decode(raw)
@@ -491,10 +493,12 @@ export function persisted<S extends Schema.ConstraintCodec<object, unknown>>(
   const store = createStore<S["Type"]>(Schema.decodeUnknownSync(Schema.toType(initialized))(initial))
   const isDesktop = platform.platform === "desktop" && !!platform.storage
   const draft = config.draft ? platform.draftStore : undefined
+  const prefix = `${config.storage ?? "default"}:`
+  // The newest serialized draft, replayed into storage if a slow load finishes after an edit.
+  let draftLatest: string | undefined
 
   const currentStorage = (() => {
     if (draft) {
-      const prefix = `${config.storage ?? "default"}:`
       return {
         getItem: (key: string) => draft.getItem(prefix + key),
         setItem: (key: string, value: string) => draft.setItem(prefix + key, value),
@@ -556,7 +560,6 @@ export function persisted<S extends Schema.ConstraintCodec<object, unknown>>(
     ]
       .filter((source): source is { storage: SyncStorage | AsyncStorage; key?: string } => !!source?.storage)
       .map((source) => ({ ...source, storage: toAsyncStorage(source.storage) }))
-    let draftLatest: string | undefined
 
     const api: AsyncStorage = {
       getItem: async (key) => {
@@ -593,13 +596,29 @@ export function persisted<S extends Schema.ConstraintCodec<object, unknown>>(
       : undefined
   if (channel) onCleanup(() => channel.close())
 
-  const [state, setState, init] = makePersisted<S["Type"], typeof store>(store, {
+  const persist = persistStore({
+    store: store[0],
+    setStore: store[1],
     name: config.key,
     storage,
     serialize,
     deserialize: Schema.decodeUnknownSync(json),
     sync: channel ? messageSync(channel) : undefined,
+    // Drafts take the encoded document itself so large text is externalized without the store
+    // re-parsing the serialized form on every save.
+    write: draft
+      ? (value, serialized) => {
+          draftLatest = serialized
+          // A failed chunk upload is retried by the next save; see drafts.ts.
+          void draft
+            .setDocument(prefix + config.key, encode(value))
+            .catch((error: unknown) => console.error(`[persistence] draft write failed for ${config.key}`, error))
+        }
+      : undefined,
   })
+  const state = store[0]
+  const setState = persist.setStore
+  const init = persist.init
 
   const isAsync = init instanceof Promise
   const [ready] = createResource(

packages/app/src/runtime/platform/keyboard.ts

@@ -0,0 +1,33 @@
+import { onCleanup, onMount } from "solid-js"
+
+export function KeyboardInsets() {
+  onMount(() => {
+    const viewport = window.visualViewport
+    if (!viewport) return
+    const root = document.documentElement
+    const sync = () => {
+      const active = document.activeElement
+      const editing =
+        active instanceof HTMLElement &&
+        (active.isContentEditable || active.matches("input:not([readonly]), textarea:not([readonly])"))
+      // iOS retains the home-indicator inset above its keyboard. Ignore pinch zoom
+      // and small viewport changes from browser chrome, not just editor focus.
+      const keyboard = editing && root.clientHeight - viewport.height * viewport.scale > 100
+      if (keyboard) root.style.setProperty("--safe-area-inset-bottom", "0px")
+      if (!keyboard) root.style.removeProperty("--safe-area-inset-bottom")
+    }
+    sync()
+    viewport.addEventListener("resize", sync)
+    window.addEventListener("resize", sync)
+    document.addEventListener("focusin", sync)
+    document.addEventListener("focusout", sync)
+    onCleanup(() => {
+      viewport.removeEventListener("resize", sync)
+      window.removeEventListener("resize", sync)
+      document.removeEventListener("focusin", sync)
+      document.removeEventListener("focusout", sync)
+      root.style.removeProperty("--safe-area-inset-bottom")
+    })
+  })
+  return null
+}

packages/app/src/runtime/platform/platform.tsx

@@ -4,6 +4,7 @@ import type { Accessor } from "solid-js"
 import type { DesktopMenuAction } from "@/shell/commands/desktop-menu"
 import { ServerConnection } from "@/runtime/server/registry"
 import type { WslServersPlatform } from "@/servers/wsl/types"
+import type { SshPlatform } from "@/servers/ssh/types"
 import type { UpdaterPlatform } from "@/shell/updates/types"
 import type { DraftStore } from "@/runtime/persistence/drafts"
 
@@ -85,6 +86,7 @@ type PlatformBase = {
 
   /** Manage WSL sidecar servers (Electron on Windows only) */
   wslServers?: WslServersPlatform
+  sshServers?: SshPlatform
 
   /** Webview zoom level (desktop only) */
   webviewZoom?: Accessor<number>

packages/app/src/runtime/server/client.tsx

@@ -1,7 +1,7 @@
 import type { OpenCodeEvent } from "@opencode-ai/client/promise"
 import { createClientConnection, createPtyClient, type ClientConnectionStatus } from "@opencode-ai/client/solid"
 import { createGlobalEmitter } from "@solid-primitives/event-bus"
-import { type Accessor, onCleanup } from "solid-js"
+import { type Accessor, createEffect, on, onCleanup } from "solid-js"
 import { createApiForServer, type ServerApi } from "@/runtime/server/api"
 import { usePlatform } from "@/runtime/platform/platform"
 import { ServerConnection } from "./registry"
@@ -74,8 +74,18 @@ type ServerSDKBase = {
 function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerScope): ServerSDKBase {
   const platform = usePlatform()
   const transport = createServerTransport({ http: server.http, fetch: platform.fetch })
+  if (server.type === "ssh") {
+    createEffect(
+      on(
+        () => `${server.http.url}\0${server.http.password ?? ""}`,
+        () => transport.update(server.http),
+        { defer: true },
+      ),
+    )
+  }
   const events = createOpenCodeEventSource()
-  const reconnect = server.type === "sidecar" && server.variant === "base" ? server.reconnect : undefined
+  const reconnect =
+    server.type === "ssh" || (server.type === "sidecar" && server.variant === "base") ? server.reconnect : undefined
 
   const connection = createClientConnection(transport.api, {
     reconnect: reconnect ? async (signal) => transport.update(await reconnect(signal)) : undefined,

packages/app/src/runtime/server/global-sync/child-store.ts

@@ -255,7 +255,7 @@ export function createChildStoreManager(input: {
           disposers.set(key, dispose)
           activationToggles.set(key, setInstanceQueriesEnabled)
 
-          const onPersistedInit = (init: Promise<string> | string | null, run: () => void) => {
+          const onPersistedInit = (init: Promise<string | null> | string | null, run: () => void) => {
             if (!(init instanceof Promise)) return
             void init.then(() => {
               if (children[key] !== child) return

packages/app/src/runtime/server/health.ts

@@ -5,7 +5,7 @@ import { ClientError, OpenCode } from "@opencode-ai/client"
 import { Accessor, createEffect, onCleanup } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
 
-export type ServerHealth = { healthy: boolean; version?: string; incompatible?: boolean }
+export type ServerHealth = { healthy: boolean; version?: string; incompatible?: boolean; checking?: boolean }
 
 interface CheckServerHealthOptions {
   timeoutMs?: number
@@ -142,25 +142,45 @@ export function useCheckServerHealth() {
 }
 
 export const useServerHealth = (servers: Accessor<ServerConnection.Any[]>, enabled: Accessor<boolean>) => {
-  const checkServerHealth = useCheckServerHealth()
+  return createServerHealth(servers, enabled, useCheckServerHealth())
+}
+
+export function createServerHealth(
+  servers: Accessor<ServerConnection.Any[]>,
+  enabled: Accessor<boolean>,
+  check: (http: ServerConnection.HttpBase) => Promise<ServerHealth>,
+) {
   const [status, setStatus] = createStore({} as Record<ServerConnection.Key, ServerHealth | undefined>)
+  const endpoints = new Map<ServerConnection.Key, string>()
 
   createEffect(() => {
     if (!enabled()) {
+      endpoints.clear()
       setStatus(reconcile({}))
       return
     }
-    const list = servers()
+    // Snapshot transport fields synchronously so a newly established SSH tunnel
+    // invalidates both the old result and any probe still using the old endpoint.
+    const list = servers().map((conn) => ({ key: ServerConnection.key(conn), type: conn.type, http: conn.http }))
+    for (const conn of list) {
+      const endpoint = cacheKey(conn.http)
+      if (conn.type === "ssh" && endpoints.get(conn.key) !== endpoint) {
+        setStatus(conn.key, reconcile({ healthy: false, checking: true }))
+      }
+      endpoints.set(conn.key, endpoint)
+    }
+    for (const key of endpoints.keys()) {
+      if (!list.some((conn) => conn.key === key)) endpoints.delete(key)
+    }
     let dead = false
 
     const refresh = async () => {
       const results: Record<string, ServerHealth> = {}
       await Promise.all(
         list.map(async (conn) => {
-          const key = ServerConnection.key(conn)
-          const result = await checkServerHealth(conn.http)
-          results[key] = result
-          if (!dead) setStatus(key, result)
+          const result = await check(conn.http)
+          results[conn.key] = result
+          if (!dead) setStatus(conn.key, reconcile(result))
         }),
       )
       if (dead) return

packages/app/src/runtime/server/registry.tsx

@@ -24,6 +24,7 @@ export function normalizeServerUrl(input: string) {
 export function serverName(conn?: ServerConnection.Any, ignoreDisplayName = false) {
   if (!conn) return ""
   if (conn.displayName && !ignoreDisplayName) return conn.displayName
+  if (conn.type === "ssh") return conn.host
   return conn.http.url.replace(/^https?:\/\//, "").replace(/\/+$/, "")
 }
 
@@ -159,9 +160,12 @@ export namespace ServerConnection {
   // Remote server desktop can SSH into
   export type Ssh = {
     type: "ssh"
+    connecting?: boolean
+    id?: string
     host: string
     // SSH client exposes an HTTP server for the app to use as a proxy
     http: HttpBase
+    reconnect?: (signal: AbortSignal) => Promise<HttpBase>
   } & Base
 
   export type Any =
@@ -178,7 +182,7 @@ export namespace ServerConnection {
         return Key.make("sidecar")
       }
       case "ssh":
-        return Key.make(`ssh:${conn.host}`)
+        return Key.make(`ssh:${conn.id ?? conn.host}`)
     }
   }
 

packages/app/src/runtime/server/request-queue.test.ts

@@ -1,7 +1,13 @@
 import { describe, expect, test } from "bun:test"
-import { createRequestQueue, isSlowRequest } from "./request-queue"
+import { createRequestQueue, isSetupRequest, isSlowRequest } from "./request-queue"
 
-function setup(input?: { limit?: number; slowLimit?: number; stallMs?: number; headersTimeoutMs?: number }) {
+function setup(input?: {
+  limit?: number
+  slowLimit?: number
+  stallMs?: number
+  headersTimeoutMs?: number
+  setupHeadersTimeoutMs?: number
+}) {
   const pending: Array<{ url: string; signal: AbortSignal; resolve: () => void }> = []
   const logs: Array<{ message: string; data: Record<string, unknown> }> = []
   let clock = 0
@@ -10,12 +16,13 @@ function setup(input?: { limit?: number; slowLimit?: number; stallMs?: number; h
     slowLimit: input?.slowLimit,
     stallMs: input?.stallMs,
     headersTimeoutMs: input?.headersTimeoutMs,
+    setupHeadersTimeoutMs: input?.setupHeadersTimeoutMs,
     now: () => clock,
     log: (message, data) => logs.push({ message, data }),
     fetch: Object.assign(
-      (resource: RequestInfo | URL) =>
+      (resource: RequestInfo | URL, init?: RequestInit) =>
         new Promise<Response>((resolve, reject) => {
-          const request = new Request(resource)
+          const request = new Request(resource, init)
           request.signal.addEventListener("abort", () => reject(request.signal.reason), { once: true })
           pending.push({ url: request.url, signal: request.signal, resolve: () => resolve(new Response("ok")) })
         }),
@@ -43,7 +50,12 @@ describe("createRequestQueue", () => {
 
   test("slow endpoints hold at most their share of slots so small reads go first", async () => {
     const input = setup({ limit: 4, slowLimit: 2 })
-    const paths = ["/api/vcs?location[directory]=%2Fa", "/api/vcs/diff?location[directory]=%2Fa", "/api/worktree", "/api/session/ses_1"]
+    const paths = [
+      "/api/vcs?location[directory]=%2Fa",
+      "/api/vcs/diff?location[directory]=%2Fa",
+      "/api/worktree",
+      "/api/session/ses_1",
+    ]
     const responses = paths.map((path) => input.queue.fetch(`http://server${path}`))
     await input.settle()
     const started = () => input.pending.map((item) => new URL(item.url).pathname)
@@ -109,6 +121,26 @@ describe("createRequestQueue", () => {
     expect(input.queue.inflight()).toBe(0)
   })
 
+  test("worktree creation gets the setup deadline while worktree reads keep the normal one", async () => {
+    const input = setup({ limit: 4, headersTimeoutMs: 10, setupHeadersTimeoutMs: 200 })
+    const create = input.queue.fetch("http://server/api/worktree?location[directory]=%2Fa", { method: "POST" })
+    const list = input.queue.fetch("http://server/api/worktree?location[directory]=%2Fa")
+    const listError = await list.catch((cause: unknown) => cause)
+    expect((listError as DOMException).name).toBe("TimeoutError")
+    // Past the normal deadline, the create is still on the wire.
+    expect(input.pending[0]!.signal.aborted).toBe(false)
+    input.pending[0]!.resolve()
+    await expect(create).resolves.toBeInstanceOf(Response)
+    expect(input.queue.inflight()).toBe(0)
+  })
+
+  test("only worktree creation counts as a setup request", () => {
+    expect(isSetupRequest("POST", "/api/worktree")).toBe(true)
+    expect(isSetupRequest("GET", "/api/worktree")).toBe(false)
+    expect(isSetupRequest("POST", "/api/worktree/refresh")).toBe(false)
+    expect(isSetupRequest("DELETE", "/api/worktree")).toBe(false)
+  })
+
   test("caller aborts still reach the underlying request", async () => {
     const input = setup({ limit: 1 })
     const controller = new AbortController()

packages/app/src/runtime/server/request-queue.ts

@@ -19,16 +19,26 @@ export const requestStallMs = 2_000
 // instead of wedging every later API call; the body may still stream for as long as it needs.
 export const requestHeadersTimeoutMs = 60_000
 
+// Creating a worktree runs the project's setup script (dependency installs, fetches) before the
+// server answers, so it needs a budget measured in minutes rather than seconds. Cutting it off
+// kills the script midway and leaves a registered but half-initialised worktree behind.
+export const setupRequestHeadersTimeoutMs = 10 * 60_000
+
 export function isSlowRequest(pathname: string) {
   return slowRequestPaths.some((path) => pathname === path || pathname.startsWith(`${path}/`))
 }
 
+export function isSetupRequest(method: string, pathname: string) {
+  return method === "POST" && pathname === "/api/worktree"
+}
+
 export function createRequestQueue(input: {
   fetch: typeof globalThis.fetch
   limit?: number
   slowLimit?: number
   stallMs?: number
   headersTimeoutMs?: number
+  setupHeadersTimeoutMs?: number
   log?: (message: string, data: Record<string, unknown>) => void
   now?: () => number
 }) {
@@ -36,6 +46,7 @@ export function createRequestQueue(input: {
   const slowLimit = input.slowLimit ?? requestQueueSlowLimit
   const stallMs = input.stallMs ?? requestStallMs
   const headersTimeoutMs = input.headersTimeoutMs ?? requestHeadersTimeoutMs
+  const setupHeadersTimeoutMs = input.setupHeadersTimeoutMs ?? setupRequestHeadersTimeoutMs
   // Call the browser fetch unbound; `input.fetch(...)` would make `this` the options object.
   const base = input.fetch
   const now = input.now ?? Date.now
@@ -101,7 +112,7 @@ export function createRequestQueue(input: {
       request.signal.addEventListener("abort", () => controller.abort(request.signal.reason), { once: true })
       const timer = setTimeout(
         () => controller.abort(new DOMException("Timed out waiting for the server to respond", "TimeoutError")),
-        headersTimeoutMs,
+        isSetupRequest(request.method, pathname) ? setupHeadersTimeoutMs : headersTimeoutMs,
       )
       return base(new Request(request, { signal: controller.signal })).finally(() => {
         clearTimeout(timer)

packages/app/src/servers/registry/controller.ts

@@ -58,6 +58,7 @@ export function useServerActionsController() {
   const remove = async (key: ServerConnection.Key) => {
     try {
       if (key.startsWith("wsl:")) await platform.wslServers?.removeServer(key)
+      if (key.startsWith("ssh:")) await platform.sshServers?.forget(key.slice(4))
       tabs.removeServer(key)
       server.remove(key)
       if ((await platform.getDefaultServer?.()) === key) await defaults.set(null)

packages/app/src/servers/registry/row-menu.tsx

@@ -5,6 +5,7 @@ import { type Component, Show } from "solid-js"
 import type { ServerActionsController } from "@/servers/registry/controller"
 import { useLanguage } from "@/runtime/i18n/language"
 import { ServerConnection } from "@/runtime/server/registry"
+import { SshMenu } from "../ssh/menu"
 
 export const ServerRowMenu: Component<{
   server: ServerConnection.Any
@@ -15,6 +16,7 @@ export const ServerRowMenu: Component<{
 }> = (props) => {
   const language = useLanguage()
   const key = ServerConnection.key(props.server)
+  if (props.server.type === "ssh" && props.server.id) return <SshMenu id={props.server.id} domain={props.domain} />
   return (
     <ServerRowMenuView
       server={props.server}

packages/app/src/servers/registry/row.stories.tsx

@@ -0,0 +1,30 @@
+import { For } from "solid-js"
+import { ServerHealthIndicator } from "./row"
+import type { ServerHealth } from "@/runtime/server/health"
+
+const states: { label: string; connecting?: boolean; health?: ServerHealth }[] = [
+  { label: "Connecting (previous health check failed)", connecting: true, health: { healthy: false } },
+  { label: "Tunnel ready, checking its new endpoint", health: { healthy: false, checking: true } },
+  { label: "Connected", health: { healthy: true } },
+  { label: "Failed", health: { healthy: false } },
+  { label: "Incompatible", health: { healthy: false, incompatible: true } },
+  { label: "Not checked" },
+]
+
+export default { title: "App/Servers/Health indicator", id: "app-server-health" }
+export const States = {
+  render: () => (
+    <div class="flex flex-col gap-4">
+      <For each={states}>
+        {(state) => (
+          <div class="flex items-center gap-2">
+            <div class="flex size-4 shrink-0 items-center justify-center">
+              <ServerHealthIndicator health={state.health} connecting={state.connecting} />
+            </div>
+            <span>{state.label}</span>
+          </div>
+        )}
+      </For>
+    </div>
+  ),
+}

packages/app/src/servers/registry/row.tsx

@@ -1,5 +1,7 @@
 import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { Icon } from "@opencode-ai/ui/icon"
+import { Spinner } from "@opencode-ai/ui/spinner"
+import { useLanguage } from "@/runtime/i18n/language"
 import { createResizeObserver } from "@solid-primitives/resize-observer"
 import {
   children,
@@ -102,22 +104,36 @@ export function ServerRow(props: ServerRowProps) {
   )
 }
 
-export function ServerHealthIndicator(props: { health?: ServerHealth }) {
+export function ServerHealthIndicator(props: { health?: ServerHealth; connecting?: boolean }) {
+  const language = useLanguage()
   return (
     <Show
-      when={props.health?.incompatible}
+      when={props.connecting || props.health?.checking}
       fallback={
-        <div
-          classList={{
-            "size-1.5 rounded-full shrink-0 my-[3.5px]": true,
-            "bg-icon-success-base": props.health?.healthy === true,
-            "bg-icon-critical-base": props.health?.healthy === false,
-            "bg-border-weak-base": props.health === undefined,
-          }}
-        />
+        <Show
+          when={props.health?.incompatible}
+          fallback={
+            <div
+              classList={{
+                "size-1.5 rounded-full shrink-0 my-[3.5px]": true,
+                "bg-icon-success-base": props.health?.healthy === true,
+                "bg-icon-critical-base": props.health?.healthy === false,
+                "bg-border-weak-base": props.health === undefined,
+              }}
+            />
+          }
+        >
+          <Icon name="warning" size="small" class="shrink-0 text-icon-warning-base" />
+        </Show>
       }
     >
-      <Icon name="warning" size="small" class="shrink-0 text-icon-warning-base" />
+      <span
+        role="status"
+        aria-label={language.t("ssh.stage.connecting")}
+        class="inline-flex h-3.5 w-1.5 shrink-0 items-center justify-center text-v2-icon-icon-muted"
+      >
+        <Spinner class="size-3 shrink-0" />
+      </span>
     </Show>
   )
 }

packages/app/src/servers/ssh/banner.tsx

@@ -0,0 +1,45 @@
+import { Button } from "@opencode-ai/ui/button"
+import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { createMemo, Show } from "solid-js"
+import { useCurrentRoute } from "@/shell/state/layout"
+import { useTabs } from "@/shell/tabs/tabs"
+import { useLanguage } from "@/runtime/i18n/language"
+import { useSshServers } from "./context"
+import { DialogSsh } from "./dialog"
+import { sshName } from "./name"
+
+export function SshBanner() {
+  const ssh = useSshServers()
+  const route = useCurrentRoute()
+  const tabs = useTabs()
+  const language = useLanguage()
+  const dialog = useDialog()
+  const item = createMemo(() => {
+    const current = route()
+    const key =
+      current.type === "session"
+        ? current.server
+        : current.type === "draft"
+          ? tabs.store.find((tab) => tab.type === "draft" && tab.draftID === current.draftID)?.server
+          : undefined
+    return ssh.data?.servers.find((item) => `ssh:${item.config.id}` === key && item.stage !== "ready")
+  })
+  return (
+    <Show when={item()}>
+      {(item) => (
+        <div class="ssh-banner" role="status" aria-live="polite">
+          <span>
+            {language.t("ssh.offline", { host: sshName(item().config) })} {language.t(`ssh.stage.${item().stage}`)}
+          </span>
+          <Button
+            size="small"
+            variant="ghost-muted"
+            onClick={() => void dialog.push(() => <DialogSsh config={item().config} connect />)}
+          >
+            {language.t(item().stage === "authentication" ? "ssh.authenticate" : "ssh.retry")}
+          </Button>
+        </div>
+      )}
+    </Show>
+  )
+}

packages/app/src/servers/ssh/context.tsx

@@ -0,0 +1,26 @@
+import { createSimpleContext } from "@opencode-ai/ui/context"
+import { queryOptions, useQuery, useQueryClient } from "@tanstack/solid-query"
+import { createEffect, onCleanup } from "solid-js"
+import { usePlatform } from "@/runtime/platform/platform"
+import type { SshState } from "./types"
+
+const key = ["platform", "sshServers"] as const
+export const { use: useSshServers, provider: SshServersProvider } = createSimpleContext({
+  name: "SshServers",
+  init: () => {
+    const platform = usePlatform()
+    const client = useQueryClient()
+    const query = useQuery(() =>
+      queryOptions<SshState>({
+        queryKey: key,
+        queryFn: () => platform.sshServers?.getState() ?? Promise.resolve({ servers: [] }),
+        staleTime: Infinity,
+      }),
+    )
+    createEffect(() => {
+      const off = platform.sshServers?.subscribe((state) => client.setQueryData(key, state))
+      if (off) onCleanup(off)
+    })
+    return query
+  },
+})

packages/app/src/servers/ssh/dialog.stories.tsx

@@ -0,0 +1,123 @@
+import { Button } from "@opencode-ai/ui/button"
+import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
+import { onCleanup, onMount } from "solid-js"
+import { PlatformProvider } from "@/runtime/platform/platform"
+import { SshServersProvider } from "./context"
+import { DialogSsh } from "./dialog"
+import type { SshItem, SshPlatform, SshState } from "./types"
+
+function Fixture(props: { initial?: "connecting" | "password" | "confirmation" | "failure"; responseDelay?: number }) {
+  const state: { item?: SshItem; step: number; timer?: ReturnType<typeof setTimeout> } = { step: 0 }
+  onCleanup(() => clearTimeout(state.timer))
+  const listeners = new Set<(state: SshState) => void>()
+  const snapshot = (): SshState => ({ servers: state.item ? [state.item] : [] })
+  const update = (changes: Partial<SshItem>) => {
+    if (!state.item) return
+    state.item = { ...state.item, ...changes }
+    listeners.forEach((listener) => listener(snapshot()))
+  }
+  const prompts = [
+    {
+      id: "host-key",
+      text: "The authenticity of host 'dev.example.com' can't be established.\nED25519 key fingerprint is SHA256:EXAMPLE-FINGERPRINT-FOR-STORY-ONLY.\nAre you sure you want to continue connecting?",
+      confirm: true,
+    },
+    { id: "password", text: "brendon@dev.example.com's password:", confirm: false },
+    { id: "otp", text: "Verification code:", confirm: false },
+  ]
+  const api: SshPlatform = {
+    getState: async () => snapshot(),
+    subscribe(callback) {
+      listeners.add(callback)
+      return () => {
+        listeners.delete(callback)
+      }
+    },
+    hosts: async () => ["devbox", "staging", "build-host"],
+    start: async (input) => {
+      clearTimeout(state.timer)
+      state.step = props.initial === "password" ? 1 : 0
+      state.item = {
+        config: input,
+        saved: false,
+        stage: "connecting",
+        detail: "",
+        destination: "brendon@dev.example.com:22",
+      }
+      if (props.initial === "connecting") return
+      update(
+        props.initial === "failure"
+          ? {
+              stage: "failed",
+              error: "connection",
+              detail: "ssh: connect to host dev.example.com port 22: Connection refused",
+            }
+          : { stage: "authentication", prompt: prompts[state.step] },
+      )
+    },
+    respond: async () => {
+      const next = () => {
+        state.step += 1
+        update(
+          state.step < prompts.length
+            ? { stage: "authentication", prompt: prompts[state.step] }
+            : { stage: "ready", prompt: undefined },
+        )
+      }
+      if (!props.responseDelay) return next()
+      update({ stage: "connecting", prompt: undefined })
+      state.timer = setTimeout(next, props.responseDelay)
+    },
+    resolve: async () => null,
+    disconnect: async () => {
+      clearTimeout(state.timer)
+      update({ stage: "disconnected", prompt: undefined })
+    },
+    forget: async () => {
+      state.item = undefined
+      listeners.forEach((listener) => listener(snapshot()))
+    },
+    openConfig: async () => {},
+  }
+  return (
+    <PlatformProvider
+      value={{
+        platform: "desktop",
+        windowID: "ssh-story",
+        sshServers: api,
+        openExternal() {},
+        restart: async () => {},
+        notify: async () => {},
+        openDirectoryPickerDialog: async () => null,
+      }}
+    >
+      <QueryClientProvider client={new QueryClient()}>
+        <SshServersProvider>
+          <Open initial={props.initial} />
+        </SshServersProvider>
+      </QueryClientProvider>
+    </PlatformProvider>
+  )
+}
+
+function Open(props: { initial?: string }) {
+  const dialog = useDialog()
+  const open = () =>
+    dialog.show(() => (
+      <DialogSsh
+        config={props.initial ? { id: "story", target: "devbox", name: "Development" } : undefined}
+        connect={!!props.initial}
+      />
+    ))
+  onMount(open)
+  return <Button onClick={open}>Open SSH connection</Button>
+}
+
+export default { title: "App/Dialogs/SSH", id: "app-dialog-ssh" }
+export const Host = { render: () => <Fixture /> }
+export const Connecting = { render: () => <Fixture initial="connecting" /> }
+export const Password = { render: () => <Fixture initial="password" /> }
+export const SlowPassword = { render: () => <Fixture initial="password" responseDelay={5000} /> }
+export const Confirmation = { render: () => <Fixture initial="confirmation" /> }
+export const Failure = { render: () => <Fixture initial="failure" /> }

packages/app/src/servers/ssh/dialog.tsx

@@ -0,0 +1,274 @@
+import { Button } from "@opencode-ai/ui/button"
+import { Dialog, DialogBody, DialogFooter, DialogHeader, DialogTitle } from "@opencode-ai/ui/dialog"
+import { Divider } from "@opencode-ai/ui/divider"
+import { TextInput } from "@opencode-ai/ui/text-input"
+import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { createEffect, createMemo, onCleanup, onMount, Show } from "solid-js"
+import { createStore } from "solid-js/store"
+import { Effect, Fiber } from "effect"
+import { useLanguage } from "@/runtime/i18n/language"
+import { usePlatform } from "@/runtime/platform/platform"
+import { ServerConnection, useServers } from "@/runtime/server/registry"
+import { useTabs } from "@/shell/tabs/tabs"
+import { useDirectoryPicker } from "@/workspaces/selection/picker"
+import { useSshServers } from "./context"
+import type { SshConfig, SshItem } from "./types"
+import { sshName } from "./name"
+import { isSshConnecting } from "./status"
+import "@/settings/settings.css"
+import "./ssh.css"
+
+export function useOpenSshProject() {
+  const servers = useServers()
+  const picker = useDirectoryPicker()
+  const tabs = useTabs()
+  const language = useLanguage()
+  return (id: string) => {
+    const server = servers.list.find((server) => server.type === "ssh" && server.id === id)
+    if (!server) return
+    picker({
+      server,
+      title: language.t("ssh.project", { host: server.displayName || (server.type === "ssh" ? server.host : "") }),
+      onSelect: (value) => {
+        const directory = Array.isArray(value) ? value[0] : value
+        if (!directory) return
+        const key = ServerConnection.key(server)
+        servers.projects.forServer(key).open(directory)
+        void tabs.newDraft({ server: key, directory })
+      },
+    })
+  }
+}
+
+export function DialogSsh(props: { config?: SshConfig; connect?: boolean; openProject?: boolean }) {
+  const dialog = useDialog()
+  const language = useLanguage()
+  const platform = usePlatform()
+  const ssh = useSshServers()
+  // Entry-point behavior is fixed for the lifetime of this dialog. Settings
+  // connects without needing the project/tab contexts used by the palette.
+  const openProject = props.openProject ? useOpenSshProject() : undefined
+  const id = props.config?.id ?? crypto.randomUUID()
+  let cancelButton: HTMLButtonElement | undefined
+  const [state, setState] = createStore({
+    target: props.config?.target ?? "",
+    name: props.config?.name ?? "",
+    started: false,
+    prompted: false,
+    response: "",
+    answered: "",
+    submitting: false,
+    complete: false,
+    error: false,
+  })
+  let task: Fiber.Fiber<void> | undefined
+  const runAction = (effect: Effect.Effect<unknown, unknown>) => {
+    setState({ submitting: true, error: false })
+    task = Effect.runFork(
+      effect.pipe(
+        Effect.asVoid,
+        Effect.catch(() => Effect.sync(() => setState("error", true))),
+        Effect.ensuring(Effect.sync(() => setState("submitting", false))),
+      ),
+    )
+  }
+  const item = createMemo(() => ssh.data?.servers.find((item) => item.config.id === id))
+  const error = createMemo(() => {
+    if (state.error) return language.t("common.requestFailed")
+    const error = item()?.error
+    return error ? language.t(`ssh.error.${error}`) : undefined
+  })
+  const busy = createMemo(
+    () => state.submitting || (state.started && !state.error && isSshConnecting(item()?.stage ?? "connecting")),
+  )
+  const prompt = createMemo<SshItem["prompt"]>((previous) => item()?.prompt ?? (busy() ? previous : undefined))
+  const waiting = () => busy() || (!state.error && state.answered === prompt()?.id)
+  const start = (replace = false) => {
+    const api = platform.sshServers
+    if (!api || busy() || !state.target.trim()) return
+    setState({ started: true, prompted: !!prompt() })
+    runAction(
+      Effect.gen(function* () {
+        yield* Effect.tryPromise(() => api.start({ id, target: state.target, name: state.name, replace }))
+        yield* Effect.tryPromise(() => ssh.refetch())
+      }),
+    )
+  }
+  const respond = () => {
+    const current = item()?.prompt
+    const api = platform.sshServers
+    if (!current || waiting() || !api || (!current.confirm && !state.response)) return
+    setState("answered", current.id)
+    runAction(Effect.tryPromise(() => api.respond(id, current.id, current.confirm ? "yes" : state.response)))
+  }
+  createEffect(() => {
+    prompt()?.id
+    setState("response", "")
+    if (prompt()) setState("prompted", true)
+    // Never let a focused Continue button become Trust between SSH challenges.
+    if (prompt()?.confirm) queueMicrotask(() => cancelButton?.focus())
+  })
+  createEffect(() => {
+    if (!state.started || item()?.stage !== "ready" || state.submitting || state.complete) return
+    setState("complete", true)
+    dialog.close()
+    if (openProject) queueMicrotask(() => openProject(id))
+  })
+  onMount(() => {
+    if (props.connect) start()
+  })
+  onCleanup(() => {
+    const api = platform.sshServers
+    const cancel = state.started && !state.complete
+    const forget = !props.config && !item()?.saved
+    Effect.runFork(
+      Effect.gen(function* () {
+        if (task) yield* Fiber.interrupt(task)
+        if (!cancel || !api) return
+        yield* Effect.tryPromise(() => api.disconnect(id))
+        if (forget) yield* Effect.tryPromise(() => api.forget(id))
+      }).pipe(Effect.ignore),
+    )
+  })
+  const keyDown = (event: KeyboardEvent) => {
+    if (event.key !== "Enter" || event.isComposing) return
+    event.preventDefault()
+    if (prompt()) return
+    start(item()?.stage === "incompatible")
+  }
+  return (
+    <Dialog fit class="settings-server-dialog">
+      <DialogHeader hideClose={true}>
+        <DialogTitle>
+          {state.prompted || props.config
+            ? language.t("ssh.connectTo", { host: sshName(state) })
+            : language.t("ssh.add")}
+        </DialogTitle>
+      </DialogHeader>
+      <Divider />
+      <DialogBody class="flex w-full min-w-0 flex-1 flex-col px-4 pt-4 pb-2">
+        <div class="flex w-full min-w-0 flex-col gap-6">
+          <Show when={!state.prompted || (!!error() && !prompt())}>
+            <div class="flex w-full min-w-0 flex-col gap-2">
+              <label class="settings-server-dialog-label" for="ssh-target">
+                {language.t("ssh.target")}
+              </label>
+              <TextInput
+                id="ssh-target"
+                type="text"
+                appearance="large"
+                class="!w-full self-stretch"
+                dir="ltr"
+                value={state.target}
+                autofocus
+                placeholder={language.t("ssh.placeholder")}
+                spellcheck={false}
+                autocomplete="off"
+                disabled={busy() || !!prompt()}
+                invalid={!!error()}
+                onInput={(event) => setState("target", event.currentTarget.value)}
+                onKeyDown={keyDown}
+              />
+            </div>
+            <div class="flex w-full min-w-0 flex-col gap-2">
+              <label class="settings-server-dialog-label" for="ssh-name">
+                {language.t("dialog.server.add.name")}
+              </label>
+              <TextInput
+                id="ssh-name"
+                type="text"
+                appearance="large"
+                class="!w-full self-stretch"
+                dir="auto"
+                value={state.name}
+                placeholder={language.t("dialog.server.add.namePlaceholder")}
+                disabled={busy() || !!prompt()}
+                onInput={(event) => setState("name", event.currentTarget.value)}
+                onKeyDown={keyDown}
+              />
+            </div>
+          </Show>
+          <Show when={prompt()} keyed>
+            {(prompt) => (
+              <div class="flex w-full min-w-0 flex-col gap-2">
+                <pre id="ssh-prompt" class="ssh-prompt" dir="auto">
+                  {prompt.text}
+                </pre>
+                <Show when={!prompt.confirm}>
+                  <TextInput
+                    id="ssh-response"
+                    aria-labelledby="ssh-prompt"
+                    ref={(element) =>
+                      queueMicrotask(() => {
+                        if (element.isConnected) element.focus()
+                      })
+                    }
+                    type="password"
+                    appearance="large"
+                    class="!w-full self-stretch"
+                    autofocus
+                    value={state.response}
+                    autocomplete="off"
+                    spellcheck={false}
+                    disabled={waiting()}
+                    onInput={(event) => setState("response", event.currentTarget.value)}
+                    onKeyDown={(event) => {
+                      if (event.key === "Enter" && !event.isComposing) {
+                        event.preventDefault()
+                        respond()
+                      }
+                    }}
+                  />
+                </Show>
+              </div>
+            )}
+          </Show>
+          <Show when={error()}>
+            {(error) => (
+              <span class="settings-server-dialog-error !leading-[var(--line-height-compact)]" role="alert">
+                {error()}
+              </span>
+            )}
+          </Show>
+        </div>
+      </DialogBody>
+      <DialogFooter>
+        <Button
+          ref={(element: HTMLButtonElement) => {
+            cancelButton = element
+          }}
+          variant="neutral"
+          onClick={() => dialog.close()}
+        >
+          {language.t("common.cancel")}
+        </Button>
+        <Show
+          when={prompt()}
+          fallback={
+            <Button
+              variant="contrast"
+              disabled={busy() || !state.target.trim()}
+              onClick={() => start(item()?.stage === "incompatible")}
+            >
+              {busy()
+                ? language.t("ssh.stage.connecting")
+                : item()?.stage === "incompatible"
+                  ? language.t("ssh.update")
+                  : props.config
+                    ? language.t("ssh.connect")
+                    : language.t("dialog.server.add.button")}
+            </Button>
+          }
+        >
+          {(prompt) => (
+            <Button variant="contrast" disabled={waiting() || (!prompt().confirm && !state.response)} onClick={respond}>
+              {waiting()
+                ? language.t("ssh.stage.connecting")
+                : language.t(prompt().confirm ? "ssh.trust" : "ssh.continue")}
+            </Button>
+          )}
+        </Show>
+      </DialogFooter>
+    </Dialog>
+  )
+}

packages/app/src/servers/ssh/menu.tsx

@@ -0,0 +1,59 @@
+import { Icon } from "@opencode-ai/ui/icon"
+import { IconButton } from "@opencode-ai/ui/icon-button"
+import { Menu } from "@opencode-ai/ui/menu"
+import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { Show } from "solid-js"
+import { useLanguage } from "@/runtime/i18n/language"
+import type { ServerActionsController } from "@/servers/registry/controller"
+import { ServerConnection } from "@/runtime/server/registry"
+import { useSshServers } from "./context"
+import { DialogSsh } from "./dialog"
+
+export function SshMenu(props: { id: string; domain: ServerActionsController }) {
+  const ssh = useSshServers()
+  const language = useLanguage()
+  const dialog = useDialog()
+  const item = () => ssh.data?.servers.find((item) => item.config.id === props.id)
+  const key = () => ServerConnection.Key.make(`ssh:${props.id}`)
+  return (
+    <Show when={item()}>
+      {(item) => (
+        <Menu gutter={4} modal={false} placement="bottom-end">
+          <Menu.Trigger
+            as={IconButton}
+            variant="ghost-muted"
+            size="small"
+            icon={<Icon name="outline-dots" />}
+            aria-label={language.t("common.moreOptions")}
+          />
+          <Menu.Portal>
+            <Menu.Content>
+              <Menu.Group>
+                <Menu.GroupLabel>{language.t("ssh.server.menu.label")}</Menu.GroupLabel>
+                <Show when={item().stage !== "ready"}>
+                  <Menu.Item onSelect={() => void dialog.push(() => <DialogSsh config={item().config} connect />)}>
+                    {language.t(item().stage === "authentication" ? "ssh.authenticate" : "ssh.connect")}
+                  </Menu.Item>
+                </Show>
+                <Show when={props.domain.defaults.available() && props.domain.defaults.key() !== key()}>
+                  <Menu.Item onSelect={() => props.domain.defaults.set(key())}>
+                    {language.t("dialog.server.menu.default")}
+                  </Menu.Item>
+                </Show>
+                <Show when={props.domain.defaults.available() && props.domain.defaults.key() === key()}>
+                  <Menu.Item onSelect={() => props.domain.defaults.set(null)}>
+                    {language.t("dialog.server.menu.defaultRemove")}
+                  </Menu.Item>
+                </Show>
+                <Menu.Separator />
+                <Menu.Item onSelect={() => void props.domain.connection.remove(key())}>
+                  {language.t("dialog.server.menu.delete")}
+                </Menu.Item>
+              </Menu.Group>
+            </Menu.Content>
+          </Menu.Portal>
+        </Menu>
+      )}
+    </Show>
+  )
+}

packages/app/src/servers/ssh/name.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "bun:test"
+import { sshHostname, sshName } from "./name"
+
+test.each([
+  ["brendan-box.exe.xyz", "brendan-box.exe.xyz"],
+  ["ssh brendan-box.exe.xyz", "brendan-box.exe.xyz"],
+  ["ssh anomaly@brendan-box.exe.xyz", "brendan-box.exe.xyz"],
+  ['ssh -p 2222 -i "/keys/my key" -J jump@example.com anomaly@devbox', "devbox"],
+  ["ssh -o 'ProxyCommand=ssh jump -W %h:%p' 'anomaly@devbox'", "devbox"],
+  ["  ssh 'brendan-'box.exe.xyz  ", "brendan-box.exe.xyz"],
+  ["ssh user@[2001:db8::1]", "[2001:db8::1]"],
+  ["", ""],
+])("uses the hostname from %s", (target, hostname) => {
+  expect(sshHostname(target)).toBe(hostname)
+  expect(sshName({ target, name: "" })).toBe(hostname)
+})
+
+test("preserves custom names and the original command", () => {
+  const config = { name: "Development", target: "ssh -p 2222 anomaly@devbox" }
+  expect(sshName(config)).toBe("Development")
+  expect(config.target).toBe("ssh -p 2222 anomaly@devbox")
+})

packages/app/src/servers/ssh/name.ts

@@ -0,0 +1,16 @@
+import type { SshConfig } from "./types"
+
+export function sshHostname(target: string) {
+  // Accepted SSH targets end with a hostname or user@hostname, never a remote
+  // command. Strip shell quoting for display only; keep the saved target intact.
+  return (
+    (target.trim().split(/\s+/).at(-1) ?? "")
+      .replace(/["'\\]/g, "")
+      .split("@")
+      .at(-1) ?? ""
+  )
+}
+
+export function sshName(config: Pick<SshConfig, "name" | "target">) {
+  return config.name || sshHostname(config.target)
+}

packages/app/src/servers/ssh/restore-state.ts

@@ -0,0 +1,17 @@
+import { createEffect } from "solid-js"
+import type { SshStart, SshState } from "./types"
+
+export function createSshRestore(input: {
+  state: () => SshState | undefined
+  start: (input: SshStart) => Promise<void> | undefined
+}) {
+  const restored = new Set<string>()
+  createEffect(() => {
+    for (const item of input.state()?.servers ?? []) {
+      if (!item.saved || restored.has(item.config.id)) continue
+      // Mark active connections too, so a later manual disconnect is respected.
+      restored.add(item.config.id)
+      if (item.stage === "disconnected") void input.start({ ...item.config, background: true })
+    }
+  })
+}

packages/app/src/servers/ssh/restore.tsx

@@ -0,0 +1,13 @@
+import { usePlatform } from "@/runtime/platform/platform"
+import { useSshServers } from "./context"
+import { createSshRestore } from "./restore-state"
+
+export function SshRestore() {
+  const platform = usePlatform()
+  const ssh = useSshServers()
+  createSshRestore({
+    state: () => ssh.data,
+    start: (input) => platform.sshServers?.start(input),
+  })
+  return null
+}

packages/app/src/servers/ssh/settings.tsx

@@ -0,0 +1,60 @@
+import { For, Show } from "solid-js"
+import { useLanguage } from "@/runtime/i18n/language"
+import type { ServerCollectionController } from "@/servers/registry/controller"
+import { ServerHealthIndicator } from "@/servers/registry/row"
+import { ServerConnection } from "@/runtime/server/registry"
+import { useSshServers } from "./context"
+import { SshMenu } from "./menu"
+import { Badge } from "@opencode-ai/ui/badge"
+import { sshName } from "./name"
+import { isSshConnecting } from "./status"
+
+export function SshServerSettings(props: { filter: string; domain: ServerCollectionController }) {
+  const ssh = useSshServers()
+  const language = useLanguage()
+  return (
+    <For
+      each={ssh.data?.servers.filter(
+        (item) =>
+          item.saved && `${item.config.name} ${item.config.target}`.toLowerCase().includes(props.filter.toLowerCase()),
+      )}
+    >
+      {(item) => {
+        const key = ServerConnection.Key.make(`ssh:${item.config.id}`)
+        const health = () => props.domain.collection.health()[key]
+        const indicator = () => {
+          if (item.stage === "ready") return health() ?? { healthy: true }
+          if (item.stage === "incompatible") return { healthy: false, incompatible: true }
+          if (item.stage === "failed") return { healthy: false }
+          return undefined
+        }
+        return (
+          <div class="settings-servers-row">
+            <div class="settings-servers-lead">
+              <ServerHealthIndicator health={indicator()} connecting={isSshConnecting(item.stage)} />
+              <div class="settings-servers-copy">
+                <span class="flex min-w-0 items-center gap-1">
+                  <bdi class="settings-servers-name truncate" dir={item.config.name ? "auto" : "ltr"}>
+                    {sshName(item.config)}
+                  </bdi>
+                  <span class="shrink-0 rounded-[3px] border border-v2-border-border-base px-1 py-0.5 text-[9px] leading-none text-v2-text-text-muted">
+                    {language.t("ssh.label")}
+                  </span>
+                </span>
+                <Show when={health()?.version}>
+                  {(version) => <span class="settings-servers-meta">v{version()}</span>}
+                </Show>
+              </div>
+            </div>
+            <div class="settings-servers-actions">
+              <Show when={props.domain.defaults.available() && props.domain.defaults.key() === key}>
+                <Badge>{language.t("dialog.server.status.default")}</Badge>
+              </Show>
+              <SshMenu id={item.config.id} domain={props.domain} />
+            </div>
+          </div>
+        )
+      }}
+    </For>
+  )
+}

packages/app/src/servers/ssh/ssh.css

@@ -0,0 +1,20 @@
+.ssh-prompt {
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  font-family: var(--font-family-mono);
+  font-size: 12px;
+  line-height: var(--line-height-compact);
+  max-height: 200px;
+  overflow: auto;
+  user-select: text;
+}
+.ssh-banner {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 8px 16px;
+  font-size: 12px;
+  line-height: var(--line-height-compact);
+  flex-shrink: 0;
+}

packages/app/src/servers/ssh/status.ts

@@ -0,0 +1,11 @@
+import type { SshItem } from "./types"
+
+export function isSshConnecting(stage: SshItem["stage"]) {
+  return (
+    stage === "connecting" ||
+    stage === "checking" ||
+    stage === "downloading" ||
+    stage === "uploading" ||
+    stage === "starting"
+  )
+}

packages/app/src/servers/ssh/types.ts

@@ -0,0 +1,70 @@
+import { Schema } from "effect"
+export { sshHostname, sshName } from "./name"
+export { isSshConnecting } from "./status"
+
+export const SshConfig = Schema.Struct({ id: Schema.String, target: Schema.String, name: Schema.String })
+export type SshConfig = typeof SshConfig.Type
+export const SshHttp = Schema.Struct({ url: Schema.String, password: Schema.String })
+export type SshHttp = typeof SshHttp.Type
+export const SshStage = Schema.Literals([
+  "disconnected",
+  "connecting",
+  "checking",
+  "downloading",
+  "uploading",
+  "starting",
+  "ready",
+  "authentication",
+  "incompatible",
+  "failed",
+])
+export const SshPrompt = Schema.Struct({
+  id: Schema.String,
+  text: Schema.String,
+  confirm: Schema.Boolean,
+})
+export const SshItem = Schema.Struct({
+  config: SshConfig,
+  saved: Schema.Boolean,
+  destination: Schema.optional(Schema.String),
+  stage: SshStage,
+  http: Schema.optional(SshHttp),
+  prompt: Schema.optional(SshPrompt),
+  detail: Schema.String,
+  error: Schema.optional(
+    Schema.Literals([
+      "connection",
+      "input",
+      "platform",
+      "version",
+      "install",
+      "service",
+      "host-key",
+      "ssh-missing",
+      "unpublished",
+    ]),
+  ),
+})
+export type SshItem = typeof SshItem.Type
+export const SshState = Schema.Struct({ servers: Schema.Array(SshItem) })
+export type SshState = typeof SshState.Type
+export const SshStart = Schema.Struct({
+  id: Schema.String,
+  target: Schema.String,
+  name: Schema.String,
+  replace: Schema.optional(Schema.Boolean),
+  background: Schema.optional(Schema.Boolean),
+})
+export type SshStart = typeof SshStart.Type
+
+export type SshPlatform = {
+  getState(): Promise<SshState>
+  subscribe(callback: (state: SshState) => void): () => void
+  hosts(): Promise<readonly string[]>
+  start(input: SshStart): Promise<void>
+  resolve(id: string): Promise<SshHttp | null>
+  respond(id: string, prompt: string, value: string): Promise<void>
+  disconnect(id: string): Promise<void>
+  forget(id: string): Promise<void>
+  openConfig(): Promise<void>
+}

packages/app/src/servers/wsl/settings.tsx

@@ -16,6 +16,7 @@ import { showToast } from "@/shell/notifications/toast"
 import { DialogAddWslServer } from "./dialog"
 import { useWslServers } from "./context"
 import { wslOpencodeAction, wslRuntimeRetryable } from "./model"
+import { DialogSsh } from "../ssh/dialog"
 
 export function isWslServer(server: ServerConnection.Any) {
   return server.type === "sidecar" && server.variant === "wsl"
@@ -30,7 +31,7 @@ export function AddServerMenu(props: { onAddServer: () => void }) {
   }
   return (
     <Show
-      when={platform.wslServers}
+      when={platform.wslServers || platform.sshServers}
       fallback={
         <Button variant="ghost-muted" icon="plus" onClick={props.onAddServer}>
           {language.t("dialog.server.add.button")}
@@ -44,7 +45,12 @@ export function AddServerMenu(props: { onAddServer: () => void }) {
         <Menu.Portal>
           <Menu.Content>
             <Menu.Item onSelect={props.onAddServer}>{language.t("dialog.server.add.button")}</Menu.Item>
-            <Menu.Item onSelect={openAddWsl}>{language.t("wsl.server.add")}</Menu.Item>
+            <Show when={platform.sshServers}>
+              <Menu.Item onSelect={() => void dialog.push(() => <DialogSsh />)}>{language.t("ssh.add")}</Menu.Item>
+            </Show>
+            <Show when={platform.wslServers}>
+              <Menu.Item onSelect={openAddWsl}>{language.t("wsl.server.add")}</Menu.Item>
+            </Show>
           </Menu.Content>
         </Menu.Portal>
       </Menu>

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

@@ -91,7 +91,7 @@ export function SessionProjectMenu(props: {
               when={props.showProjectIcon}
               fallback={
                 <span class={props.workspace ? "text-v2-icon-icon-accent" : "text-v2-icon-icon-muted"}>
-                  <Icon name={props.workspace ? "workspace-isolated" : "monitor"} />
+                  <Icon name={props.workspace ? "outline-worktree" : "monitor"} />
                 </span>
               }
             >

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

@@ -184,7 +184,7 @@ function WorkspaceMoveAction(props: {
             : "flex h-[46px] w-full items-center gap-2 rounded-b-[6px] px-3 pe-9 pt-2.5 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-muted focus-visible:outline-none"
         }
       >
-        <Icon name="workspace-new" class="shrink-0 text-v2-icon-icon-muted" />
+        <Icon name="outline-worktree" class="shrink-0 text-v2-icon-icon-muted" />
         <span class="min-w-0 truncate">{language.t("workspace.move.title")}</span>
       </SessionWorkspaceMenu>
       <button
@@ -256,7 +256,10 @@ export function SessionSummaryPanel(props: {
           gutter={props.mobile ? 4 : -22}
           class={`${row} hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed`}
         >
-          <Icon name={props.local ? "monitor" : "workspace-isolated"} class="shrink-0 text-v2-icon-icon-muted" />
+          <Icon
+            name={props.local ? "monitor" : "outline-worktree"}
+            class={`shrink-0 ${props.local ? "text-v2-icon-icon-muted" : "text-v2-icon-icon-accent"}`}
+          />
           <span dir="auto" class="min-w-0 flex-1 truncate text-start">
             {location()}
           </span>

packages/app/src/session/timeline/session-workspace-menu.tsx

@@ -7,7 +7,6 @@ import type { Project } from "@/runtime/server/types"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useServerSDK } from "@/runtime/server/client"
 import { useData } from "@/runtime/server/current"
-import { useSettingsDialog } from "@/settings/command"
 import { pathKey } from "@/workspaces/path-key"
 import { showToast } from "@/shell/notifications/toast"
 import { containsDirectory, sameDirectory, workspaceDirectories } from "@/workspaces/paths"
@@ -28,7 +27,6 @@ export function SessionWorkspaceMenu(props: {
   const language = useLanguage()
   const serverSDK = useServerSDK()
   const data = useData()
-  const openWorkspaces = useSettingsDialog("workspaces")
   const [store, setStore] = createStore({ selected: undefined as string | undefined })
   const [directories, setDirectories] = createSignal(workspaceDirectories(props.project))
   const blocked = () => props.eligible === false || data.session.status(props.sessionID) === "running"
@@ -99,13 +97,13 @@ export function SessionWorkspaceMenu(props: {
               </Menu.Item>
             </Show>
             <Menu.Item disabled={!!store.selected || blocked()} onSelect={() => void move("create")}>
-              <Icon name="workspace-new" />
+              <Icon name="plus" />
               {language.t("workspace.new")}
             </Menu.Item>
             <Show when={workspaces().length > 0}>
               <Menu.Sub gutter={0} overlap overflowPadding={8}>
                 <Menu.SubTrigger>
-                  <Icon name="workspace-isolated" />
+                  <Icon name="outline-worktree" />
                   {language.t("session.new.workspace.existing").replace(/(…|\.{3})$/, "")}
                 </Menu.SubTrigger>
                 <Menu.Portal>
@@ -113,7 +111,7 @@ export function SessionWorkspaceMenu(props: {
                     <For each={workspaces()}>
                       {(workspace) => (
                         <Menu.Item disabled={!!store.selected || blocked()} onSelect={() => void move(workspace)}>
-                          <Icon name="workspace-isolated" />
+                          <Icon name="outline-worktree" />
                           <span class="min-w-0 flex-1 truncate">{getFilename(workspace)}</span>
                         </Menu.Item>
                       )}
@@ -123,10 +121,6 @@ export function SessionWorkspaceMenu(props: {
               </Menu.Sub>
             </Show>
           </Menu.Group>
-          <Menu.Separator class="h-[0.5px] bg-v2-border-border-base" />
-          <Menu.Item onSelect={() => openWorkspaces()}>
-            <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
-          </Menu.Item>
         </Menu.Content>
       </Menu.Portal>
     </Menu>

packages/app/src/settings/servers/servers.tsx

@@ -13,6 +13,8 @@ import { ServerConnection, serverName } from "@/runtime/server/registry"
 import { useServerCollectionController } from "@/servers/registry/controller"
 import { DialogServer } from "@/servers/connect/dialog"
 import { SettingsList } from "@/settings/list"
+import { SshServerSettings } from "@/servers/ssh/settings"
+import { useSshServers } from "@/servers/ssh/context"
 import { AddServerMenu, isWslServer, useFilteredWslServers, WslServerSettings } from "@/servers/wsl/settings"
 import "@/settings/settings.css"
 
@@ -22,13 +24,14 @@ export const SettingsServers: Component = () => {
   const controller = useServerCollectionController()
   const [store, setStore] = createStore({ filter: "" })
   const wslServers = useFilteredWslServers(() => store.filter)
+  const ssh = useSshServers()
 
   const showSearch = createMemo(
     () => controller.collection.items().filter((item) => !isWslServer(item)).length + wslServers().length > 1,
   )
 
   const filtered = createMemo(() => {
-    const items = controller.collection.items().filter((item) => !isWslServer(item))
+    const items = controller.collection.items().filter((item) => !isWslServer(item) && item.type !== "ssh")
     const query = store.filter.trim()
     if (!query) return items
     return fuzzysort
@@ -89,7 +92,7 @@ export const SettingsServers: Component = () => {
 
       <div class="settings-tab-body settings-servers">
         <Show
-          when={filtered().length > 0 || wslServers().length > 0}
+          when={filtered().length > 0 || wslServers().length > 0 || ssh.data?.servers.some((item) => item.saved)}
           fallback={
             <div class="settings-servers-status">
               <span>{store.filter ? language.t("palette.empty") : language.t("dialog.server.empty")}</span>
@@ -100,6 +103,7 @@ export const SettingsServers: Component = () => {
           }
         >
           <SettingsList>
+            <SshServerSettings filter={store.filter} domain={controller} />
             <WslServerSettings domain={controller} servers={wslServers} />
             <For each={filtered()}>
               {(item) => {

packages/app/src/settings/settings.css

@@ -1029,25 +1029,92 @@
   display: flex;
   flex-direction: column;
   gap: 0;
-  padding: 20px;
-  border-radius: 6px;
-  background-color: var(--v2-background-bg-base);
+  padding: 16px;
+  border-radius: 8px;
+  background-color: var(--v2-background-bg-layer-01);
   box-shadow: inset 0 0 0 0.5px var(--v2-border-border-base);
 }
 
+.settings-workspaces-inventory[data-empty="true"] [data-component="settings-list"] {
+  padding: 0;
+  background-color: transparent;
+  box-shadow: none;
+}
+
+.settings-workspaces-row-motion {
+  display: grid;
+  grid-template-rows: minmax(0, 1fr);
+  opacity: 1;
+  transition:
+    grid-template-rows 150ms ease-out,
+    opacity 120ms ease-out;
+}
+
+.settings-workspaces-row-motion[data-removing="true"] {
+  grid-template-rows: minmax(0, 0fr);
+  opacity: 0;
+}
+
 .settings-workspaces-row {
   display: flex;
   min-width: 0;
+  min-height: 0;
   flex-direction: column;
   gap: 12px;
+  overflow: hidden;
+  transition:
+    padding-bottom 150ms ease-out,
+    margin-bottom 150ms ease-out,
+    border-color 120ms ease-out;
 }
 
-.settings-workspaces-row:not(:last-child) {
+.settings-workspaces-row-motion:not(:last-child) > .settings-workspaces-row {
   padding-bottom: 20px;
   margin-bottom: 20px;
   border-bottom: 0.5px solid var(--v2-border-border-base);
 }
 
+.settings-workspaces-row-motion:has(+ .settings-workspaces-row-motion[data-removing="true"]:last-child)
+  > .settings-workspaces-row {
+  padding-bottom: 0;
+  margin-bottom: 0;
+  border-color: transparent;
+}
+
+.settings-workspaces-empty-motion {
+  display: grid;
+  min-height: 0;
+  grid-template-rows: minmax(0, 0fr);
+  opacity: 0;
+  overflow: hidden;
+  pointer-events: none;
+  transition:
+    grid-template-rows 150ms ease-out,
+    opacity 120ms ease-out;
+}
+
+.settings-workspaces-empty-motion[data-visible="true"] {
+  grid-template-rows: minmax(0, 1fr);
+  opacity: 1;
+  pointer-events: auto;
+}
+
+.settings-workspaces-empty-motion > .settings-workspaces-empty {
+  min-height: 0;
+  overflow: hidden;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .settings-workspaces-row-motion {
+    transition: none;
+  }
+
+  .settings-workspaces-row,
+  .settings-workspaces-empty-motion {
+    transition: none;
+  }
+}
+
 .settings-workspaces-row-header {
   display: flex;
   min-width: 0;
@@ -1088,7 +1155,7 @@
   color: var(--v2-text-text-base);
   font-family: inherit;
   font-size: 13px;
-  font-weight: 530;
+  font-weight: 440;
   line-height: var(--line-height-compact);
   letter-spacing: -0.04px;
   text-overflow: ellipsis;
@@ -1098,6 +1165,11 @@
   cursor: default;
 }
 
+.settings-workspaces-path-name {
+  color: var(--v2-text-text-base);
+  font-weight: 530;
+}
+
 .settings-workspaces-meta {
   font-size: 13px;
   font-weight: 440;
@@ -1105,6 +1177,10 @@
   color: var(--v2-text-text-faint);
 }
 
+.settings-workspaces-meta-project {
+  color: var(--v2-text-text-muted);
+}
+
 .settings-workspaces-active,
 .settings-workspaces-more {
   flex-shrink: 0;
@@ -1114,11 +1190,16 @@
   color: var(--v2-text-text-faint);
 }
 
+.settings-workspaces-active {
+  font-size: 13px;
+  line-height: var(--line-height-compact);
+}
+
 .settings-workspaces-sessions {
   display: flex;
   flex-direction: column;
   border: 0.5px solid var(--v2-border-border-base);
-  border-radius: 4px;
+  border-radius: 6px;
   background-color: var(--v2-background-bg-base);
   overflow: hidden;
 }
@@ -1129,7 +1210,8 @@
   align-items: center;
   justify-content: space-between;
   gap: 12px;
-  padding: 10px 12px;
+  padding-block: 10px;
+  padding-inline: 12px 16px;
   font-size: 13px;
   font-weight: 440;
   line-height: 16px;
@@ -1149,22 +1231,28 @@
 
 .settings-workspaces-session-time {
   flex-shrink: 0;
-  font-size: 11px;
-  line-height: 1;
-  color: var(--v2-text-text-muted);
+  font-size: 13px;
+  line-height: var(--line-height-compact);
+  color: var(--v2-text-text-faint);
 }
 
 .settings-workspaces-empty {
   display: flex;
-  align-items: center;
-  justify-content: center;
-  padding-block: 48px;
+  min-width: 0;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 4px;
   font-size: 13px;
   font-weight: 440;
   line-height: var(--line-height-compact);
   color: var(--v2-text-text-muted);
 }
 
+.settings-workspaces-empty-title {
+  color: var(--v2-text-text-base);
+  font-weight: 530;
+}
+
 @media (max-width: 639px) {
   .settings-workspaces-header {
     padding: 24px 20px 20px;

packages/app/src/settings/shell.tsx

@@ -1,4 +1,5 @@
 import { Component, createEffect, createMemo, For, Show, onMount, startTransition } from "solid-js"
+import { createStore } from "solid-js/store"
 import { Tabs } from "@opencode-ai/ui/tabs"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Menu } from "@opencode-ai/ui/menu"
@@ -35,7 +36,7 @@ const sections = [
   [
     { value: "servers", icon: "server", label: "status.popover.tab.servers" },
     { value: "projects", icon: "folder", label: "settings.tab.projects" },
-    { value: "workspaces", icon: "workspace-isolated", label: "settings.tab.workspaces" },
+    { value: "workspaces", icon: "outline-worktree", label: "settings.tab.workspaces" },
   ],
   [
     { value: "providers", icon: "providers", label: "settings.providers.title" },
@@ -54,6 +55,7 @@ export const SettingsScreen: Component = () => {
   const servers = useServers()
   const tabs = useTabs()
   const global = useGlobal()
+  const [state, setState] = createStore({ worktreeFilterReset: 0 })
   let root: HTMLDivElement | undefined
 
   onMount(() => {
@@ -146,7 +148,14 @@ export const SettingsScreen: Component = () => {
                         </Show>
                         <For each={group}>
                           {(section) => (
-                            <Menu.RadioItem value={section.value} closeOnSelect>
+                            <Menu.RadioItem
+                              value={section.value}
+                              closeOnSelect
+                              onSelect={() => {
+                                if (section.value === "workspaces")
+                                  setState("worktreeFilterReset", (value) => value + 1)
+                              }}
+                            >
                               <Icon name={section.icon} />
                               {language.t(section.label)}
                             </Menu.RadioItem>
@@ -172,7 +181,12 @@ export const SettingsScreen: Component = () => {
                   <div class="flex flex-col gap-1 w-full">
                     <For each={group}>
                       {(section) => (
-                        <Tabs.Trigger value={section.value}>
+                        <Tabs.Trigger
+                          value={section.value}
+                          onClick={() => {
+                            if (section.value === "workspaces") setState("worktreeFilterReset", (value) => value + 1)
+                          }}
+                        >
                           <Icon name={section.icon} />
                           {language.t(section.label)}
                         </Tabs.Trigger>
@@ -208,7 +222,10 @@ export const SettingsScreen: Component = () => {
         </Tabs.Content>
         <SettingsServerScope directory={directory()}>
           <Tabs.Content value="workspaces" class="settings-panel">
-            <SettingsWorkspaces activeDirectory={directory()} />
+            <SettingsWorkspaces
+              activeDirectory={directory()}
+              resetProjectFilter={() => state.worktreeFilterReset}
+            />
           </Tabs.Content>
           <Tabs.Content value="providers" class="settings-panel">
             <SettingsProviders directory={directory()} onBack={showProviders} />

packages/app/src/settings/timeline-detail.css

@@ -1,4 +1,6 @@
 [data-component="timeline-detail-control"] {
+  --timeline-detail-track-background: var(--v2-background-bg-layer-04);
+  --timeline-detail-marker-background: var(--v2-grey-500);
   position: relative;
   display: flex;
   min-width: 0;
@@ -10,48 +12,55 @@
   letter-spacing: -0.04px;
   container: timeline-detail / inline-size;
 
-  [data-slot="timeline-detail-heading"] {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    gap: 12px;
-    min-height: 24px;
-    font-weight: 530;
-    line-height: var(--line-height-compact);
-  }
-
-  [data-slot="timeline-detail-current"] {
-    color: var(--v2-text-text-muted);
-    text-align: end;
-  }
-
   p {
     margin: 0;
     color: var(--v2-text-text-muted);
   }
 
+  [data-slot="timeline-detail-summary"] {
+    color: var(--v2-text-text-base);
+  }
+
   [data-slot="timeline-detail-scale"] {
     position: relative;
     height: 28px;
+    margin-top: 24px;
+    margin-inline: 8px;
   }
 
   [data-slot="timeline-detail-track"] {
     position: absolute;
-    inset-inline: 8px;
+    inset-inline: 0;
     top: 12px;
     height: 4px;
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
     border-radius: 2px;
-    background: var(--v2-background-bg-layer-03);
+    background: var(--timeline-detail-track-background);
     pointer-events: none;
 
+    &::before {
+      content: "";
+      position: absolute;
+      inset-inline-start: 0;
+      width: var(--timeline-detail-progress);
+      height: 100%;
+      border-radius: inherit;
+      background: var(--v2-background-bg-accent);
+    }
+
     span {
-      width: 4px;
-      height: 4px;
+      position: absolute;
+      top: 50%;
+      transform: translate(-50%, -50%);
+      box-sizing: content-box;
+      width: 6px;
+      height: 6px;
+      border: 2px solid var(--v2-background-bg-layer-01);
       border-radius: 50%;
-      background: var(--v2-border-border-strong);
+      background: var(--timeline-detail-marker-background);
+
+      &:dir(rtl) {
+        transform: translate(50%, -50%);
+      }
     }
   }
 
@@ -59,9 +68,11 @@
     appearance: none;
     position: relative;
     display: block;
-    width: 100%;
+    /* Native ranges reserve half the thumb width at each end of their track. */
+    width: calc(100% + 16px);
     height: 28px;
     margin: 0;
+    margin-inline: -8px;
     background: transparent;
     cursor: pointer;
     border-radius: 4px;
@@ -81,9 +92,15 @@
       width: 16px;
       height: 16px;
       margin-top: -6px;
-      border: 1px solid var(--v2-border-border-base);
+      border: 0;
       border-radius: 50%;
-      background: var(--v2-background-bg-base);
+      background:
+        linear-gradient(
+          180deg,
+          var(--v2-overlay-gradient-depth-overlay-depth-top) 0%,
+          var(--v2-overlay-gradient-depth-overlay-depth-bot) 100%
+        ),
+        var(--v2-grey-300);
       box-shadow: var(--v2-elevation-button-neutral);
     }
 
@@ -96,28 +113,34 @@
       box-sizing: border-box;
       width: 16px;
       height: 16px;
-      border: 1px solid var(--v2-border-border-base);
+      border: 0;
       border-radius: 50%;
-      background: var(--v2-background-bg-base);
+      background:
+        linear-gradient(
+          180deg,
+          var(--v2-overlay-gradient-depth-overlay-depth-top) 0%,
+          var(--v2-overlay-gradient-depth-overlay-depth-bot) 100%
+        ),
+        var(--v2-grey-300);
       box-shadow: var(--v2-elevation-button-neutral);
     }
   }
 
   [data-slot="timeline-detail-advanced"] {
-    margin-top: 4px;
+    margin-top: 20px;
     padding-top: 8px;
   }
 
   [data-slot="timeline-detail-advanced"] > [data-slot="collapsible-trigger"] {
     width: fit-content;
-    height: 28px;
+    height: 24px;
     align-self: flex-start;
     gap: 6px;
     font-size: inherit;
     font-weight: 530;
     line-height: var(--line-height-compact);
     letter-spacing: inherit;
-    color: var(--v2-text-text-muted);
+    color: var(--v2-text-text-base);
 
     [data-slot="collapsible-arrow"] {
       width: 16px;
@@ -133,20 +156,28 @@
   }
 
   [data-slot="timeline-detail-categories"] {
-    --timeline-detail-columns: minmax(0, 1fr) 100px 108px;
+    --timeline-detail-columns: minmax(0, 1fr) 72px 88px;
     display: flex;
     flex-direction: column;
-    margin-top: 8px;
-  }
-
-  [data-slot="timeline-detail-explainer"] {
-    margin-bottom: 12px;
+    margin-top: 0;
   }
 
   [data-slot="timeline-detail-field-label"] {
     display: none;
   }
 
+  [data-slot="timeline-detail-unavailable"] {
+    width: 24px;
+    border-block-start: 1px solid var(--v2-icon-icon-muted);
+    opacity: 0.5;
+  }
+
+  [data-slot="timeline-detail-list"] {
+    border: 0.5px solid var(--v2-border-border-base);
+    border-radius: 8px;
+    background-color: var(--v2-background-bg-layer-02);
+  }
+
   [data-slot="timeline-detail-columns"],
   [data-slot="timeline-detail-category"] {
     display: grid;
@@ -155,6 +186,10 @@
     column-gap: 8px;
     line-height: var(--line-height-compact);
 
+    > :nth-child(3) {
+      margin-inline-start: 8px;
+    }
+
     > span {
       min-width: 0;
       overflow-wrap: normal;
@@ -162,49 +197,78 @@
   }
 
   [data-slot="timeline-detail-columns"] {
-    min-height: 28px;
+    min-height: var(--line-height-compact);
+    margin-bottom: 8px;
+    padding-inline: 12.5px;
     color: var(--v2-text-text-muted);
 
     span:not(:first-child) {
-      padding-inline-start: 8px;
+      text-align: center;
     }
   }
 
   [data-slot="timeline-detail-category"] {
     min-height: 40px;
     padding-block: 8px;
+    padding-inline: 12px;
     border-bottom: 0.5px solid var(--v2-border-border-base);
 
     &:last-child {
       border-bottom: 0;
     }
 
-    [data-component="select-v2-root"],
     [data-slot="timeline-detail-placement"],
     [data-slot="timeline-detail-expansion"] {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
       min-width: 0;
     }
 
-    [data-component="select-v2-root"][data-field] {
-      width: 100%;
+    &[data-hidden] [data-slot="timeline-detail-activity"] {
+      color: var(--v2-text-text-faint);
+    }
+  }
+
+  [data-slot="timeline-detail-activity"] {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    min-width: 0;
+
+    > label {
+      min-width: 0;
+      overflow-wrap: anywhere;
+      cursor: default;
     }
 
-    [data-component="select-v2"][data-appearance="inline"] {
-      width: 100%;
+    [data-component="tooltip-v2-trigger"] {
+      flex-shrink: 0;
+    }
+
+    [data-action="timeline-detail-visibility"][aria-pressed="true"] {
+      color: var(--v2-icon-icon-base);
+    }
+
+    /* Labels also activate :hover on their associated button. Keep that feedback local to the icon. */
+    &:has(> label:hover) [data-action="timeline-detail-visibility"][data-variant="ghost-muted"] {
+      background-color: transparent;
     }
   }
 }
 
+[data-color-scheme="dark"] [data-component="timeline-detail-control"] {
+  --timeline-detail-track-background: var(--v2-background-bg-layer-03);
+  --timeline-detail-marker-background:
+    linear-gradient(
+      180deg,
+      var(--v2-overlay-gradient-depth-overlay-depth-top) 0%,
+      var(--v2-overlay-gradient-depth-overlay-depth-bot) 100%
+    ),
+    var(--v2-grey-300);
+}
+
 @container timeline-detail (max-width: 250px) {
-  [data-component="timeline-detail-control"] [data-slot="timeline-detail-heading"] {
-    flex-wrap: wrap;
-    gap: 4px 8px;
-  }
-
-  [data-component="timeline-detail-control"] [data-slot="timeline-detail-current"] {
-    margin-inline-start: auto;
-  }
-
   [data-component="timeline-detail-control"] [data-slot="timeline-detail-columns"] {
     display: none;
   }
@@ -214,20 +278,20 @@
     row-gap: 8px;
     padding-block: 12px;
 
-    > span {
-      font-weight: 530;
+    > :nth-child(3) {
+      margin-inline-start: 0;
     }
   }
 
   [data-component="timeline-detail-control"] [data-slot="timeline-detail-field-label"] {
     display: block;
     margin-bottom: 2px;
-    padding-inline-start: 8px;
     font-size: 12px;
     line-height: var(--line-height-compact);
     color: var(--v2-text-text-muted);
   }
 
+  [data-component="timeline-detail-control"] [data-slot="timeline-detail-placement"]:empty,
   [data-component="timeline-detail-control"] [data-slot="timeline-detail-expansion"]:empty {
     display: none;
   }
@@ -235,7 +299,7 @@
 
 @container timeline-detail (max-width: 310px) {
   [data-component="timeline-detail-control"] [data-slot="timeline-detail-categories"] {
-    --timeline-detail-columns: minmax(0, 1fr) 90px 96px;
+    --timeline-detail-columns: minmax(0, 1fr) 64px 80px;
   }
 
   [data-component="timeline-detail-control"] [data-slot="timeline-detail-columns"],

packages/app/src/settings/timeline-detail.stories.tsx

@@ -0,0 +1,40 @@
+import { Show } from "solid-js"
+import { createStore } from "solid-js/store"
+import { Button } from "@opencode-ai/ui/button"
+import { timelinePresets, type TimelineDetail } from "@opencode-ai/session-ui/timeline/detail"
+import { SettingsList } from "./list"
+import { TimelineDetailControl } from "./timeline-detail"
+import "./settings.css"
+
+export default {
+  title: "OpenCode/Settings/Timeline detail",
+  id: "settings-timeline-detail",
+}
+
+export const Interactive = {
+  render: () => {
+    const [state, setState] = createStore<{ value: TimelineDetail; visible: boolean }>({
+      value: structuredClone(timelinePresets[2].value),
+      visible: true,
+    })
+
+    return (
+      <div class="flex w-[560px] max-w-full flex-col gap-4">
+        <Show when={state.visible}>
+          <SettingsList>
+            <div class="py-5">
+              <TimelineDetailControl value={state.value} onChange={(value) => setState("value", value)} />
+            </div>
+          </SettingsList>
+        </Show>
+        <Button onClick={() => setState("visible", !state.visible)}>
+          {state.visible ? "Leave settings" : "Return to settings"}
+        </Button>
+        <Button onClick={() => setState("value", structuredClone(timelinePresets[2].value))}>Reset</Button>
+        <output data-slot="timeline-detail-fixture-value" hidden>
+          {JSON.stringify(state.value)}
+        </output>
+      </div>
+    )
+  },
+}

packages/app/src/settings/timeline-detail.tsx

@@ -1,27 +1,33 @@
 import { For, Show, createMemo, createUniqueId } from "solid-js"
+import { createStore } from "solid-js/store"
 import { Collapsible } from "@opencode-ai/ui/collapsible"
-import { Select } from "@opencode-ai/ui/select"
+import { Icon } from "@opencode-ai/ui/icon"
+import { IconButton } from "@opencode-ai/ui/icon-button"
+import { Switch } from "@opencode-ai/ui/switch"
+import { Tooltip } from "@opencode-ai/ui/tooltip"
 import {
   timelineCategories,
   timelinePreset,
   timelinePresets,
+  type TimelineCategory,
   type TimelineDetail,
-  type TimelineExpansion,
   type TimelinePlacement,
 } from "@opencode-ai/session-ui/timeline/detail"
 import { useLanguage } from "@/runtime/i18n/language"
 import "./timeline-detail.css"
 
-const placements: TimelinePlacement[] = ["separate", "grouped", "hidden"]
-const expansions: TimelineExpansion[] = ["collapsed", "expanded"]
+const presets = timelinePresets.toReversed()
 
 export function TimelineDetailControl(props: { value: TimelineDetail; onChange: (value: TimelineDetail) => void }) {
   const language = useLanguage()
   const id = createUniqueId()
+  const [visiblePlacements, setVisiblePlacements] = createStore<
+    Partial<Record<TimelineCategory, Exclude<TimelinePlacement, "hidden">>>
+  >({})
   const preset = createMemo(() => timelinePreset(props.value))
   const position = () => {
     const current = preset()
-    return current ? timelinePresets.indexOf(current) : 2
+    return current ? presets.indexOf(current) : 2
   }
   const label = () => {
     const current = preset()
@@ -30,34 +36,42 @@ export function TimelineDetailControl(props: { value: TimelineDetail; onChange:
 
   return (
     <div data-component="timeline-detail-control">
-      <div data-slot="timeline-detail-heading">
-        <label for={`${id}-slider`}>{language.t("settings.timeline.detail")}</label>
-        <span data-slot="timeline-detail-current" aria-live="polite">
-          {label()}
-        </span>
+      <div data-slot="settings-row-copy">
+        <label data-slot="settings-row-title" for={`${id}-slider`}>
+          {language.t("settings.timeline.detail")}
+        </label>
+        <div id={`${id}-description`} data-slot="settings-row-description">
+          {language.t("settings.timeline.description")}
+        </div>
       </div>
-      <p id={`${id}-description`} class="sr-only">
-        {language.t("settings.timeline.description")}
-      </p>
       <div data-slot="timeline-detail-scale">
-        <div data-slot="timeline-detail-track" aria-hidden="true">
-          <For each={timelinePresets}>{() => <span />}</For>
+        <div
+          data-slot="timeline-detail-track"
+          aria-hidden="true"
+          style={{ "--timeline-detail-progress": `${(position() / (presets.length - 1)) * 100}%` }}
+        >
+          <For each={presets}>
+            {(_, index) => <span style={{ "inset-inline-start": `${(index() / (presets.length - 1)) * 100}%` }} />}
+          </For>
         </div>
         <input
           id={`${id}-slider`}
           data-action="settings-timeline-detail"
           type="range"
           min="0"
-          max={timelinePresets.length - 1}
+          max={presets.length - 1}
           step="1"
           value={position()}
           aria-valuetext={label()}
           aria-describedby={`${id}-description ${id}-preset-description`}
-          onInput={(event) => props.onChange({ ...timelinePresets[event.currentTarget.valueAsNumber].value })}
+          onInput={(event) => props.onChange({ ...presets[event.currentTarget.valueAsNumber].value })}
         />
       </div>
-      <p id={`${id}-preset-description`}>{language.t(`settings.timeline.description.${preset()?.id ?? "custom"}`)}</p>
-      <Collapsible variant="ghost" data-slot="timeline-detail-advanced">
+      <p id={`${id}-preset-description`} aria-live="polite">
+        <span data-slot="timeline-detail-summary">{language.t("settings.timeline.summary", { preset: label() })}</span>{" "}
+        {language.t(`settings.timeline.description.${preset()?.id ?? "custom"}`)}
+      </p>
+      <Collapsible variant="ghost" data-slot="timeline-detail-advanced" defaultOpen={!preset()}>
         <Collapsible.Trigger>
           <span>{language.t("settings.timeline.advanced")}</span>
           <Collapsible.Arrow />
@@ -68,57 +82,122 @@ export function TimelineDetailControl(props: { value: TimelineDetail; onChange:
             role="group"
             aria-label={language.t("settings.timeline.advanced.description")}
           >
-            <p data-slot="timeline-detail-explainer">{language.t("settings.timeline.advanced.explainer")}</p>
             <div data-slot="timeline-detail-columns">
-              <span>{language.t("settings.timeline.activity")}</span>
-              <span id={`${id}-placement`}>{language.t("settings.timeline.placement.title")}</span>
-              <span id={`${id}-expansion`}>{language.t("settings.timeline.expansion.title")}</span>
+              <span aria-hidden="true" />
+              <span>{language.t("settings.timeline.group")}</span>
+              <span>{language.t("settings.timeline.collapse")}</span>
             </div>
-            <For each={timelineCategories}>
-              {(category) => (
-                <div data-slot="timeline-detail-category" role="group" aria-labelledby={`${id}-${category}`}>
-                  <span id={`${id}-${category}`}>{language.t(`settings.timeline.category.${category}`)}</span>
-                  <div data-slot="timeline-detail-placement">
-                    <span data-slot="timeline-detail-field-label" aria-hidden="true">
-                      {language.t("settings.timeline.placement.title")}
-                    </span>
-                    <Select
-                      data-category={category}
-                      data-field="placement"
-                      aria-labelledby={`${id}-${category} ${id}-placement`}
-                      options={placements}
-                      current={props.value[category].placement}
-                      label={(value) => language.t(`settings.timeline.placement.${value}`)}
-                      onSelect={(placement) =>
-                        placement &&
-                        props.onChange({ ...props.value, [category]: { ...props.value[category], placement } })
-                      }
-                    />
-                  </div>
-                  <div data-slot="timeline-detail-expansion">
-                    {category === "shell" || category === "edit" || category === "thinking" ? (
-                      <Show when={props.value[category].placement !== "hidden"}>
-                        <span data-slot="timeline-detail-field-label" aria-hidden="true">
-                          {language.t("settings.timeline.expansion.title")}
-                        </span>
-                        <Select
-                          data-category={category}
-                          data-field="details"
-                          aria-labelledby={`${id}-${category} ${id}-expansion`}
-                          options={expansions}
-                          current={props.value[category].details}
-                          label={(value) => language.t(`settings.timeline.expansion.${value}`)}
-                          onSelect={(details) =>
-                            details &&
-                            props.onChange({ ...props.value, [category]: { ...props.value[category], details } })
+            <div data-slot="timeline-detail-list">
+              <For each={timelineCategories}>
+                {(category) => (
+                  <div
+                    data-slot="timeline-detail-category"
+                    data-hidden={props.value[category].placement === "hidden" ? "" : undefined}
+                    role="group"
+                    aria-labelledby={`${id}-${category}`}
+                  >
+                    <div data-slot="timeline-detail-activity">
+                      <Tooltip
+                        placement="top"
+                        value={language.t(
+                          props.value[category].placement === "hidden"
+                            ? "settings.timeline.visibility.show"
+                            : "settings.timeline.visibility.hide",
+                        )}
+                      >
+                        <IconButton
+                          id={`${id}-${category}-visibility`}
+                          type="button"
+                          variant="ghost-muted"
+                          size="small"
+                          data-action="timeline-detail-visibility"
+                          aria-label={language.t("settings.timeline.visibility.label", {
+                            activity: language.t(`settings.timeline.category.${category}`),
+                          })}
+                          aria-pressed={props.value[category].placement !== "hidden"}
+                          onClick={() => {
+                            const placement = props.value[category].placement
+                            if (placement !== "hidden") setVisiblePlacements(category, placement)
+                            props.onChange({
+                              ...props.value,
+                              [category]: {
+                                ...props.value[category],
+                                placement:
+                                  placement === "hidden" ? (visiblePlacements[category] ?? "grouped") : "hidden",
+                              },
+                            })
+                          }}
+                          icon={
+                            <Icon
+                              name={props.value[category].placement === "hidden" ? "outline-eye-slash" : "outline-eye"}
+                            />
                           }
                         />
+                      </Tooltip>
+                      <label id={`${id}-${category}`} for={`${id}-${category}-visibility`}>
+                        {language.t(`settings.timeline.category.${category}`)}
+                      </label>
+                    </div>
+                    <div data-slot="timeline-detail-placement">
+                      <span data-slot="timeline-detail-field-label" aria-hidden="true">
+                        {language.t("settings.timeline.group")}
+                      </span>
+                      <Show
+                        when={props.value[category].placement !== "hidden"}
+                        fallback={<span data-slot="timeline-detail-unavailable" aria-hidden="true" />}
+                      >
+                        <Switch
+                          data-category={category}
+                          data-field="placement"
+                          hideLabel
+                          checked={props.value[category].placement === "grouped"}
+                          onChange={(checked) =>
+                            props.onChange({
+                              ...props.value,
+                              [category]: { ...props.value[category], placement: checked ? "grouped" : "separate" },
+                            })
+                          }
+                        >
+                          {language.t("settings.timeline.grouped.label", {
+                            activity: language.t(`settings.timeline.category.${category}`),
+                          })}
+                        </Switch>
                       </Show>
-                    ) : null}
+                    </div>
+                    <div data-slot="timeline-detail-expansion">
+                      {category === "shell" || category === "edit" || category === "thinking" ? (
+                        <>
+                          <span data-slot="timeline-detail-field-label" aria-hidden="true">
+                            {language.t("settings.timeline.collapse")}
+                          </span>
+                          <Show
+                            when={props.value[category].placement !== "hidden"}
+                            fallback={<span data-slot="timeline-detail-unavailable" aria-hidden="true" />}
+                          >
+                            <Switch
+                              data-category={category}
+                              data-field="details"
+                              hideLabel
+                              checked={props.value[category].details === "collapsed"}
+                              onChange={(checked) =>
+                                props.onChange({
+                                  ...props.value,
+                                  [category]: { ...props.value[category], details: checked ? "collapsed" : "expanded" },
+                                })
+                              }
+                            >
+                              {language.t("settings.timeline.collapsed.label", {
+                                activity: language.t(`settings.timeline.category.${category}`),
+                              })}
+                            </Switch>
+                          </Show>
+                        </>
+                      ) : null}
+                    </div>
                   </div>
-                </div>
-              )}
-            </For>
+                )}
+              </For>
+            </div>
           </div>
         </Collapsible.Content>
       </Collapsible>

packages/app/src/settings/workspaces/workspaces.tsx

@@ -1,6 +1,8 @@
 import type { Component } from "solid-js"
-import { For, Show, createMemo } from "solid-js"
+import { For, Show, createEffect, createMemo, createSignal } from "solid-js"
 import { createStore } from "solid-js/store"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
+import { Key } from "@solid-primitives/keyed"
 import type { SessionInfo } from "@opencode-ai/client/promise"
 import { useQuery } from "@tanstack/solid-query"
 import { Button } from "@opencode-ai/ui/button"
@@ -46,7 +48,9 @@ type Workspace = {
   project: Project
 }
 
-export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (props) => {
+export const SettingsWorkspaces: Component<{ activeDirectory?: string; resetProjectFilter: () => number }> = (
+  props,
+) => {
   const dialog = useDialog()
   const language = useLanguage()
   const serverSDK = useServerSDK()
@@ -56,6 +60,12 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
   const [store, setStore] = createStore({
     project: "all",
     transaction: undefined as "confirm" | "running" | undefined,
+    deleting: [] as string[],
+    removing: [] as string[],
+  })
+  createEffect(() => {
+    props.resetProjectFilter()
+    setStore("project", "all")
   })
 
   const projectQuery = useQuery(() => ({
@@ -111,6 +121,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     ] as const,
     queryFn: () => loadSessions(workspaceDirectories()),
     enabled: serverSDK.connection.status() === "connected" && workspaceDirectories().length > 0,
+    placeholderData: (previous) => previous,
     refetchOnMount: "always",
   }))
   const sessionsByWorkspace = createMemo(() => {
@@ -123,14 +134,29 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     )
   })
   const workspaceSessions = (workspace: Workspace) => sessionsByWorkspace().get(pathKey(workspace.directory)) ?? []
+  const workspacesWithoutSessions = createMemo(() => {
+    if (sessionQuery.isPending || sessionQuery.isError) return []
+    return filtered().filter((workspace) => workspaceSessions(workspace).length === 0)
+  })
   const sessionCount = (workspace: Workspace) => {
     if (sessionQuery.isPending) return language.t("session.messages.loading")
     if (sessionQuery.isError) return language.t("common.requestFailed")
     const count = workspaceSessions(workspace).length
-    return language.plural("settings.workspaces.sessions", count, {
+    if (selectedProject() !== "all") return language.plural("settings.workspaces.sessions.filtered", count, { count })
+    const project = projectName(workspace.project)
+    const label = language.plural("settings.workspaces.sessions", count, {
       count,
-      project: projectName(workspace.project),
+      project,
     })
+    const start = label.lastIndexOf(project)
+    if (start < 0) return label
+    return (
+      <>
+        {label.slice(0, start)}
+        <span class="settings-workspaces-meta-project">{project}</span>
+        {label.slice(start + project.length)}
+      </>
+    )
   }
   const lastActive = (workspace: Workspace) => {
     const updated = workspaceSessions(workspace)[0]?.time.updated
@@ -158,54 +184,64 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
   }
   const inspectionMessages = (result: WorkspaceDeleteInspection) => {
     const messages = [
-      result.active ? language.t("settings.workspaces.delete.blocked.active") : undefined,
       result.linked ? language.t("settings.workspaces.delete.blocked.linked") : undefined,
       result.dirty ? language.t("workspace.status.dirty") : undefined,
     ].filter((message): message is string => message !== undefined)
-    return messages.length > 0 ? messages : [language.t("workspace.status.clean")]
+    return messages
   }
   const blocked = (result: WorkspaceDeleteInspection) => {
     showToast({
       variant: "error",
       title: language.t("workspace.delete.failed.title"),
-      description: inspectionMessages(result)[0],
+      description: result.active
+        ? language.t("settings.workspaces.delete.blocked.active")
+        : inspectionMessages(result)[0],
     })
   }
 
   const remove = async (workspace: Workspace, force = false, context = captureDeleteContext()) => {
-    const preflight = await inspect(workspace, context)
-    if (preflight.result.active || (!force && (preflight.result.linked || preflight.result.dirty))) {
-      blocked(preflight.result)
-      return
-    }
-    const removed = await context.sdk.api.worktree
-      .remove({
-        location: { directory: workspace.project.worktree },
-        directory: workspace.directory,
-        force,
-      })
-      .then(() => true)
-      .catch((error) => {
-        showToast({
-          variant: "error",
-          title: language.t("workspace.delete.failed.title"),
-          description: error instanceof Error ? error.message : language.t("common.requestFailed"),
+    const key = String(pathKey(workspace.directory))
+    setStore("deleting", (items) => [...items, key])
+    try {
+      const preflight = await inspect(workspace, context)
+      if (!force && (preflight.result.active || preflight.result.linked || preflight.result.dirty)) {
+        blocked(preflight.result)
+        return
+      }
+      const removed = await context.sdk.api.worktree
+        .remove({
+          location: { directory: workspace.project.worktree },
+          directory: workspace.directory,
+          force,
+        })
+        .then(() => true)
+        .catch((error) => {
+          showToast({
+            variant: "error",
+            title: language.t("workspace.delete.failed.title"),
+            description: error instanceof Error ? error.message : language.t("common.requestFailed"),
+          })
+          return false
+        })
+      if (!removed) return
+      setStore("removing", (items) => [...items, key])
+      await new Promise((resolve) => setTimeout(resolve, 150))
+      tabs.store.forEach((tab) => {
+        if (tab.type !== "draft" || tab.server !== context.server) return
+        const directoryMatches = containsDirectory(workspace.directory, tab.directory)
+        const worktreeMatches = tab.worktree && containsDirectory(workspace.directory, tab.worktree)
+        if (!directoryMatches && !worktreeMatches) return
+        tabs.updateDraft(tab.draftID, {
+          directory: directoryMatches ? workspace.project.worktree : tab.directory,
+          worktree: undefined,
         })
-        return false
       })
-    if (!removed) return
-    tabs.store.forEach((tab) => {
-      if (tab.type !== "draft" || tab.server !== context.server) return
-      const directoryMatches = containsDirectory(workspace.directory, tab.directory)
-      const worktreeMatches = tab.worktree && containsDirectory(workspace.directory, tab.worktree)
-      if (!directoryMatches && !worktreeMatches) return
-      tabs.updateDraft(tab.draftID, {
-        directory: directoryMatches ? workspace.project.worktree : tab.directory,
-        worktree: undefined,
-      })
-    })
-    clearWorkspaceTerminals(workspace.directory, platform, context.sdk.scope)
-    await projectQuery.refetch()
+      clearWorkspaceTerminals(workspace.directory, platform, context.sdk.scope)
+      await projectQuery.refetch()
+    } finally {
+      setStore("deleting", (items) => items.filter((item) => item !== key))
+      setStore("removing", (items) => items.filter((item) => item !== key))
+    }
   }
 
   let inspectionID = 0
@@ -253,13 +289,30 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     if (store.transaction) return
     const context = captureDeleteContext()
     const inventory = [...filtered()]
-    const project = projectOptions().find((option) => option.id === selectedProject())?.label ?? selectedProject()
     setStore("transaction", "confirm")
     void dialog.push(
       () => (
-        <DialogDeleteAllWorkspaces
-          count={inventory.length}
-          project={project}
+        <DialogDeleteWorkspaces
+          title={language.t("settings.workspaces.deleteAll")}
+          confirmation={language.plural("settings.workspaces.deleteAll.confirm", inventory.length)}
+          warning={language.t("settings.workspaces.deleteAll.warning")}
+          onDelete={() => transact(() => removeAll(inventory, context))}
+        />
+      ),
+      releaseConfirmation,
+    )
+  }
+  const confirmDeleteWithoutSessions = () => {
+    if (store.transaction || workspacesWithoutSessions().length === 0) return
+    const context = captureDeleteContext()
+    const inventory = [...workspacesWithoutSessions()]
+    setStore("transaction", "confirm")
+    void dialog.push(
+      () => (
+        <DialogDeleteWorkspaces
+          title={language.t("settings.workspaces.deleteWithoutSessions")}
+          confirmation={language.plural("settings.workspaces.deleteWithoutSessions.confirm", inventory.length)}
+          warning={language.t("settings.workspaces.deleteWithoutSessions.warning")}
           onDelete={() => transact(() => removeAll(inventory, context))}
         />
       ),
@@ -271,44 +324,45 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     <>
       <div class="settings-tab-header settings-workspaces-header">
         <div class="settings-tab-header-row">
-          <h2 class="settings-tab-title">{language.t("settings.tab.workspaces")}</h2>
+          <div class="flex flex-col gap-1">
+            <h2 class="settings-tab-title">{language.t("settings.tab.workspaces")}</h2>
+            <span class="text-11-regular text-v2-text-text-muted">{language.t("settings.workspaces.description")}</span>
+          </div>
           <InlineServerSelect />
         </div>
       </div>
 
       <div class="settings-tab-body settings-workspaces">
-        <div class="settings-workspaces-toolbar">
-          <span class="settings-workspaces-count">
-            <Show when={!projectQuery.isPending && !projectQuery.isError}>
+        <Show when={filtered().length > 0}>
+          <div class="settings-workspaces-toolbar">
+            <span class="settings-workspaces-count">
               {language.plural("settings.workspaces.count", filtered().length)}
-            </Show>
-          </span>
-          <div class="settings-workspaces-toolbar-actions">
-            <Show when={projects().length > 1}>
-              <Menu placement="bottom-end" gutter={6}>
-                <Menu.Trigger class="flex h-6 max-w-48 items-center gap-1 rounded-sm px-2 text-13-medium hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed">
-                  <span class="min-w-0 truncate">
-                    {projectOptions().find((option) => option.id === selectedProject())?.label}
-                  </span>
-                  <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-                </Menu.Trigger>
-                <Menu.Portal>
-                  <Menu.Content>
-                    <For each={projectOptions()}>
-                      {(option) => (
-                        <Menu.Item onSelect={() => setStore("project", option.id)}>
-                          <span class="min-w-0 flex-1 truncate">{option.label}</span>
-                          <Show when={selectedProject() === option.id}>
-                            <Icon name="check" size="small" class="shrink-0" />
-                          </Show>
-                        </Menu.Item>
-                      )}
-                    </For>
-                  </Menu.Content>
-                </Menu.Portal>
-              </Menu>
-            </Show>
-            <Show when={filtered().length > 0}>
+            </span>
+            <div class="settings-workspaces-toolbar-actions">
+              <Show when={projects().length > 1}>
+                <Menu placement="bottom-end" gutter={6}>
+                  <Menu.Trigger as={Button} size="small" variant="ghost-muted" class="max-w-48">
+                    <span class="min-w-0 truncate">
+                      {projectOptions().find((option) => option.id === selectedProject())?.label}
+                    </span>
+                    <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
+                  </Menu.Trigger>
+                  <Menu.Portal>
+                    <Menu.Content>
+                      <For each={projectOptions()}>
+                        {(option) => (
+                          <Menu.Item onSelect={() => setStore("project", option.id)}>
+                            <span class="min-w-0 flex-1 truncate">{option.label}</span>
+                            <Show when={selectedProject() === option.id}>
+                              <Icon name="check" size="small" class="shrink-0" />
+                            </Show>
+                          </Menu.Item>
+                        )}
+                      </For>
+                    </Menu.Content>
+                  </Menu.Portal>
+                </Menu>
+              </Show>
               <Menu placement="bottom-end" gutter={4}>
                 <Menu.Trigger
                   as={IconButton}
@@ -321,78 +375,83 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
                 />
                 <Menu.Portal>
                   <Menu.Content>
+                    <Show when={workspacesWithoutSessions().length > 0}>
+                      <Menu.Item onSelect={confirmDeleteWithoutSessions}>
+                        {language.t("settings.workspaces.deleteWithoutSessions")}
+                      </Menu.Item>
+                      <Menu.Separator />
+                    </Show>
                     <Menu.Item onSelect={confirmDeleteAll}>
                       <span class="settings-workspaces-delete-all">{language.t("settings.workspaces.deleteAll")}</span>
                     </Menu.Item>
                   </Menu.Content>
                 </Menu.Portal>
               </Menu>
-            </Show>
+            </div>
           </div>
-        </div>
+        </Show>
 
-        <div class="settings-workspaces-inventory">
-          <Show
-            when={filtered().length > 0}
-            fallback={
+        <div class="settings-workspaces-inventory" data-empty={filtered().length === 0}>
+          <SettingsList>
+            <div class="settings-workspaces-empty-motion" data-visible={filtered().length === 0}>
               <div class="settings-workspaces-empty">
-                {language.t(
-                  projectQuery.isPending
-                    ? "common.loading"
-                    : projectQuery.isError
-                      ? "common.requestFailed"
-                      : "settings.workspaces.empty",
-                )}
+                <Show
+                  when={!projectQuery.isPending && !projectQuery.isError}
+                  fallback={language.t(projectQuery.isPending ? "common.loading" : "common.requestFailed")}
+                >
+                  <span class="settings-workspaces-empty-title">{language.t("settings.workspaces.empty")}</span>
+                  <span>{language.t("settings.workspaces.empty.description")}</span>
+                </Show>
               </div>
-            }
-          >
-            <SettingsList>
-              <For each={filtered()}>
-                {(workspace) => {
-                  const linked = () => workspaceSessions(workspace)
-                  return (
+            </div>
+            <Key each={filtered()} by={(workspace) => `${workspace.project.id}:${pathKey(workspace.directory)}`}>
+              {(workspace) => {
+                const linked = () => workspaceSessions(workspace())
+                const key = () => String(pathKey(workspace().directory))
+                const deleting = () => store.deleting.includes(key())
+                return (
+                  <div class="settings-workspaces-row-motion" data-removing={store.removing.includes(key())}>
                     <div class="settings-workspaces-row">
                       <div class="settings-workspaces-row-header">
                         <div class="settings-workspaces-copy">
                           <div class="settings-workspaces-main">
-                            <Tooltip
-                              value={workspace.directory}
-                              placement="top-start"
-                              contentClass="max-w-[calc(100vw-32px)] break-all"
-                            >
-                              <span
-                                tabIndex={0}
-                                dir="ltr"
-                                aria-label={workspace.directory}
-                                class="settings-workspaces-path"
-                              >
-                                {workspace.directory}
-                              </span>
-                            </Tooltip>
+                            <WorkspacePath directory={workspace().directory} />
                           </div>
-                          <span class="settings-workspaces-meta">{sessionCount(workspace)}</span>
+                          <span class="settings-workspaces-meta">{sessionCount(workspace())}</span>
                         </div>
                         <div class="settings-workspaces-row-actions">
-                          <Show when={lastActive(workspace)}>
-                            {(value) => (
-                              <Tooltip value={language.t("settings.workspaces.lastActiveSession")} placement="top-end">
-                                <span tabIndex={0} class="settings-workspaces-active">
-                                  {value()}
-                                </span>
-                              </Tooltip>
-                            )}
+                          <Show
+                            when={deleting()}
+                            fallback={
+                              <>
+                                <Show when={lastActive(workspace())}>
+                                  {(value) => (
+                                    <Tooltip
+                                      value={language.t("settings.workspaces.lastActiveSession")}
+                                      placement="top-end"
+                                    >
+                                      <span tabIndex={0} class="settings-workspaces-active">
+                                        {value()}
+                                      </span>
+                                    </Tooltip>
+                                  )}
+                                </Show>
+                                <IconButton
+                                  type="button"
+                                  variant="ghost-muted"
+                                  size="small"
+                                  aria-label={language.t("workspace.delete.confirm", {
+                                    name: getFilename(workspace().directory),
+                                  })}
+                                  disabled={!!store.transaction}
+                                  icon={<Icon name="outline-trash" size="small" />}
+                                  onClick={() => confirmDelete(workspace())}
+                                />
+                              </>
+                            }
+                          >
+                            <span class="settings-workspaces-active">{language.t("workspace.lifecycle.deleting")}</span>
                           </Show>
-                          <IconButton
-                            type="button"
-                            variant="ghost-muted"
-                            size="small"
-                            aria-label={language.t("workspace.delete.confirm", {
-                              name: getFilename(workspace.directory),
-                            })}
-                            disabled={!!store.transaction}
-                            icon={<Icon name="trash" size="small" />}
-                            onClick={() => confirmDelete(workspace)}
-                          />
                         </div>
                       </div>
                       <Show when={linked().length > 0}>
@@ -401,7 +460,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
                             {(session) => (
                               <div class="settings-workspaces-session">
                                 <span>{sessionLabel(session)}</span>
-                                <Show when={sessionTime(session)}>
+                                <Show when={linked().length > 1 ? sessionTime(session) : undefined}>
                                   {(time) => <span class="settings-workspaces-session-time">{time()}</span>}
                                 </Show>
                               </div>
@@ -410,18 +469,48 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
                         </div>
                       </Show>
                     </div>
-                  )
-                }}
-              </For>
-            </SettingsList>
-          </Show>
+                  </div>
+                )
+              }}
+            </Key>
+          </SettingsList>
         </div>
       </div>
     </>
   )
 }
 
-function DialogDeleteAllWorkspaces(props: { count: number; project: string; onDelete: () => Promise<void> }) {
+function WorkspacePath(props: { directory: string }) {
+  const [truncated, setTruncated] = createSignal(false)
+  const name = () => getFilename(props.directory)
+
+  return (
+    <Tooltip
+      value={props.directory}
+      placement="top-start"
+      disabled={!truncated()}
+      contentClass="max-w-[calc(100vw-32px)] break-all"
+    >
+      <span
+        ref={(element) => createResizeObserver(element, () => setTruncated(element.scrollWidth > element.clientWidth))}
+        tabIndex={truncated() ? 0 : undefined}
+        dir="ltr"
+        aria-label={props.directory}
+        class="settings-workspaces-path"
+      >
+        <span>{props.directory.slice(0, -name().length)}</span>
+        <span class="settings-workspaces-path-name">{name()}</span>
+      </span>
+    </Tooltip>
+  )
+}
+
+function DialogDeleteWorkspaces(props: {
+  title: string
+  confirmation: string
+  warning: string
+  onDelete: () => Promise<void>
+}) {
   const dialog = useDialog()
   const language = useLanguage()
   const remove = () => {
@@ -434,13 +523,12 @@ function DialogDeleteAllWorkspaces(props: { count: number; project: string; onDe
     <Dialog fit>
       <DialogHeader>
         <DialogTitleGroup
-          title={language.t("settings.workspaces.deleteAll")}
+          title={props.title}
           description={
-            <>
-              {language.t("settings.workspaces.deleteAll.confirm", { count: props.count })}
-              <br />
-              {language.t("settings.workspaces.deleteAll.warning", { count: props.count, project: props.project })}
-            </>
+            <div class="flex flex-col gap-2">
+              <div>{props.confirmation}</div>
+              <div>{props.warning}</div>
+            </div>
           }
         />
       </DialogHeader>
@@ -449,7 +537,7 @@ function DialogDeleteAllWorkspaces(props: { count: number; project: string; onDe
           {language.t("common.cancel")}
         </Button>
         <Button type="button" variant="danger" onClick={remove}>
-          {language.t("settings.workspaces.deleteAll")}
+          {language.t("settings.workspaces.delete.button")}
         </Button>
       </DialogFooter>
     </Dialog>
@@ -472,7 +560,7 @@ function DialogDeleteWorkspace(props: {
     staleTime: 0,
   }))
   const descriptions = () => {
-    if (status.isPending) return [language.t("workspace.status.checking")]
+    if (status.isPending) return []
     if (status.isError) return [language.t("workspace.status.error")]
     if (!status.data) return []
     return props.inspectionMessages(status.data.result)
@@ -487,18 +575,20 @@ function DialogDeleteWorkspace(props: {
     <Dialog fit>
       <DialogHeader>
         <DialogTitleGroup
-          title={language.t("workspace.delete.title")}
+          title={language.t("workspace.delete.confirm", { name: getFilename(props.workspace.directory) })}
           description={
-            <>
-              {language.t("workspace.delete.confirm", { name: getFilename(props.workspace.directory) })}
-              <br />
-              <code class="max-w-full rounded-[4px] bg-[color-mix(in_oklch,var(--v2-text-text-base)_8%,transparent)] px-1 py-0.5 font-mono text-xs font-medium leading-4 text-v2-text-text-base break-all">
-                {props.workspace.directory}
-              </code>
-              <br />
-              {language.t("settings.workspaces.delete.warning")}
+            <div class="flex flex-col gap-2">
+              <div class="flex flex-col gap-1">
+                <span class="text-11-regular text-v2-text-text-faint">
+                  {language.t(status.isPending ? "workspace.status.checking" : "workspace.delete.location")}
+                </span>
+                <code class="block w-fit max-w-full rounded-[4px] bg-[color-mix(in_oklch,var(--v2-text-text-base)_8%,transparent)] px-1 py-0.5 font-mono text-xs font-medium leading-4 text-v2-text-text-base break-all">
+                  {props.workspace.directory}
+                </code>
+              </div>
+              <div>{language.t("settings.workspaces.delete.warning")}</div>
               <For each={descriptions()}>{(description) => <div>{description}</div>}</For>
-            </>
+            </div>
           }
         />
       </DialogHeader>
@@ -506,12 +596,7 @@ function DialogDeleteWorkspace(props: {
         <Button type="button" variant="neutral" onClick={() => dialog.close()}>
           {language.t("common.cancel")}
         </Button>
-        <Button
-          type="button"
-          variant="danger"
-          disabled={status.isPending || status.isError || status.data?.result.active}
-          onClick={remove}
-        >
+        <Button type="button" variant="danger" disabled={status.isPending || status.isError} onClick={remove}>
           {language.t("workspace.delete.button")}
         </Button>
       </DialogFooter>