test(core): simplify command layer wiring

.github/workflows/test.yml

@@ -65,7 +65,7 @@ jobs:
 
       - name: Run unit tests
         timeout-minutes: 20
-        run: GITHUB_ACTIONS=false bun turbo test
+        run: bun turbo test --output-logs=errors-only --log-order=grouped --log-prefix=task
         env:
           OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
 
@@ -99,8 +99,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
-          # Playwright 1.59 hangs while extracting Chromium with Node 24.16.
-          node-version: "24.15"
+          node-version: "24"
 
       - name: Setup Bun
         uses: ./.github/actions/setup-bun

AGENTS.md

@@ -137,7 +137,7 @@ const table = sqliteTable("session", {
 
 ## Testing
 
-- Avoid mocks as much as possible, you shouldn't be using globalThis.\* at all unless it's the only option.
+- Avoid mocks as much as possible
 - Test actual implementation, do not duplicate logic into tests
 - Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package dirs like `packages/opencode`.
 
@@ -152,7 +152,7 @@ const table = sqliteTable("session", {
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; idle or missing interruption is a no-op.
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
 - Preserve one explicit `llm.stream(request)` call per provider turn and reload projected history before durable continuation. Do not bridge through legacy `SessionPrompt.loop(...)` or delegate orchestration to an in-memory tool loop.
-- Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. Advisory wakes drain eligible durable inbox rows only; post-crash continuation recovery requires a separate explicit design before it may retry provider work. A drain has no durable identity or transcript boundary.
-- Keep delivery vocabulary explicit. Prompts steer by default and promote at the next safe provider-turn boundary while the current drain requires continuation. An explicit `queue` input remains pending until the Session would otherwise become idle; promote one queued input at that boundary, then reevaluate continuation before promoting another. Promoting any new user input resets the selected agent's provider-turn allowance; a batch of steers resets it once.
+- Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. Advisory wakes drain eligible durable inbox rows only; post-crash activity recovery requires a separate explicit design before it may retry provider work.
+- Keep delivery vocabulary explicit. Prompts steer by default and coalesce into the active activity at the next safe provider-turn boundary. Explicit `queue` inputs open FIFO future activities one at a time after the active activity settles.
 - Keep EventV2 replay owner claims separate from clustered Session execution ownership.
 - Keep the System Context algebra, registry, and built-ins in `src/system-context`; keep Context Source producers with their observed domains, and keep Session History selection plus Context Epoch persistence Session-owned.

CONTEXT.md

@@ -24,7 +24,7 @@ A durable chronological instruction that tells the model the newly effective sta
 _Avoid_: System update, system notification, raw text diff
 
 **Context Epoch**:
-The span during which one initially rendered **System Context** remains the immutable provider-cache baseline, ending at completed compaction, Session movement, or an incompatible context transition that requires a fresh baseline.
+The span during which one effective agent's initially rendered **System Context** remains immutable, ending at compaction or another baseline-replacing transition.
 
 **Baseline System Context**:
 The full **System Context** rendered at the start of a **Context Epoch**.
@@ -39,18 +39,6 @@ An expected temporary inability to observe a **Context Source** value; the runti
 **Safe Provider-Turn Boundary**:
 The point immediately before a provider call, after durable input promotion and any required tool settlement, where context changes may be admitted chronologically.
 
-**Admitted Prompt**:
-A durable user input accepted into the Session inbox but not yet included in **Session History**.
-
-**Prompt Promotion**:
-The durable transition that removes an **Admitted Prompt** from pending input and appends its user message to **Session History**.
-
-**Provider Turn**:
-One request to a model provider and the response projected from that request.
-
-**Session Drain**:
-One process-local execution span that promotes eligible input and runs required **Provider Turns** until no immediate continuation remains. A Session Drain has no durable identity or transcript boundary.
-
 **Model Tool Output**:
 The bounded projection of a Core-executed tool result persisted in Session history and replayed to the model. A tool may shape this projection semantically, but the Tool Registry enforces the final size limit.
 
@@ -79,11 +67,6 @@ The host-supplied environment overlay applied by the server when creating a PTY,
 - Changes from multiple **Context Sources** admitted at one safe boundary combine into one **Mid-Conversation System Message**.
 - Context changes are sampled and admitted lazily at a **Safe Provider-Turn Boundary**, never pushed asynchronously when their source changes.
 - At a **Safe Provider-Turn Boundary**, newly promoted user input or settled tool results precede any combined **Mid-Conversation System Message**.
-- An **Admitted Prompt** is replayable pending input, not yet model-visible **Session History**.
-- **Prompt Promotion** atomically consumes the pending inbox entry and appends its model-visible user message.
-- Steering prompts promote at the next **Safe Provider-Turn Boundary** while the current **Session Drain** still requires continuation. Promoting any newly admitted user input resets the selected agent's provider-turn allowance; multiple prompts promoted at one boundary reset it once.
-- A queued prompt does not promote while the current **Session Drain** requires continuation. The runner promotes one queued prompt when the Session would otherwise become idle, then reevaluates continuation before promoting another.
-- A **Session Drain** is process-local coordination rather than a durable domain entity. Durable recovery must reason from prompts, projected history, provider attempts, and tool state rather than inventing an enclosing execution identity.
 - The first provider turn renders the latest complete **Baseline System Context** and initializes its **Context Snapshot** without emitting a redundant **Mid-Conversation System Message**; unavailable initial context blocks the turn instead of persisting an incomplete baseline.
 - Initial **System Context** preparation precedes the first durable input promotion so an unavailable baseline leaves that input pending and retryable; ordinary reconciliation remains after promotion.
 - Compaction starts a new **Context Epoch** with a freshly rendered **Baseline System Context** and **Context Snapshot**; prior **Mid-Conversation System Messages** remain durable audit history but leave projected model history.
@@ -92,28 +75,31 @@ The host-supplied environment overlay applied by the server when creating a PTY,
 - Each **Context Source** loader returns one coherent typed value. `SystemContext.make(...)` hides that value type so differently typed sources compose uniformly. Its codec compares and stores that value; its pure renderers produce model-visible baseline, update, and removal text only when needed.
 - `SystemContext.initialize(...)` observes a composed **System Context** once and produces a fresh **Baseline System Context** with its **Context Snapshot**.
 - `SystemContext.reconcile(...)` observes a composed **System Context** once and returns exactly one next action: unchanged, updated, replacement ready, or replacement blocked.
-- `SystemContext.replace(...)` renders a fresh generation after completed compaction or another baseline-replacing transition; it reports replacement blocked while previously admitted context is unavailable.
+- `SystemContext.replace(...)` represents an explicit baseline-replacing transition such as compaction or model/provider switch; it either produces a fresh generation or reports that replacement is blocked by unavailable admitted context.
+- Context Epoch preparation retries until stable after optimistic revision mismatches so concurrent replacement requests cannot terminate an otherwise valid safe-boundary run.
 - **Unavailable Context** uses stale-while-revalidate semantics and is distinct from a successfully loaded absence, which may emit removal text.
 - Ordinary **Context Source** loaders return values directly; loaders that intentionally use stale-while-revalidate may explicitly return **Unavailable Context**.
 - Nested project instruction discovery after successful reads remains a follow-up; when implemented, discovered instructions must be admitted durably at the next **Safe Provider-Turn Boundary**.
 - Location-scoped services naturally re-resolve effective context when a moved session next runs in its destination location.
 - Moving a Session clears its active **Context Epoch**, so the destination must initialize a complete baseline before another prompt can promote.
+- Context Epoch initialization is fenced against the authoritative Session Location, so an old-Location runner cannot recreate source context after a concurrent move.
 - Instruction discovery, source identity, persistence, and file loading belong to the instruction service; the **System Context** abstraction only composes effectful producers and renders loaded values.
 - The first instruction-service slice observes global and upward project `AGENTS.md` files as one ordered aggregate **Context Source** at each **Safe Provider-Turn Boundary**.
 - Built-in and instruction context producers register through the **System Context Registry** with stable contribution keys. Plugin-defined context registration and hot-reload lifecycle remain a follow-up built on the same scoped registry seam.
 - Selected-agent available-skill guidance is a **Context Source** composed with Location-wide registry sources immediately before Context Epoch admission. It lists only names and descriptions permitted for that agent; skill bodies and locations are exposed only through the permission-checked `skill` tool.
-- The selected agent and model are sampled when a provider turn starts. Changes admitted after that boundary apply to the next provider turn and do not restart the current turn.
-- Selected-agent available-skill guidance remains a **Context Source**. An agent switch that changes that guidance produces a **Mid-Conversation System Message** while preserving the current baseline.
+- Switching the selected agent requests **Context Epoch** replacement. A switch admitted after the current **Safe Provider-Turn Boundary** applies to the next provider turn while leaving the already-prepared baseline durable. Epoch creation is fenced against the authoritative effective agent, and retries re-observe the current agent.
+- A cross-agent replacement must complete before another provider turn; unavailable admitted context blocks that replacement instead of exposing the previous agent's privileged baseline.
 - Local tool authorization and pending permission requests retain the effective agent of the provider turn that issued the call; a later agent switch cannot change that call's policy.
 - Context source changes never wake idle sessions; the next naturally scheduled **Safe Provider-Turn Boundary** loads and compares current values lazily.
 - Once admitted, a **Mid-Conversation System Message** remains durable even if the following provider attempt fails and is replayed unchanged on retry.
 - **Mid-Conversation System Messages** remain durable Session-message history; normal user-facing transcript surfaces may hide them.
 - The date **Context Source** initially preserves host-local calendar-date behavior; a configured user timezone may replace that default later.
 - A **Context Epoch** begins with one immutable **Baseline System Context**.
+- A **Context Epoch** durably records the effective agent that owns its **Baseline System Context**.
 - A **Baseline System Context** is stored durably and reused verbatim across process restarts within its **Context Epoch**.
 - A **Baseline System Context** durably preserves the exact joined text used for the active provider-cache prefix.
-- Completed compaction starts a new **Context Epoch** on the next provider attempt, folding the current complete **System Context** into a fresh baseline and removing earlier **Mid-Conversation System Messages** from active model history.
-- A model/provider switch preserves the current **Context Epoch** and chronological conversation history; the new selection applies to the next provider turn.
+- Compaction or a model/provider switch starts a new **Context Epoch** because the baseline can be replaced without preserving the prior provider cache.
+- A model/provider switch always starts a new **Context Epoch** while preserving chronological conversation history.
 - **Model Request Options** remain provider-semantic through Catalog resolution. The Session runner maps them into the LLM package's provider-option namespace; the selected protocol adapter alone owns provider wire encoding.
 - **Generation Controls**, protocol-semantic **Model Request Options**, and compatibility request body fields are separate Catalog domains. A shared ingestion adapter partitions legacy and models.dev AI-SDK-shaped options before routing.
 - The **PTY Environment** is a server concern rather than a Core PTY concern. PTY creation merges caller values, then the host overlay, then Core-forced terminal invariants such as `TERM` and `OPENCODE_TERMINAL`.

bun.lock

@@ -276,7 +276,6 @@
         "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
         "@opencode-ai/effect-sqlite-node": "workspace:*",
         "@opencode-ai/llm": "workspace:*",
-        "@opencode-ai/plugin": "workspace:*",
         "@openrouter/ai-sdk-provider": "2.9.0",
         "@opentelemetry/api": "1.9.0",
         "@opentelemetry/context-async-hooks": "2.6.1",
@@ -626,7 +625,6 @@
       "name": "@opencode-ai/plugin",
       "version": "1.17.9",
       "dependencies": {
-        "@ai-sdk/provider": "3.0.8",
         "@opencode-ai/sdk": "workspace:*",
         "effect": "catalog:",
         "zod": "catalog:",

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-oWSGu+SP66Aquy/0Vaq7Bgp8404ZdOWbQX+O7h3jxHU=",
-    "aarch64-linux": "sha256-UsS0+c+GwtIukmWwQeFbY/3Oaz3t4Q7C6cFMGkmlyAY=",
-    "aarch64-darwin": "sha256-CArz92ewPmXO+ORFCBkCH8LzMpU/DjyaO4ic7QL0UpI=",
-    "x86_64-darwin": "sha256-rhnz9gmG6L06wIzfMhTaXDDEf6IbMD32CavqwXoqcUs="
+    "x86_64-linux": "sha256-g0tDvRf7MErZ1PEeUazEYi492ZHiRT8kYv3bPdkss/I=",
+    "aarch64-linux": "sha256-6sKgf3ftbIqlPxlFkoPzoWPsJp3IwXD+H3Y6g874xmk=",
+    "aarch64-darwin": "sha256-Se/Nls/KlkuK2ysDQ9DeAzSaX3NsL2iDdf/dsv2GIXc=",
+    "x86_64-darwin": "sha256-V9MCkqnvQ1nkD2PaaTfNFKkBZGymj6KxrSAK6+DTF8Y="
   }
 }

packages/app/e2e/regression/review-line-comment.spec.ts

@@ -1,157 +0,0 @@
-import { expect, test, type Page } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectAppVisible, expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/ReviewLineCommentRegression"
-const sessionID = "ses_review_line_comment_regression"
-const title = "Review line comment regression"
-
-test.beforeEach(async ({ page }) => {
-  await openReview(page)
-})
-
-test("opens the comment editor when code is clicked", async ({ page }) => {
-  const review = page.locator('[data-component="session-review"]')
-  const line = review.getByText("export const value = 'after'", { exact: true })
-  await expectAppVisible(line)
-  await line.click()
-
-  await expect(review.getByRole("textbox")).toBeVisible()
-})
-
-test("opens the comment editor when a line number is clicked", async ({ page }) => {
-  const review = page.locator('[data-component="session-review"]')
-  const lineNumber = review.locator('[data-column-number="1"]').last()
-  await expectAppVisible(lineNumber)
-  await lineNumber.click()
-
-  await expect(review.getByRole("textbox")).toBeVisible()
-})
-
-test("opens the comment editor for a line number range", async ({ page }) => {
-  const review = page.locator('[data-component="session-review"]')
-  const start = review.locator('[data-column-number="1"]').last()
-  const end = review.locator('[data-column-number="3"]').last()
-  await expectAppVisible(start)
-  await expectAppVisible(end)
-
-  const from = await start.boundingBox()
-  const to = await end.boundingBox()
-  if (!from || !to) throw new Error("Missing line number bounds")
-  await page.mouse.move(from.x + from.width / 2, from.y + from.height / 2)
-  await page.mouse.down()
-  await page.mouse.move(to.x + to.width / 2, to.y + to.height / 2)
-  await page.mouse.up()
-
-  await expect(review.getByRole("textbox")).toBeVisible()
-})
-
-test("shows a comment button when a line number is hovered", async ({ page }) => {
-  const review = page.locator('[data-component="session-review"]')
-  const lineNumber = review.locator('[data-column-number="1"]').last()
-  await expectAppVisible(lineNumber)
-
-  const comment = review.getByRole("button", { name: "Comment", exact: true })
-  await expect(async () => {
-    await page.mouse.move(0, 0)
-    await lineNumber.hover()
-    await expect(comment).toBeVisible({ timeout: 500 })
-  }).toPass()
-  await comment.click()
-  await expect(review.getByRole("textbox")).toBeVisible()
-})
-
-test("stages a submitted line comment in the prompt context", async ({ page }) => {
-  const requests: string[] = []
-  page.on("request", (request) => {
-    if (request.method() !== "GET") requests.push(`${request.method()} ${new URL(request.url()).pathname}`)
-  })
-
-  const review = page.locator('[data-component="session-review"]')
-  await review.getByText("export const value = 'after'", { exact: true }).click()
-  await review.getByRole("textbox").fill("Use the existing value instead")
-  await review.locator('[data-slot="line-comment-action"][data-variant="primary"]').click()
-
-  await expect(review.getByText("Use the existing value instead", { exact: true })).toBeVisible()
-  await page.getByRole("tab", { name: "Session" }).click()
-  const context = page.getByText("Use the existing value instead", { exact: true }).last()
-  await expect(context).toBeVisible()
-  await expect(context.locator("..")).toContainText("review.ts:2")
-  expect(requests).toEqual([])
-})
-
-async function openReview(page: Page) {
-  await page.setViewportSize({ width: 700, height: 900 })
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: "proj_review_line_comment_regression",
-      worktree: directory,
-      vcs: "git",
-      name: "review-line-comment-regression",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [
-      {
-        id: sessionID,
-        slug: "review-line-comment-regression",
-        projectID: "proj_review_line_comment_regression",
-        directory,
-        title,
-        version: "dev",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-    ],
-    vcsDiff: [
-      {
-        file: "src/review.ts",
-        additions: 1,
-        deletions: 1,
-        status: "modified",
-        patch:
-          "diff --git a/src/review.ts b/src/review.ts\n--- a/src/review.ts\n+++ b/src/review.ts\n@@ -1,3 +1,3 @@\n export const first = 1\n-export const value = 'before'\n+export const value = 'after'\n export const last = 3\n",
-      },
-    ],
-    pageMessages: () => ({
-      items: [
-        {
-          info: {
-            id: "msg_review_line_comment_regression",
-            sessionID,
-            role: "user",
-            time: { created: 1700000000000 },
-            summary: { diffs: [] },
-            agent: "build",
-            model: { providerID: "opencode", modelID: "test" },
-          },
-          parts: [
-            {
-              id: "prt_review_line_comment_regression",
-              sessionID,
-              messageID: "msg_review_line_comment_regression",
-              type: "text",
-              text: "Review this change.",
-            },
-          ],
-        },
-      ],
-    }),
-  })
-
-  await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-  await expectSessionTitle(page, title)
-  const diffResponse = page.waitForResponse((response) => new URL(response.url()).pathname === "/vcs/diff")
-  await page.getByRole("tab", { name: "Changes" }).click()
-  expect(await (await diffResponse).json()).toHaveLength(1)
-
-  const review = page.locator('[data-component="session-review"]')
-  await expectAppVisible(review)
-  await review
-    .getByRole("heading", { name: /review\.ts/ })
-    .getByRole("button")
-    .first()
-    .click()
-}

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

@@ -21,7 +21,6 @@ const words = [
   "vector",
 ]
 
-const serverKey = "http://127.0.0.1:4096"
 const sourceID = "ses_smoke_source"
 const targetID = "ses_smoke_target"
 const directory = "C:/OpenCode/SmokeProject"
@@ -140,7 +139,7 @@ function toolPart(
       status: "completed",
       input,
       output: lorem(index * 23 + partIndex, outputLength),
-      title: tool === "bash" ? input.command : input.filePath || input.path || input.pattern || "completed",
+      title: tool === "bash" ? "Verify generated output" : input.filePath || input.path || input.pattern || "completed",
       metadata,
       time: { start: 1700000000000 + index * 10_000, end: 1700000000000 + index * 10_000 + 400 },
     },
@@ -201,7 +200,9 @@ function turn(index: number): Message[] {
     ...(index % 8 === 0
       ? [toolPart(index, 8, "apply_patch", { files: [`src/generated/patch-${index}.ts`] }, 620)]
       : []),
-    ...(index % 7 === 0 ? [toolPart(index, 4, "bash", { command: "bun typecheck" }, 620)] : []),
+    ...(index % 7 === 0
+      ? [toolPart(index, 4, "bash", { command: "bun typecheck", description: "Verify generated output" }, 620)]
+      : []),
     ...(index % 10 === 0 ? [toolPart(index, 9, "webfetch", { url: "https://example.com/docs/sample" }, 120)] : []),
     ...(index % 11 === 0 ? [toolPart(index, 10, "websearch", { query: "sample movement notes" }, 240)] : []),
     ...(index % 13 === 0
@@ -241,7 +242,6 @@ function orderedParts(message: Message) {
 
 export const fixture = {
   directory,
-  serverKey,
   project: {
     id: projectID,
     worktree: directory,
@@ -295,7 +295,6 @@ export const fixture = {
         .filter(renderable)
         .map((part) => part.id),
     ),
-    expandedShellPartID: targetMessages.flatMap((message) => message.parts).find((part) => part.tool === "bash")!.id,
   },
 }
 

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

@@ -327,18 +327,6 @@ test.describe("smoke: session timeline", () => {
     const expectedMessageIDs = fixture.expected.targetMessageIDs
     await expectSessionTimelineReady(page, expectedPartIDs, expectedMessageIDs, errors)
     await expectCanScrollToStart(page, expectedPartIDs, expectedMessageIDs, errors)
-
-    const shell = page.locator(`[data-timeline-part-id="${fixture.expected.expandedShellPartID}"]`)
-    const shellTrigger = shell.locator('[data-slot="collapsible-trigger"]')
-    const shellSubtitle = shell.locator('[data-slot="basic-tool-tool-subtitle"]')
-    await expect(shellSubtitle).toHaveCount(0)
-    await expect(shell.locator('[data-slot="bash-pre"]')).toContainText("$ bun typecheck")
-    await shellTrigger.click()
-    await expect(shellTrigger).toHaveAttribute("aria-expanded", "false")
-    await expect(shellSubtitle).toHaveText("bun typecheck")
-    await shellTrigger.click()
-    await expect(shellTrigger).toHaveAttribute("aria-expanded", "true")
-    await expect(shellSubtitle).toHaveCount(0)
   })
 })
 
@@ -718,8 +706,7 @@ async function navigateToSession(page: Page, directory: string, sessionId: strin
 }
 
 async function switchTitlebarSession(page: Page, sessionID: string, title: string) {
-  console.log(process.env)
-  const href = `/server/${base64Encode(fixture.serverKey)}/session/${sessionID}`
+  const href = `/${base64Encode(fixture.directory)}/session/${sessionID}`
   const tab = page.locator(`[data-slot="titlebar-tabs"] a[href="${href}"]`).first()
   await expect(tab).toBeVisible()
   await tab.click()

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

@@ -18,7 +18,6 @@ export interface MockServerConfig {
   project: unknown
   sessions: ({ id: string } & Record<string, unknown>)[]
   pageMessages: (sessionId: string, limit: number, before?: string) => { items: unknown[]; cursor?: string }
-  vcsDiff?: unknown[]
   messageDelay?: number
   onMessages?: (input: { sessionID: string; before?: string; phase: "start" | "end" }) => void
   events?: () => unknown[]
@@ -53,7 +52,6 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
     const path = url.pathname
     if (path === "/global/event" || path === "/event") return sse(route, config.events?.(), config.eventRetry)
     if (path === "/global/health") return json(route, { healthy: true })
-    if (path === "/vcs/diff" && config.vcsDiff) return json(route, config.vcsDiff)
     if (emptyObject.has(path)) return json(route, {})
     if (emptyList.has(path)) return json(route, [])
     if (path in staticRoutes) return json(route, staticRoutes[path])

packages/app/index.html

@@ -1,28 +1,22 @@
 <!doctype html>
-<html lang="en" style="background-color: var(--v2-background-bg-deep, #fafafa)">
+<html lang="en" style="background-color: var(--background-base)">
   <head>
     <meta charset="utf-8" />
-    <meta
-      name="viewport"
-      content="width=device-width, initial-scale=1, interactive-widget=resizes-content, viewport-fit=cover"
-    />
+    <meta name="viewport" content="width=device-width, initial-scale=1, interactive-widget=resizes-content" />
     <title>OpenCode</title>
     <link rel="icon" type="image/png" href="/favicon-96x96-v3.png" sizes="96x96" />
     <link rel="icon" type="image/svg+xml" href="/favicon-v3.svg" />
     <link rel="shortcut icon" href="/favicon-v3.ico" />
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-v3.png" />
     <link rel="manifest" href="/site.webmanifest" />
-    <meta name="theme-color" content="#fafafa" />
-    <meta name="mobile-web-app-capable" content="yes" />
-    <meta name="apple-mobile-web-app-capable" content="yes" />
-    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <meta name="theme-color" content="#F8F7F7" />
     <meta property="og:image" content="/social-share.png" />
     <meta property="twitter:image" content="/social-share.png" />
     <script id="oc-theme-preload-script" src="/oc-theme-preload.js"></script>
   </head>
-  <body class="antialiased overscroll-none text-12-regular overflow-hidden bg-v2-background-bg-deep">
+  <body class="antialiased overscroll-none text-12-regular overflow-hidden">
     <noscript>You need to enable JavaScript to run this app.</noscript>
-    <div id="root" class="flex flex-col h-dvh bg-v2-background-bg-deep p-px"></div>
+    <div id="root" class="flex flex-col h-dvh p-px"></div>
     <script src="/src/entry.tsx" type="module"></script>
   </body>
 </html>

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

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

packages/app/src/app.tsx

@@ -10,7 +10,7 @@ import { Splash } from "@opencode-ai/ui/logo"
 import { ThemeProvider } from "@opencode-ai/ui/theme/context"
 import { MetaProvider } from "@solidjs/meta"
 import { type BaseRouterProps, Navigate, Route, Router, useParams, useSearchParams } from "@solidjs/router"
-import { keepPreviousData, QueryClient, QueryClientProvider, useQuery } from "@tanstack/solid-query"
+import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
 import { Effect } from "effect"
 import {
   type Component,
@@ -30,7 +30,7 @@ import { Dynamic } from "solid-js/web"
 import { CommandProvider } from "@/context/command"
 import { CommentsProvider } from "@/context/comments"
 import { FileProvider } from "@/context/file"
-import { ServerSDKProvider, useServerSDK } from "@/context/server-sdk"
+import { ServerSDKProvider } from "@/context/server-sdk"
 import { ServerSyncProvider } from "@/context/server-sync"
 import { GlobalProvider } from "@/context/global"
 import { HighlightsProvider } from "@/context/highlights"
@@ -47,14 +47,11 @@ import { TabsProvider, useTabs, type DraftTab } from "@/context/tabs"
 import { SDKProvider, useSDK } from "@/context/sdk"
 import { WslServersProvider } from "@/wsl/context"
 import DirectoryLayout, { DirectoryDataProvider } from "@/pages/directory-layout"
-import LegacyLayout from "@/pages/layout"
-import NewLayout from "@/pages/layout-new"
+import Layout from "@/pages/layout"
 import { ErrorPage } from "./pages/error"
 import { useCheckServerHealth } from "./utils/server-health"
-import { legacySessionHref, requireServerKey, rootSession, sessionHref } from "./utils/session-route"
 
-const LegacyHome = lazy(() => import("@/pages/home").then((module) => ({ default: module.LegacyHome })))
-const NewHome = lazy(() => import("@/pages/home").then((module) => ({ default: module.NewHome })))
+const HomeRoute = lazy(() => import("@/pages/home"))
 const Session = lazy(() => import("@/pages/session"))
 const NewSession = lazy(() => import("@/pages/new-session"))
 
@@ -67,10 +64,6 @@ const SessionRoute = Object.assign(
     const server = useServer()
     const tabs = useTabs()
 
-    if (params.id && settings.general.newLayoutDesigns()) {
-      return <Navigate href={sessionHref(server.key, params.id)} />
-    }
-
     // When the new layout is enabled, the legacy new-session route (/:dir/session with no id)
     // is replaced by a draft at /new-session?draftId=…
     createEffect(() => {
@@ -89,55 +82,29 @@ const SessionRoute = Object.assign(
   { preload: Session.preload },
 )
 
-const TargetSessionRoute = Object.assign(
-  () => {
-    const sdk = useSDK()
-    const serverSDK = useServerSDK()
-    return (
-      <Show when={`${serverSDK().scope}\0${sdk().directory}`} keyed>
-        <SessionProviders>
-          <Session />
-        </SessionProviders>
-      </Show>
-    )
-  },
-  { preload: Session.preload },
-)
-
 // Wraps the non-draft routes. They are gated on (and keyed to) the globally selected
 // server via ServerKey, then provide the server-scoped shell (Permission/Layout/
 // Notification/Models + the visual Layout) for that server.
-function SelectedServerProviders(props: ParentProps) {
+function SelectedServerLayout(props: ParentProps) {
   return (
     <ServerKey>
       <ServerSDKProvider>
-        <ServerSyncProvider>{props.children}</ServerSyncProvider>
+        <ServerSyncProvider>
+          <ServerScopedShell>{props.children}</ServerScopedShell>
+        </ServerSyncProvider>
       </ServerSDKProvider>
     </ServerKey>
   )
 }
 
-function LegacyServerLayout(props: ParentProps) {
-  return (
-    <SelectedServerProviders>
-      <LegacyServerScopedShell>{props.children}</LegacyServerScopedShell>
-    </SelectedServerProviders>
-  )
-}
-
 // Wraps /new-session. It resolves the draft's target server and provides the
 // server-scoped shell for that server — without ServerKey, so the page never depends
 // on the globally "selected" server.
-function TargetServerLayout(props: ParentProps) {
+function DraftServerLayout(props: ParentProps) {
   const server = useServer()
   const tabs = useTabs()
-  const params = useParams<{ serverKey?: string }>()
   const [search] = useSearchParams<{ draftId?: string }>()
   const conn = createMemo(() => {
-    if (params.serverKey) {
-      const key = requireServerKey(params.serverKey)
-      return server.list.find((item) => ServerConnection.key(item) === key)
-    }
     const id = search.draftId
     if (!id) return undefined
     const draft = tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === id)
@@ -148,98 +115,48 @@ function TargetServerLayout(props: ParentProps) {
   return (
     <ServerSDKProvider server={conn}>
       <ServerSyncProvider server={conn}>
-        <TargetDirectoryLayout>{props.children}</TargetDirectoryLayout>
+        <ServerScopedShell>{props.children}</ServerScopedShell>
       </ServerSyncProvider>
     </ServerSDKProvider>
   )
 }
 
-function TargetDirectoryLayout(props: ParentProps) {
-  const params = useParams<{ serverKey?: string; id?: string }>()
-  const [search] = useSearchParams<{ draftId?: string }>()
-  const settings = useSettings()
-  const tabs = useTabs()
-  const serverSDK = useServerSDK()
-  const serverKey = createMemo(() => {
-    if (params.serverKey) return requireServerKey(params.serverKey)
-    if (!search.draftId) return undefined
-    return tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)?.server
-  })
-
-  const resolved = useQuery(() => ({
-    queryKey: [serverSDK().scope, "session-route", params.id] as const,
-    enabled: !!params.serverKey && !!params.id,
-    placeholderData: keepPreviousData,
-    queryFn: async () => {
-      const session = (await serverSDK().client.session.get({ sessionID: params.id! })).data!
-      const root = await rootSession(session, (sessionID) =>
-        serverSDK()
-          .client.session.get({ sessionID })
-          .then((result) => result.data!),
-      )
-      return { session, rootID: root.id }
-    },
-  }))
-  const resolvedDirectory = createMemo(() => {
-    if (params.serverKey) return resolved.data?.session.directory
-    if (!search.draftId) return undefined
-    return tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)?.directory
-  })
-  const directory = createMemo<string | undefined>((prev) => prev ?? resolvedDirectory())
-  const home = () => !params.serverKey && !search.draftId
-  const targetDirectory = () => directory()!
-
-  createEffect(() => {
-    const current = resolved.data
-    const key = serverKey()
-    if (!current || !key) return
-    tabs.addSessionTab({
-      server: key,
-      sessionId: current.rootID,
-    })
-  })
-
-  return (
-    <NewServerScopedShell directory={() => (home() ? undefined : directory())} sessionID={() => params.id}>
-      <Show when={!home()} fallback={props.children}>
-        <Show when={!resolved.error} fallback={<ErrorPage error={resolved.error} />}>
-          <Show when={directory()}>
-            <Show
-              when={!params.serverKey || settings.general.newLayoutDesigns()}
-              fallback={<Navigate href={legacySessionHref(directory()!, params.id!)} />}
-            >
-              <SDKProvider directory={targetDirectory}>
-                <DirectoryDataProvider directory={targetDirectory} server={serverKey}>
-                  <Show when={!params.serverKey || (resolved.data && !resolved.isPlaceholderData)}>
-                    {props.children}
-                  </Show>
-                </DirectoryDataProvider>
-              </SDKProvider>
-            </Show>
-          </Show>
-        </Show>
-      </Show>
-    </NewServerScopedShell>
-  )
-}
-
 function DraftRoute() {
   const [search] = useSearchParams<{ draftId?: string }>()
   const tabs = useTabs()
   return (
     <Show when={tabs.ready()}>
       <Show when={search.draftId} keyed fallback={<Navigate href="/" />}>
-        <ResolvedDraftRoute />
+        {(draftID) => <ResolvedDraftRoute draftID={draftID} />}
       </Show>
     </Show>
   )
 }
 
-function ResolvedDraftRoute() {
+function ResolvedDraftRoute(props: { draftID: string }) {
+  const tabs = useTabs()
+  const draft = createMemo(() =>
+    tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === props.draftID),
+  )
+
+  // Key on the directory so retargeting the draft's project re-instantiates the
+  // directory-scoped providers while keeping the same draft id. The draft's target
+  // server is provided by DraftServerLayout, so changing only the server updates the
+  // SDK/sync hooks without remounting the composer.
+  const directory = () => draft()?.directory
+
   return (
-    <DraftProviders>
-      <NewSession />
-    </DraftProviders>
+    <Show when={directory()} keyed>
+      {(dir) => (
+        <SDKProvider directory={dir}>
+          <DirectoryDataProvider directory={dir} draftID={props.draftID}>
+            <DraftProviders>
+              <NewSession />
+            </DraftProviders>
+          </DirectoryDataProvider>
+        </SDKProvider>
+      )}
+    </Show>
   )
 }
 
@@ -293,51 +210,32 @@ function BodyDesignClass() {
 // shell (router root) so they stay mounted regardless of the active server/route.
 function SharedProviders(props: ParentProps) {
   return (
-    <>
+    <SettingsProvider>
       <BodyDesignClass />
       <CommandProvider>
         <HighlightsProvider>{props.children}</HighlightsProvider>
       </CommandProvider>
-    </>
+    </SettingsProvider>
   )
 }
 
 // Server-scoped providers plus the visual Layout (tabs/sidebar). These live inside
 // each per-route server layout so they resolve to that route's server (selected vs
 // draft). The Layout remounts when crossing between those groups.
-type ServerScopedShellProps = ParentProps<{
-  directory?: () => string | undefined
-  sessionID?: () => string | undefined
-}>
-
-function ServerScopedProviders(props: ServerScopedShellProps) {
+function ServerScopedShell(props: ParentProps) {
   return (
-    <PermissionProvider directory={props.directory}>
+    <PermissionProvider>
       <LayoutProvider>
-        <NotificationProvider directory={props.directory} sessionID={props.sessionID}>
-          <ModelsProvider>{props.children}</ModelsProvider>
+        <NotificationProvider>
+          <ModelsProvider>
+            <Layout>{props.children}</Layout>
+          </ModelsProvider>
         </NotificationProvider>
       </LayoutProvider>
     </PermissionProvider>
   )
 }
 
-function LegacyServerScopedShell(props: ServerScopedShellProps) {
-  return (
-    <ServerScopedProviders directory={props.directory} sessionID={props.sessionID}>
-      <LegacyLayout>{props.children}</LegacyLayout>
-    </ServerScopedProviders>
-  )
-}
-
-function NewServerScopedShell(props: ServerScopedShellProps) {
-  return (
-    <ServerScopedProviders directory={props.directory} sessionID={props.sessionID}>
-      <NewLayout>{props.children}</NewLayout>
-    </ServerScopedProviders>
-  )
-}
-
 function SessionProviders(props: ParentProps) {
   return (
     <TerminalProvider>
@@ -541,61 +439,28 @@ export function AppInterface(props: {
       servers={props.servers}
     >
       <GlobalProvider>
-        <SettingsProvider>
-          <ConnectionGate disableHealthCheck={props.disableHealthCheck}>
-            <Show when={useSettings().general.newLayoutDesigns().toString()} keyed>
-              <Dynamic
-                component={props.router ?? Router}
-                root={(routerProps) => (
-                  <TabsProvider>
-                    <ServerShell>{routerProps.children}</ServerShell>
-                  </TabsProvider>
-                )}
-              >
-                <Routes />
-              </Dynamic>
-            </Show>
-          </ConnectionGate>
-        </SettingsProvider>
+        <ConnectionGate disableHealthCheck={props.disableHealthCheck}>
+          <Dynamic
+            component={props.router ?? Router}
+            root={(routerProps) => (
+              <TabsProvider>
+                <ServerShell>{routerProps.children}</ServerShell>
+              </TabsProvider>
+            )}
+          >
+            <Route component={SelectedServerLayout}>
+              <Route path="/" component={HomeRoute} />
+              <Route path="/:dir" component={DirectoryLayout}>
+                <Route path="/" component={() => <Navigate href="session" />} />
+                <Route path="/session/:id?" component={SessionRoute} />
+              </Route>
+            </Route>
+            <Route component={DraftServerLayout}>
+              <Route path="/new-session" component={DraftRoute} />
+            </Route>
+          </Dynamic>
+        </ConnectionGate>
       </GlobalProvider>
     </ServerProvider>
   )
 }
-
-function Routes() {
-  const settings = useSettings()
-
-  return (
-    <>
-      <Route component={LegacyServerLayout}>
-        <Show when={!settings.general.newLayoutDesigns()}>{<Route path="/" component={LegacyHome} />}</Show>
-        <Route path="/:dir" component={DirectoryLayout}>
-          <Route path="/" component={() => <Navigate href="session" />} />
-          <Route path="/session/:id?" component={SessionRoute} />
-        </Route>
-      </Route>
-      <Route component={TargetServerLayout}>
-        <Show when={settings.general.newLayoutDesigns()}>
-          {
-            <>
-              <Route path="/" component={NewHome} />
-              <Route path="/:dir" component={DirectoryLayout}>
-                <Route
-                  path="/session/:id"
-                  component={() => {
-                    const server = useServer()
-                    const { id } = useParams()
-
-                    return <Navigate href={`/server/${server.key}/session/${id}`} />
-                  }}
-                />
-              </Route>
-            </>
-          }
-        </Show>
-        <Route path="/new-session" component={DraftRoute} />
-        <Route path="/server/:serverKey/session/:id" component={TargetSessionRoute} />
-      </Route>
-    </>
-  )
-}

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

@@ -388,7 +388,12 @@ export function createPromptSubmit(input: PromptSubmitInput) {
         local.session.promote(sessionDirectory, session.id)
         layout.handoff.setTabs(base64Encode(sessionDirectory), session.id)
         const draftID = search.draftId
-        if (draftID) tabs.promoteDraft(draftID, { server: server.key, sessionId: session.id })
+        if (draftID)
+          tabs.promoteDraft(draftID, {
+            server: server.key,
+            dirBase64: base64Encode(sessionDirectory),
+            sessionId: session.id,
+          })
         else navigate(`/${base64Encode(sessionDirectory)}/session/${session.id}`)
       }
     }

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

@@ -10,7 +10,6 @@ import { Tooltip, TooltipKeybind } from "@opencode-ai/ui/tooltip"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { createEffect, createMemo, createSignal, For, onMount, Show } from "solid-js"
 import { createStore } from "solid-js/store"
-import { createMediaQuery } from "@solid-primitives/media"
 import { Portal } from "solid-js/web"
 import { useCommand } from "@/context/command"
 import { useLanguage } from "@/context/language"
@@ -159,7 +158,6 @@ export function SessionHeader() {
   const isV2 = settings.general.newLayoutDesigns
   const search = settings.visibility.search
   const status = settings.visibility.status
-  const isDesktop = createMediaQuery("(min-width: 768px)")
 
   const [exists, setExists] = createStore<Partial<Record<OpenApp, boolean>>>({
     finder: true,
@@ -238,7 +236,6 @@ export function SessionHeader() {
     statusLabel: language.t("status.popover.trigger"),
     reviewLabel: language.t("command.review.toggle"),
     reviewKeybind: command.keybind("review.toggle"),
-    reviewVisible: isDesktop(),
     reviewOpened: view().reviewPanel.opened(),
     onReviewToggle: () => view().reviewPanel.toggle(),
   }))
@@ -521,7 +518,6 @@ type SessionHeaderV2ActionsState = {
   statusLabel: string
   reviewLabel: string
   reviewKeybind: string
-  reviewVisible: boolean
   reviewOpened: boolean
   onReviewToggle: () => void
 }
@@ -534,22 +530,20 @@ function SessionHeaderV2Actions(props: { state: SessionHeaderV2ActionsState }) {
           <StatusPopoverV2 />
         </Tooltip>
       </Show>
-      <Show when={props.state.reviewVisible}>
-        <TooltipKeybind title={props.state.reviewLabel} keybind={props.state.reviewKeybind}>
-          <IconButtonV2
-            type="button"
-            variant="ghost-muted"
-            size="large"
-            class="!w-9 shrink-0"
-            state={props.state.reviewOpened ? "pressed" : undefined}
-            onClick={props.state.onReviewToggle}
-            aria-label={props.state.reviewLabel}
-            aria-expanded={props.state.reviewOpened}
-            aria-controls="review-panel"
-            icon={<IconV2 name="sidebar-right" />}
-          />
-        </TooltipKeybind>
-      </Show>
+      <TooltipKeybind title={props.state.reviewLabel} keybind={props.state.reviewKeybind}>
+        <IconButtonV2
+          type="button"
+          variant="ghost-muted"
+          size="large"
+          class="!w-9 shrink-0"
+          state={props.state.reviewOpened ? "pressed" : undefined}
+          onClick={props.state.onReviewToggle}
+          aria-label={props.state.reviewLabel}
+          aria-expanded={props.state.reviewOpened}
+          aria-controls="review-panel"
+          icon={<IconV2 name="sidebar-right" />}
+        />
+      </TooltipKeybind>
     </div>
   )
 }

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

@@ -1,5 +1,4 @@
 import { Component, Show, createMemo, createResource, onMount } from "solid-js"
-import { createMediaQuery } from "@solid-primitives/media"
 import { ButtonV2 } from "@opencode-ai/ui/v2/button-v2"
 import { SelectV2 } from "@opencode-ai/ui/v2/select-v2"
 import { Switch } from "@opencode-ai/ui/v2/switch-v2"
@@ -90,7 +89,6 @@ export const SettingsGeneralV2: Component = () => {
   const dialog = useDialog()
   const params = useParams()
   const settings = useSettings()
-  const mobile = createMediaQuery("(max-width: 767px)")
 
   const updater = useUpdaterAction()
 
@@ -347,20 +345,6 @@ export const SettingsGeneralV2: Component = () => {
             />
           </div>
         </SettingsRowV2>
-
-        <Show when={mobile()}>
-          <SettingsRowV2
-            title={language.t("settings.general.row.mobileTitlebarBottom.title")}
-            description={language.t("settings.general.row.mobileTitlebarBottom.description")}
-          >
-            <div data-action="settings-mobile-titlebar-bottom">
-              <Switch
-                checked={settings.general.mobileTitlebarPosition() === "bottom"}
-                onChange={(checked) => settings.general.setMobileTitlebarPosition(checked ? "bottom" : "top")}
-              />
-            </div>
-          </SettingsRowV2>
-        </Show>
       </SettingsListV2>
     </div>
   )

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

@@ -1,3 +1,4 @@
+import { ButtonV2 } from "@opencode-ai/ui/v2/button-v2"
 import { Tag } from "@opencode-ai/ui/v2/badge-v2"
 import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { IconButtonV2 } from "@opencode-ai/ui/v2/icon-button-v2"
@@ -13,7 +14,7 @@ import { ServerConnection, serverName } from "@/context/server"
 import { useServerManagementController } from "../dialog-select-server"
 import { DialogServerV2 } from "./dialog-server-v2"
 import { SettingsListV2 } from "./parts/list"
-import { AddServerMenu, isWslServer, useFilteredWslServers, WslServerSettings } from "@/wsl/settings"
+import { isWslServer, useFilteredWslServers, WslAddServerButton, WslServerSettings } from "@/wsl/settings"
 import "./settings-v2.css"
 
 export const SettingsServersV2: Component = () => {
@@ -54,7 +55,10 @@ export const SettingsServersV2: Component = () => {
       >
         <div class="settings-v2-tab-header-row">
           <h2 class="settings-v2-tab-title">{language.t("status.popover.tab.servers")}</h2>
-          <AddServerMenu onAddServer={openAdd} />
+          <ButtonV2 variant="ghost-muted" icon="plus" onClick={openAdd}>
+            {language.t("dialog.server.add.button")}
+          </ButtonV2>
+          <WslAddServerButton />
         </div>
         <Show when={showSearch()}>
           <div class="settings-v2-tab-search">

packages/app/src/components/titlebar.tsx

@@ -29,20 +29,19 @@ import { useLanguage } from "@/context/language"
 import { useSettings } from "@/context/settings"
 import { WindowsAppMenu } from "./windows-app-menu"
 import { applyPath, backPath, forwardPath } from "./titlebar-history"
+import { useServerSync } from "@/context/server-sync"
 import { base64Encode } from "@opencode-ai/core/util/encode"
 import { ProjectAvatar } from "@opencode-ai/ui/v2/project-avatar-v2"
 import { displayName, getProjectAvatarSource, projectForSession } from "@/pages/layout/helpers"
 import { useSessionTabAvatarState } from "@/pages/layout/project-avatar-state"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { createResizeObserver } from "@solid-primitives/resize-observer"
-import { createMediaQuery } from "@solid-primitives/media"
 import { readSessionTabsRemovedDetail, SESSION_TABS_REMOVED_EVENT } from "@/components/titlebar-session-events"
 import { useGlobal } from "@/context/global"
+import { decode64 } from "@/utils/base64"
 import { ServerConnection, useServer } from "@/context/server"
-import { tabHref, useTabs } from "@/context/tabs"
+import { tabHref, useTabs, type Tab } from "@/context/tabs"
 import "./titlebar.css"
-import { useServerSDK } from "@/context/server-sdk"
-import { Session } from "@opencode-ai/sdk/v2"
 
 type TauriDesktopWindow = {
   startDragging?: () => Promise<void>
@@ -88,8 +87,6 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
   const location = useLocation()
   const params = useParams()
   const useV2Titlebar = createMemo(() => settings.general.newLayoutDesigns())
-  const mobile = createMediaQuery("(max-width: 767px)")
-  const bottom = createMemo(() => useV2Titlebar() && mobile() && settings.general.mobileTitlebarPosition() === "bottom")
 
   const mac = createMemo(() => platform.platform === "desktop" && platform.os === "macos")
   const windows = createMemo(() => platform.platform === "desktop" && platform.os === "windows")
@@ -101,10 +98,6 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
   const counterZoom = () => (windows() && titlebarZoom() < 1 ? 1 / titlebarZoom() : 1)
   const minHeight = () => {
     const height = useV2Titlebar() ? v2TitlebarHeight : legacyTitlebarHeight
-    if (useV2Titlebar() && mobile()) {
-      const inset = bottom() ? "env(safe-area-inset-bottom, 0px)" : "env(safe-area-inset-top, 0px)"
-      return `calc(${height}px + ${inset})`
-    }
     if (mac()) return `${height / zoom()}px`
     if (windows()) return `${height / Math.min(titlebarZoom(), 1)}px`
     return undefined
@@ -242,13 +235,10 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
         "shrink-0 relative flex flex-row": true,
         "h-9 bg-v2-background-bg-deep overflow-visible": useV2Titlebar(),
         "h-10 bg-background-base overflow-hidden": !useV2Titlebar(),
-        "order-last": bottom(),
       }}
       style={{
         "min-height": minHeight(),
-        "padding-top": useV2Titlebar() && mobile() && !bottom() ? "env(safe-area-inset-top, 0px)" : undefined,
-        "padding-bottom": bottom() ? "env(safe-area-inset-bottom, 0px)" : undefined,
-        "padding-left": mac() && !mobile() ? `${84 / zoom()}px` : 0,
+        "padding-left": mac() ? `${84 / zoom()}px` : 0,
         width: electronWindows() ? `env(titlebar-area-width, calc(100vw - ${windowsControlsWidth()}))` : undefined,
         "max-width": electronWindows()
           ? `env(titlebar-area-width, calc(100vw - ${windowsControlsWidth()}))`
@@ -262,7 +252,7 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
       <Switch>
         <Match when={useV2Titlebar()}>
           {(_) => {
-            const serverSdk = useServerSDK()
+            const serverSync = useServerSync()
             const navigate = useNavigate()
             const layout = useLayout()
 
@@ -278,17 +268,6 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
             const tabs = useTabs()
             const tabsStore = tabs.store
             const tabsStoreActions = tabs
-            const [session] = createResource(
-              () => {
-                const route = layout.route()
-                return route.type === "session" ? route : undefined
-              },
-              (route) =>
-                serverSdk()
-                  .client.session.get({ sessionID: route.sessionId })
-                  .then((x) => x.data)
-                  .catch(() => {}),
-            )
 
             const matchRoute = (route: LayoutRoute) => {
               if (route.type === "home") return
@@ -301,9 +280,10 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                     item.type === "session" && item.server === route.server && item.sessionId === route.sessionId,
                 )
                 if (main) return main
-                const s = session()
-                if (s?.parentID) {
-                  const parentID = s.parentID
+                const sync = serverSync().createDirSyncContext(route.dir)
+                const session = sync.session.get(route.sessionId)
+                if (session?.parentID) {
+                  const parentID = session.parentID
                   const parent = tabsStore.find(
                     (item) => item.type === "session" && item.server === route.server && item.sessionId === parentID,
                   )
@@ -324,10 +304,15 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
               }
 
               if (route.type === "session") {
-                const s = session()
-                if (!s) return
-                const sessionId = s.parentID ?? s.id
-                const next = { server: route.server ?? server.key, sessionId }
+                const sync = serverSync().createDirSyncContext(route.dir)
+                const session = sync.session.get(route.sessionId)
+                if (!session) return
+                const sessionId = session.parentID ?? session.id
+                const next = {
+                  server: route.server ?? server.key,
+                  dirBase64: route.dirBase64,
+                  sessionId,
+                }
                 tabsStoreActions.addSessionTab(next)
               }
             })
@@ -436,12 +421,10 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
 
             return (
               <div
-                class="h-full flex-1 overflow-hidden flex flex-row items-center gap-1.5 px-2 md:pr-3"
+                class="h-full flex-1 overflow-hidden flex flex-row items-center gap-1.5 pr-3 pt-2"
                 classList={{
-                  "pt-2": !bottom(),
-                  "pb-2": bottom(),
-                  "md:pl-2": mac(),
-                  "md:pl-4": !mac(),
+                  "pl-2": mac(),
+                  "pl-4": !mac(),
                 }}
               >
                 <ChannelIndicator />
@@ -512,38 +495,25 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                             )
                           }
 
-                          const [session] = createResource(
-                            () => tab.sessionId,
-                            (sessionID) =>
-                              serverSdk()
-                                .client.session.get({ sessionID })
-                                .then((x) => x.data)
-                                .catch(() => undefined),
-                          )
-
                           return (
                             <>
                               {divider()}
-                              <Show when={session()}>
-                                {(session) => (
-                                  <TabNavItem
-                                    ref={ref}
-                                    href={tabHref(tab)}
-                                    server={tab.server}
-                                    sessionId={tab.sessionId}
-                                    session={session()}
-                                    onNavigate={() => {
-                                      tabs.select(tab)
+                              <TabNavItem
+                                ref={ref}
+                                href={tabHref(tab)}
+                                server={tab.server}
+                                directory={decode64(tab.dirBase64)!}
+                                sessionId={tab.sessionId}
+                                onNavigate={() => {
+                                  tabs.select(tab)
 
-                                      ref.scrollIntoView({ behavior: "instant" })
-                                    }}
-                                    onClose={() => tabsStoreActions.removeTab(i())}
-                                    active={currentTab() === tab}
-                                    activeServer={tab.server === server.key}
-                                    forceTruncate={tabsAreOverflowing()}
-                                  />
-                                )}
-                              </Show>
+                                  ref.scrollIntoView({ behavior: "instant" })
+                                }}
+                                onClose={() => tabsStoreActions.removeTab(i())}
+                                active={currentTab() === tab}
+                                activeServer={tab.server === server.key}
+                                forceTruncate={tabsAreOverflowing()}
+                              />
                             </>
                           )
                         }}
@@ -823,6 +793,7 @@ function TabNavItem(props: {
   ref?: HTMLDivElement
   href: string
   server: ServerConnection.Key
+  directory: string
   sessionId?: string
   hideClose?: boolean
   onClose: () => void
@@ -830,19 +801,31 @@ function TabNavItem(props: {
   active?: boolean
   activeServer: boolean
   forceTruncate?: boolean
-  session: Session
 }) {
   const closeTab = (event: MouseEvent) => {
     event.preventDefault()
     event.stopPropagation()
     props.onClose()
   }
-
   const global = useGlobal()
   const serverCtx = createMemo(() => {
     const conn = global.servers.list().find((item) => ServerConnection.key(item) === props.server)
     if (conn) return global.createServerCtx(conn)
   })
+  const dirSyncCtx = createMemo(() => serverCtx()?.sync.createDirSyncContext(props.directory))
+
+  const [session] = createResource(
+    () => {
+      const ctx = dirSyncCtx()
+      if (!ctx || !props.sessionId) return
+      return [props.sessionId, ctx] as const
+    },
+    async ([sessionId, dirSyncCtx]) => {
+      await dirSyncCtx.session.sync(sessionId).catch(() => {})
+      return dirSyncCtx.session.get(sessionId)
+    },
+    { initialValue: props.sessionId ? dirSyncCtx()?.session.get(props.sessionId) : undefined },
+  )
 
   return (
     <div
@@ -854,7 +837,7 @@ function TabNavItem(props: {
         closeTab(event)
       }}
     >
-      <Show when={props.session}>
+      <Show when={session.latest}>
         {(session) => {
           const project = createMemo(() => projectForSession(session(), serverCtx()?.projects.list() ?? []))
 
@@ -870,7 +853,7 @@ function TabNavItem(props: {
               <span data-slot="project-avatar-slot">
                 <ProjectTabAvatar
                   project={project()}
-                  directory={session().directory}
+                  directory={props.directory}
                   sessionId={session().id}
                   activeServer={props.activeServer}
                 />

packages/app/src/context/comments.tsx

@@ -2,14 +2,12 @@ import { batch, createMemo, createRoot, onCleanup } from "solid-js"
 import { createStore, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { useParams } from "@solidjs/router"
-import { base64Encode } from "@opencode-ai/core/util/encode"
 import { Persist, persisted } from "@/utils/persist"
 import { useServerSDK } from "./server-sdk"
 import type { ServerScope } from "@/utils/server-scope"
 import { createScopedCache } from "@/utils/scoped-cache"
 import { uuid } from "@/utils/uuid"
 import type { SelectedLineRange } from "@/context/file"
-import { useSDK } from "./sdk"
 
 export type LineComment = {
   id: string
@@ -204,7 +202,6 @@ export const { use: useComments, provider: CommentsProvider } = createSimpleCont
   gate: false,
   init: () => {
     const params = useParams()
-    const sdk = useSDK()
     const serverSDK = useServerSDK()
     const cache = createScopedCache(
       (key) => {
@@ -231,7 +228,7 @@ export const { use: useComments, provider: CommentsProvider } = createSimpleCont
       return cache.get(key).value
     }
 
-    const session = createMemo(() => load(base64Encode(sdk().directory), params.id))
+    const session = createMemo(() => load(params.dir!, params.id))
 
     return {
       ready: () => session().ready(),

packages/app/src/context/file.tsx

@@ -3,7 +3,6 @@ import { createStore, produce, reconcile } from "solid-js/store"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { showToast } from "@/utils/toast"
 import { useParams } from "@solidjs/router"
-import { base64Encode } from "@opencode-ai/core/util/encode"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { useSDK } from "./sdk"
 import { useSync } from "./sync"
@@ -66,7 +65,7 @@ export const { use: useFile, provider: FileProvider } = createSimpleContext({
     const scope = createMemo(() => sdk().directory)
     const path = createPathHelpers(scope)
     const tabs = layout.tabs(() =>
-      SessionStateKey.from(serverSDK().scope, SessionRouteKey.fromRoute(base64Encode(sdk().directory), params.id)),
+      SessionStateKey.from(serverSDK().scope, SessionRouteKey.fromRoute(params.dir, params.id)),
     )
 
     const inflight = new Map<string, Promise<void>>()

packages/app/src/context/layout.tsx

@@ -16,7 +16,6 @@ import { createPathHelpers } from "./file/path"
 import type { ProjectAvatarVariant } from "@opencode-ai/ui/v2/project-avatar-v2"
 import { migrateLegacySessionStateKeys, ServerScope, SessionStateKey } from "@/utils/server-scope"
 import { createSessionKeyReader, ensureSessionKey, pruneSessionKeys } from "./layout-helpers"
-import { requireServerKey } from "@/utils/session-route"
 
 export { createSessionKeyReader, ensureSessionKey, pruneSessionKeys }
 
@@ -80,7 +79,7 @@ export type LayoutRoute =
   | { type: "home" }
   | { type: "draft"; draftID: string; server?: ServerConnection.Key }
   | { type: "dir-new-sesssion"; dir: string; dirBase64: string; server?: ServerConnection.Key }
-  | { type: "session"; sessionId: string; server?: ServerConnection.Key }
+  | { type: "session"; dir: string; dirBase64: string; sessionId: string; server?: ServerConnection.Key }
 
 function nextSessionTabsForOpen(current: SessionTabs | undefined, tab: string): SessionTabs {
   const all = current?.all ?? []
@@ -132,14 +131,6 @@ const currentRoute = (pathname: string, search: string): LayoutRoute => {
     return { type: "draft", draftID }
   }
 
-  if (parts[0] === "server" && parts[2] === "session" && parts[3]) {
-    return {
-      type: "session",
-      sessionId: parts[3],
-      server: requireServerKey(parts[1]),
-    }
-  }
-
   const dirBase64 = parts[0]
   const dir = decode64(dirBase64)
   if (!dir) return { type: "home" }
@@ -147,7 +138,7 @@ const currentRoute = (pathname: string, search: string): LayoutRoute => {
   if (parts[1] !== "session") return { type: "home" }
 
   const id = parts[2]
-  if (id) return { type: "session", sessionId: id }
+  if (id) return { type: "session", dir, dirBase64, sessionId: id }
   return { type: "dir-new-sesssion", dir, dirBase64 }
 }
 
@@ -163,7 +154,6 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
     const route = createMemo(() => {
       const value = currentRoute(location.pathname, location.search)
       if (value.type === "home") return value
-      if (value.server) return value
       return { ...value, server: server.key }
     })
 
@@ -582,7 +572,7 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
       handoff: {
         tabs: createMemo(() => store.handoff?.tabs),
         setTabs(dir: string, id: string) {
-          setStore("handoff", "tabs", { scope: serverSdk().scope, dir, id, at: Date.now() })
+          setStore("handoff", "tabs", { scope: server.scope(), dir, id, at: Date.now() })
         },
         clearTabs() {
           if (!store.handoff?.tabs) return

packages/app/src/context/notification.tsx

@@ -1,5 +1,5 @@
 import { createStore, reconcile } from "solid-js/store"
-import { type Accessor, batch, createEffect, createMemo, onCleanup } from "solid-js"
+import { batch, createEffect, createMemo, onCleanup } from "solid-js"
 import { useParams } from "@solidjs/router"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { useServerSDK } from "./server-sdk"
@@ -108,7 +108,7 @@ function buildNotificationIndex(list: Notification[]) {
 export const { use: useNotification, provider: NotificationProvider } = createSimpleContext({
   name: "Notification",
   gate: false,
-  init: (props: { directory?: Accessor<string | undefined>; sessionID?: Accessor<string | undefined> }) => {
+  init: () => {
     const params = useParams()
     const serverSDK = useServerSDK()
     const serverSync = useServerSync()
@@ -119,10 +119,10 @@ export const { use: useNotification, provider: NotificationProvider } = createSi
     const empty: Notification[] = []
 
     const currentDirectory = createMemo(() => {
-      return props.directory?.() ?? decode64(params.dir)
+      return decode64(params.dir)
     })
 
-    const currentSession = createMemo(() => props.sessionID?.() ?? params.id)
+    const currentSession = createMemo(() => params.id)
 
     const [store, setStore, _, ready] = persisted(
       Persist.serverGlobal(serverSDK().scope, "notification", ["notification.v1"]),

packages/app/src/context/permission.tsx

@@ -1,4 +1,4 @@
-import { type Accessor, createEffect, createMemo, onCleanup } from "solid-js"
+import { createEffect, createMemo, onCleanup } from "solid-js"
 import { createStore, produce } from "solid-js/store"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import type { PermissionRequest } from "@opencode-ai/sdk/v2/client"
@@ -47,13 +47,13 @@ function hasPermissionPromptRules(permission: unknown) {
 export const { use: usePermission, provider: PermissionProvider } = createSimpleContext({
   name: "Permission",
   gate: false,
-  init: (props: { directory?: Accessor<string | undefined> }) => {
+  init: () => {
     const params = useParams()
     const serverSDK = useServerSDK()
     const serverSync = useServerSync()
 
     const permissionsEnabled = createMemo(() => {
-      const directory = props.directory?.() ?? decode64(params.dir)
+      const directory = decode64(params.dir)
       if (!directory) return false
       const [store] = serverSync().child(directory)
       return hasPermissionPromptRules(store.config.permission)
@@ -85,7 +85,7 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
     // When config has permission: "allow", auto-enable directory-level auto-accept
     createEffect(() => {
       if (!ready()) return
-      const directory = props.directory?.() ?? decode64(params.dir)
+      const directory = decode64(params.dir)
       if (!directory) return
       const [childStore] = serverSync().child(directory)
       const perm = childStore.config.permission

packages/app/src/context/prompt.tsx

@@ -1,5 +1,5 @@
 import { createSimpleContext } from "@opencode-ai/ui/context"
-import { base64Encode, checksum } from "@opencode-ai/core/util/encode"
+import { checksum } from "@opencode-ai/core/util/encode"
 import { useParams, useSearchParams } from "@solidjs/router"
 import { batch, createMemo, createRoot, getOwner, onCleanup } from "solid-js"
 import { createStore, type SetStoreFunction } from "solid-js/store"
@@ -7,7 +7,6 @@ import type { FileSelection } from "@/context/file"
 import { Persist, persisted } from "@/utils/persist"
 import { useServerSDK } from "./server-sdk"
 import type { ServerScope } from "@/utils/server-scope"
-import { useSDK } from "./sdk"
 
 interface PartBase {
   content: string
@@ -257,7 +256,6 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
   gate: false,
   init: () => {
     const params = useParams()
-    const sdk = useSDK()
     const [search] = useSearchParams<{ draftId?: string }>()
     const serverSDK = useServerSDK()
     const cache = new Map<string, PromptCacheEntry>()
@@ -305,7 +303,7 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
     }
 
     const session = createMemo(() =>
-      load(search.draftId ? { draftID: search.draftId } : { dir: base64Encode(sdk().directory), id: params.id }),
+      load(search.draftId ? { draftID: search.draftId } : { dir: params.dir!, id: params.id }),
     )
     const pick = (scope?: Scope) => (scope ? load(scope) : session())
 

packages/app/src/context/settings.tsx

@@ -33,7 +33,6 @@ export interface Settings {
     editToolPartsExpanded: boolean
     showSessionProgressBar: boolean
     showCustomAgents: boolean
-    mobileTitlebarPosition: "top" | "bottom"
     newLayoutDesigns?: boolean
   }
   appearance: {
@@ -119,7 +118,6 @@ const defaultSettings: Settings = {
     editToolPartsExpanded: false,
     showSessionProgressBar: true,
     showCustomAgents: false,
-    mobileTitlebarPosition: "top",
   },
   appearance: {
     fontSize: 14,
@@ -250,13 +248,6 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
         setShowCustomAgents(value: boolean) {
           setStore("general", "showCustomAgents", value)
         },
-        mobileTitlebarPosition: withFallback(
-          () => store.general?.mobileTitlebarPosition,
-          defaultSettings.general.mobileTitlebarPosition,
-        ),
-        setMobileTitlebarPosition(value: "top" | "bottom") {
-          setStore("general", "mobileTitlebarPosition", value)
-        },
         newLayoutDesigns,
         setNewLayoutDesigns(value: boolean) {
           setStore("general", "newLayoutDesigns", value)

packages/app/src/context/tabs.tsx

@@ -1,5 +1,6 @@
 import type { Session } from "@opencode-ai/sdk/v2/client"
 import { createSimpleContext } from "@opencode-ai/ui/context"
+import { base64Encode } from "@opencode-ai/core/util/encode"
 import { createStore, produce } from "solid-js/store"
 import { Persist, persisted, removePersisted, draftPersistedKeys } from "@/utils/persist"
 import { ServerConnection, useServer } from "./server"
@@ -8,11 +9,11 @@ import { useLocation, useNavigate, useParams } from "@solidjs/router"
 import { usePlatform } from "./platform"
 import { uuid } from "@/utils/uuid"
 import { SessionTabsRemovedDetail } from "@/components/titlebar-session-events"
-import { sessionHref } from "@/utils/session-route"
 
 export type SessionTab = {
   type: "session"
   server: ServerConnection.Key
+  dirBase64: string
   sessionId: string
 }
 
@@ -33,12 +34,16 @@ type RecentTab = {
 export const draftHref = (draftID: string) => `/new-session?draftId=${encodeURIComponent(draftID)}`
 
 export const tabHref = (tab: Tab) =>
-  tab.type === "draft" ? draftHref(tab.draftID) : sessionHref(tab.server, tab.sessionId)
+  tab.type === "draft" ? draftHref(tab.draftID) : `/${tab.dirBase64}/session/${tab.sessionId}`
 
 export const tabKey = (tab: Tab) => (tab.type === "draft" ? `draft:${tab.draftID}` : `${tab.server}\n${tabHref(tab)}`)
 
 export function sessionHasOpenTab(tabs: Tab[], server: ServerConnection.Key, session: Session) {
-  return tabs.some((tab) => tab.type === "session" && tab.server === server && tab.sessionId === session.id)
+  const dirBase64 = base64Encode(session.directory)
+  return tabs.some(
+    (tab) =>
+      tab.type === "session" && tab.server === server && tab.dirBase64 === dirBase64 && tab.sessionId === session.id,
+  )
 }
 
 export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
@@ -100,7 +105,14 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
     const navigateTab = (tab: Tab) => {
       const href = tabHref(tab)
       setRecentKey(tabKey(tab))
-      navigate(href)
+      if (tab.server === server.key) {
+        navigate(href)
+        return
+      }
+      void startTransition(() => {
+        server.setActive(tab.server)
+        navigate(href)
+      })
     }
 
     const actions = {
@@ -183,7 +195,11 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
       removeSessions: (input: SessionTabsRemovedDetail) => {
         const removed = store
           .filter(
-            (tab) => tab.type === "session" && tab.server === server.key && input.sessionIDs.includes(tab.sessionId),
+            (tab) =>
+              tab.type === "session" &&
+              tab.server === server.key &&
+              atob(tab.dirBase64) === input.directory &&
+              input.sessionIDs.includes(tab.sessionId),
           )
           .map(tabKey)
         void startTransition(() => {
@@ -195,6 +211,7 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
                   ? tabHref({
                       type: "session",
                       server: server.key,
+                      dirBase64: params.dir,
                       sessionId: params.id,
                     })
                   : undefined
@@ -207,12 +224,14 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
               const removedCurrent =
                 currentTab?.type === "session" &&
                 currentTab.server === server.key &&
+                atob(currentTab.dirBase64) === input.directory &&
                 sessionIDs.has(currentTab.sessionId)
 
               for (let i = tabs.length - 1; i >= 0; i--) {
                 const tab = tabs[i]
                 if (!tab || tab.type !== "session") continue
                 if (tab.server !== server.key) continue
+                if (atob(tab.dirBase64) !== input.directory) continue
                 if (!sessionIDs.has(tab.sessionId)) continue
                 tabs.splice(i, 1)
               }

packages/app/src/context/terminal.tsx

@@ -4,8 +4,7 @@ import { batch, createEffect, createMemo, createRoot, on, onCleanup } from "soli
 import { useParams } from "@solidjs/router"
 import { useSDK, type DirectorySDK } from "./sdk"
 import type { Platform } from "./platform"
-import { useServerSDK } from "./server-sdk"
-import { base64Encode } from "@opencode-ai/core/util/encode"
+import { useServer } from "./server"
 import { defaultTitle, titleNumber } from "./terminal-title"
 import { Persist, persisted, removePersisted } from "@/utils/persist"
 import { ScopedKey, ServerScope, type ServerScope as ServerScopeValue } from "@/utils/server-scope"
@@ -375,11 +374,10 @@ export const { use: useTerminal, provider: TerminalProvider } = createSimpleCont
   gate: false,
   init: () => {
     const sdk = useSDK()
-    const serverSDK = useServerSDK()
+    const server = useServer()
     const params = useParams()
     const cache = new Map<string, TerminalCacheEntry>()
-    const scope = () => serverSDK().scope
-    const directory = createMemo(() => base64Encode(sdk().directory))
+    const scope = server.scope()
 
     caches.add(cache)
     onCleanup(() => caches.delete(cache))
@@ -423,11 +421,11 @@ export const { use: useTerminal, provider: TerminalProvider } = createSimpleCont
       return entry.value
     }
 
-    const workspace = createMemo(() => loadWorkspace(directory(), params.id, scope()))
+    const workspace = createMemo(() => loadWorkspace(params.dir!, params.id, scope))
 
     createEffect(
       on(
-        () => ({ dir: directory(), id: params.id, scope: scope() }),
+        () => ({ dir: params.dir, id: params.id, scope }),
         (next, prev) => {
           if (!prev?.dir) return
           if (next.dir === prev.dir && next.id === prev.id && next.scope === prev.scope) return

packages/app/src/i18n/en.ts

@@ -589,8 +589,6 @@ export const dict = {
   "home.title": "Home",
   "home.projects": "Projects",
   "home.project.add": "Add project",
-  "home.server.collapse": "Collapse server projects",
-  "home.server.expand": "Expand server projects",
   "home.sessions.search.placeholder": "Search sessions",
   "home.sessions.search.sessions": "Sessions",
   "home.sessions.search.noResults": "No sessions found for {{query}}",
@@ -841,9 +839,6 @@ export const dict = {
   "settings.general.row.showTerminal.description": "Show the terminal button in the desktop title bar",
   "settings.general.row.showStatus.title": "Server status",
   "settings.general.row.showStatus.description": "Show the server status button in the title bar",
-  "settings.general.row.mobileTitlebarBottom.title": "Bottom navigation",
-  "settings.general.row.mobileTitlebarBottom.description":
-    "Place the title bar and session tabs at the bottom of the screen on mobile",
   "settings.general.row.showCustomAgents.title": "Custom agents",
   "settings.general.row.showCustomAgents.description": "Show the agent picker in the composer",
   "settings.general.row.reasoningSummaries.title": "Show reasoning summaries",

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

@@ -2,40 +2,26 @@ import { DataProvider } from "@opencode-ai/ui/context"
 import { showToast } from "@/utils/toast"
 import { base64Encode } from "@opencode-ai/core/util/encode"
 import { useLocation, useNavigate, useParams } from "@solidjs/router"
-import { type Accessor, createEffect, createMemo, createResource, type ParentProps, Show } from "solid-js"
+import { createEffect, createMemo, createResource, type ParentProps, Show } from "solid-js"
 import { useLanguage } from "@/context/language"
 import { LocalProvider } from "@/context/local"
 import { SDKProvider } from "@/context/sdk"
 import { useSync } from "@/context/sync"
 import { decode64 } from "@/utils/base64"
 import { Schema } from "effect"
-import type { ServerConnection } from "@/context/server"
-import { sessionHref } from "@/utils/session-route"
 
-export function DirectoryDataProvider(
-  props: ParentProps<{
-    directory: string | Accessor<string>
-    draftID?: string
-    server?: Accessor<ServerConnection.Key | undefined>
-  }>,
-) {
+export function DirectoryDataProvider(props: ParentProps<{ directory: string; draftID?: string }>) {
   const location = useLocation()
   const navigate = useNavigate()
   const params = useParams()
   const sync = useSync()
-  const directory = () => (typeof props.directory === "function" ? props.directory() : props.directory)
-  const slug = createMemo(() => base64Encode(directory()))
-  const href = (sessionID: string) => {
-    const server = props.server?.()
-    if (server) return sessionHref(server, sessionID)
-    return `/${slug()}/session/${sessionID}`
-  }
+  const slug = createMemo(() => base64Encode(props.directory))
 
   createEffect(() => {
     // A draft lives at /new-session?draftId=… and has no directory segment to normalize.
-    if (props.draftID || props.server?.()) return
+    if (props.draftID) return
     const next = sync().data.path.directory
-    if (!next || next === directory()) return
+    if (!next || next === props.directory) return
     const path = location.pathname.slice(slug().length + 1)
     navigate(`/${base64Encode(next)}${path}${location.search}${location.hash}`, { replace: true })
   })
@@ -51,9 +37,9 @@ export function DirectoryDataProvider(
   return (
     <DataProvider
       data={sync().data}
-      directory={directory()}
-      onNavigateToSession={(sessionID: string) => navigate(href(sessionID))}
-      onSessionHref={href}
+      directory={props.directory}
+      onNavigateToSession={(sessionID: string) => navigate(`/${slug()}/session/${sessionID}`)}
+      onSessionHref={(sessionID: string) => `/${slug()}/session/${sessionID}`}
     >
       <LocalProvider>{props.children}</LocalProvider>
     </DataProvider>

packages/app/src/pages/home.tsx

@@ -43,10 +43,10 @@ import { sessionTitle } from "@/utils/session-title"
 import { pathKey } from "@/utils/path-key"
 import { useGlobal } from "@/context/global"
 import { useCommand } from "@/context/command"
+import { useSettings } from "@/context/settings"
 import { ServerRowMenu } from "@/components/server/server-row-menu"
 import { ServerHealthIndicator } from "@/components/server/server-row"
 import { type ServerHealth } from "@/utils/server-health"
-import { Persist, persisted } from "@/utils/persist"
 
 const HOME_SESSION_LIMIT = 64
 const HOME_ROW_LAYOUT =
@@ -113,7 +113,16 @@ function homeSessionSearchKey(record: HomeSessionRecord) {
   return `${pathKey(record.session.directory)}:${record.session.id}`
 }
 
-export function NewHome() {
+export default function Home() {
+  const settings = useSettings()
+  return (
+    <Show when={settings.general.newLayoutDesigns()} fallback={<LegacyHome />}>
+      <HomeDesign />
+    </Show>
+  )
+}
+
+function HomeDesign() {
   const sync = useServerSync()
   const layout = useLayout()
   const platform = usePlatform()
@@ -304,7 +313,7 @@ export function NewHome() {
     const ctx = global.createServerCtx(conn)
     ctx.projects.open(directory)
     ctx.projects.touch(directory)
-    navigateOnServer(conn, `/server/${base64Encode(ServerConnection.key(conn))}/session/${session.id}`)
+    navigateOnServer(conn, `/${base64Encode(session.directory)}/session/${session.id}`)
   }
 
   function chooseProject(conn: ServerConnection.Any) {
@@ -330,7 +339,7 @@ export function NewHome() {
 
   return (
     <div class="rounded-[10px] shadow-[var(--v2-elevation-raised)] m-2 min-h-0 lg:overflow-hidden bg-v2-background-bg-base self-stretch flex-1">
-      <div class="mx-auto grid h-full w-full max-w-[1080px] grid-rows-[auto_minmax(0,1fr)_auto] gap-4 px-3 pb-3 lg:grid-cols-[280px_minmax(0,720px)] lg:grid-rows-1 lg:gap-8 lg:px-6 lg:pb-16">
+      <div class="mx-auto grid w-full h-full max-w-[1080px] gap-8 px-6 pb-16 lg:grid-cols-[280px_minmax(0,720px)]">
         <HomeProjectColumn
           projects={projects()}
           selected={state.selection}
@@ -356,7 +365,7 @@ export function NewHome() {
         />
 
         <section
-          class="min-h-0 min-w-0 flex-1 flex flex-col pt-6 lg:pt-12"
+          class="min-h-0 min-w-0 flex-1 flex flex-col pt-12"
           aria-label={language.t("sidebar.project.recentSessions")}
         >
           <HomeSessionSearch
@@ -407,7 +416,7 @@ export function NewHome() {
                                 record={record}
                                 server={state.selection.server}
                                 activeServer={state.selection.server === server.key}
-                                onClick={() => openSession(record.session)}
+                                openSession={openSession}
                               />
                             )}
                           </For>
@@ -420,12 +429,6 @@ export function NewHome() {
             </div>
           </ScrollView>
         </section>
-        <HomeUtilityNav
-          class="flex lg:hidden"
-          openSettings={openSettings}
-          openHelp={() => platform.openLink("https://opencode.ai/desktop-feedback")}
-          language={language}
-        />
       </div>
     </div>
   )
@@ -449,15 +452,8 @@ function HomeProjectColumn(props: {
   const global = useGlobal()
   const dialog = useDialog()
   const controller = useServerManagementController({ navigateOnAdd: false })
-  const [state, setState] = persisted(
-    Persist.global("home.servers", ["home.servers.v1"]),
-    createStore({ collapsed: {} as Record<string, boolean> }),
-  )
   return (
-    <aside
-      class="mt-6 flex min-w-0 flex-col gap-4 lg:mt-14 lg:pt-[52px]"
-      aria-label={props.language.t("home.projects")}
-    >
+    <aside class="flex min-w-0 flex-col lg:pt-[52px] mt-14 gap-4" aria-label={props.language.t("home.projects")}>
       <div class="flex h-7 min-w-0 items-center justify-between pl-1.5">
         <div class={HOME_SECTION_LABEL}>{props.language.t("home.projects")}</div>
         <Show when={global.servers.list().length === 1}>
@@ -481,23 +477,20 @@ function HomeProjectColumn(props: {
             const key = ServerConnection.key(item)
             const healthy = () => !!global.servers.health[key]?.healthy
             const serverCtx = global.createServerCtx(item)
-            const collapsed = () => !!state.collapsed[key]
             return (
               <div class="flex max-h-[min(572px,calc(100vh_-_300px))] min-w-0 flex-col gap-1 overflow-y-auto [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
                 <HomeServerRow
                   server={item}
                   selected={props.selected.server === key && !props.selected.directory}
                   healthy={healthy()}
-                  collapsed={collapsed()}
                   health={global.servers.health[key]}
                   controller={controller}
                   focusServer={props.focusServer}
                   chooseProject={props.chooseProject}
                   openEdit={(server) => dialog.show(() => <DialogServerV2 mode="edit" server={server} />)}
-                  toggleCollapsed={() => setState("collapsed", key, !state.collapsed[key])}
                   language={props.language}
                 />
-                <Show when={healthy() && !collapsed()}>
+                <Show when={healthy()}>
                   <div class="mx-3 h-px bg-v2-border-border-base" />
                   <HomeProjectList {...props} server={item} projects={serverCtx.projects.list()} />
                 </Show>
@@ -506,55 +499,37 @@ function HomeProjectColumn(props: {
           }}
         </For>
       </Show>
-      <HomeUtilityNav
-        class="mt-4 hidden lg:flex"
-        openSettings={props.openSettings}
-        openHelp={props.openHelp}
-        language={props.language}
-      />
+      <div class="mt-4 flex min-w-0 flex-col gap-1">
+        <button
+          type="button"
+          class={`${HOME_PROJECT_NAV_ROW} text-v2-text-text-faint [&>[data-slot=icon-svg]]:text-v2-icon-icon-muted`}
+          onClick={props.openSettings}
+        >
+          <IconV2 name="settings-gear" size="small" />
+          <span class={HOME_PROJECT_NAV_LABEL}>{props.language.t("sidebar.settings")}</span>
+        </button>
+        <button
+          type="button"
+          class={`${HOME_PROJECT_NAV_ROW} text-v2-text-text-faint [&>[data-slot=icon-svg]]:text-v2-icon-icon-muted`}
+          onClick={props.openHelp}
+        >
+          <IconV2 name="help" size="small" />
+          <span class={HOME_PROJECT_NAV_LABEL}>{props.language.t("sidebar.help")}</span>
+        </button>
+      </div>
     </aside>
   )
 }
 
-function HomeUtilityNav(props: {
-  class?: string
-  openSettings: () => void
-  openHelp: () => void
-  language: ReturnType<typeof useLanguage>
-}) {
-  return (
-    <div class={`${props.class ?? ""} min-w-0 flex-col gap-1`}>
-      <button
-        type="button"
-        class={`${HOME_PROJECT_NAV_ROW} text-v2-text-text-faint [&>[data-slot=icon-svg]]:text-v2-icon-icon-muted`}
-        onClick={props.openSettings}
-      >
-        <IconV2 name="settings-gear" size="small" />
-        <span class={HOME_PROJECT_NAV_LABEL}>{props.language.t("sidebar.settings")}</span>
-      </button>
-      <button
-        type="button"
-        class={`${HOME_PROJECT_NAV_ROW} text-v2-text-text-faint [&>[data-slot=icon-svg]]:text-v2-icon-icon-muted`}
-        onClick={props.openHelp}
-      >
-        <IconV2 name="help" size="small" />
-        <span class={HOME_PROJECT_NAV_LABEL}>{props.language.t("sidebar.help")}</span>
-      </button>
-    </div>
-  )
-}
-
 function HomeServerRow(props: {
   server: ServerConnection.Any
   selected: boolean
   healthy: boolean
-  collapsed: boolean
   health: ServerHealth | undefined
   controller: ReturnType<typeof useServerManagementController>
   focusServer: (server: ServerConnection.Any) => void
   chooseProject: (server: ServerConnection.Any) => void
   openEdit: (server: ServerConnection.Http) => void
-  toggleCollapsed: () => void
   language: ReturnType<typeof useLanguage>
 }) {
   const [state, setState] = createStore({ menuOpen: false })
@@ -567,30 +542,7 @@ function HomeServerRow(props: {
         disabled={!props.healthy}
         onClick={() => props.focusServer(props.server)}
       >
-        <Show when={props.healthy}>
-          <span
-            data-action="home-server-collapse"
-            class="inline-flex -ml-0.5 -mr-1.5 size-5 shrink-0 items-center justify-center rounded-[4px] text-v2-icon-icon-muted hover:bg-v2-overlay-simple-overlay-hover"
-            aria-label={
-              props.collapsed ? props.language.t("home.server.expand") : props.language.t("home.server.collapse")
-            }
-            aria-expanded={!props.collapsed}
-            onClick={(event) => {
-              event.preventDefault()
-              event.stopPropagation()
-              props.toggleCollapsed()
-            }}
-            onPointerDown={(event) => event.preventDefault()}
-          >
-            <IconV2
-              name="chevron-down"
-              size="small"
-              class="transition-transform duration-150 ease-in-out"
-              style={{ transform: `rotate(${props.collapsed ? -90 : 0}deg)` }}
-            />
-          </span>
-        </Show>
-        <div class="flex size-4 shrink-0 items-center justify-center -mr-0.5">
+        <div class="flex size-4 shrink-0 items-center justify-center">
           <ServerHealthIndicator health={props.health} />
         </div>
         <span class="flex min-w-0 items-center gap-1">
@@ -1072,7 +1024,7 @@ function HomeSessionRow(props: {
   record: HomeSessionRecord
   server: ServerConnection.Key
   activeServer: boolean
-  onClick: () => void
+  openSession: (session: Session) => void
 }) {
   const title = createMemo(() => sessionTitle(props.record.session.title) || props.record.session.id)
 
@@ -1081,7 +1033,7 @@ function HomeSessionRow(props: {
       type="button"
       data-component="home-session-row"
       class={`${HOME_ROW} h-10 gap-2 px-6 py-3 pl-4`}
-      onClick={props.onClick}
+      onClick={() => props.openSession(props.record.session)}
     >
       <HomeSessionLeading
         project={props.record.project}
@@ -1141,7 +1093,7 @@ function groupSessions(records: HomeSessionRecord[], language: ReturnType<typeof
   ].filter((group) => group.sessions.length > 0)
 }
 
-export function LegacyHome() {
+function LegacyHome() {
   const sync = useServerSync()
   const platform = usePlatform()
   const pickDirectory = useDirectoryPicker()

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

@@ -1,38 +0,0 @@
-import { createEffect, type ParentProps } from "solid-js"
-import { useNavigate } from "@solidjs/router"
-import { DebugBar } from "@/components/debug-bar"
-import { HelpButton } from "@/components/help-button"
-import { Titlebar, type TitlebarUpdate } from "@/components/titlebar"
-import { usePlatform } from "@/context/platform"
-import { setNavigate } from "@/utils/notification-click"
-import { setV2Toast, ToastRegion } from "@/utils/toast"
-
-export default function NewLayout(props: ParentProps) {
-  const platform = usePlatform()
-  const navigate = useNavigate()
-  setNavigate(navigate)
-
-  createEffect(() => setV2Toast(true))
-
-  const update: TitlebarUpdate = {
-    version: () => {
-      const state = platform.updater?.state()
-      if (state?.status !== "ready") return
-      return state.version
-    },
-    installing: () => platform.updater?.state().status === "installing",
-    install: () => void platform.updater?.install(),
-  }
-
-  return (
-    <div class="relative bg-v2-background-bg-deep flex-1 min-h-0 min-w-0 flex flex-col select-none [&_input]:select-text [&_textarea]:select-text [&_[contenteditable]]:select-text">
-      <Titlebar update={update} />
-      <main class="flex-1 min-h-0 min-w-0 overflow-x-hidden flex flex-col items-start contain-strict">
-        {props.children}
-      </main>
-      {import.meta.env.DEV && <DebugBar />}
-      <HelpButton />
-      <ToastRegion v2 />
-    </div>
-  )
-}

packages/app/src/pages/layout.tsx

@@ -13,7 +13,7 @@ import {
   type Accessor,
 } from "solid-js"
 import { makeEventListener } from "@solid-primitives/event-listener"
-import { useNavigate, useParams } from "@solidjs/router"
+import { useLocation, useNavigate, useParams } from "@solidjs/router"
 import { useLayout, LocalProject } from "@/context/layout"
 import { useServerSync } from "@/context/server-sync"
 import { Persist, persisted } from "@/utils/persist"
@@ -92,7 +92,7 @@ import {
 import { ProjectDragOverlay, SortableProject, type ProjectSidebarContext } from "./layout/sidebar-project"
 import { SidebarContent } from "./layout/sidebar-shell"
 
-export default function LegacyLayout(props: ParentProps) {
+export default function Layout(props: ParentProps) {
   const serverSDK = useServerSDK()
   const [store, setStore, , ready] = persisted(
     Persist.serverGlobal(serverSDK().scope, "layout.page", ["layout.page.v1"]),
@@ -131,8 +131,10 @@ export default function LegacyLayout(props: ParentProps) {
   const command = useCommand()
   const theme = useTheme()
   const language = useLanguage()
-  createEffect(() => setV2Toast(false))
+  const newDesign = createMemo(() => settings.general.newLayoutDesigns())
+  createEffect(() => setV2Toast(newDesign()))
   const initialDirectory = decode64(params.dir)
+  const location = useLocation()
   const route = createMemo(() => {
     const slug = params.dir
     if (!slug) return { slug, dir: "" }
@@ -156,7 +158,7 @@ export default function LegacyLayout(props: ParentProps) {
   const currentDir = createMemo(() => route().dir)
 
   const [state, setState] = createStore({
-    autoselect: !initialDirectory,
+    autoselect: !initialDirectory && !newDesign(),
     busyWorkspaces: {} as Record<string, boolean>,
     hoverProject: undefined as string | undefined,
     scrollSessionKey: undefined as string | undefined,
@@ -994,7 +996,7 @@ export default function LegacyLayout(props: ParentProps) {
         id: "sidebar.toggle",
         title: language.t("command.sidebar.toggle"),
         category: language.t("command.category.view"),
-        keybind: "mod+b",
+        keybind: newDesign() ? undefined : "mod+b",
         onSelect: () => layout.sidebar.toggle(),
       },
       {
@@ -1132,19 +1134,20 @@ export default function LegacyLayout(props: ParentProps) {
       },
     ]
 
-    Array.from({ length: 9 }, (_, i) => {
-      const index = i
-      const number = index + 1
-      commands.push({
-        id: `project.${number}`,
-        category: language.t("command.category.project"),
-        title: `Open Project {number}`,
-        keybind: `mod+${number}`,
-        disabled: layout.projects.list().length <= index,
-        hidden: true,
-        onSelect: () => navigateToProjectIndex(index),
+    if (!newDesign())
+      Array.from({ length: 9 }, (_, i) => {
+        const index = i
+        const number = index + 1
+        commands.push({
+          id: `project.${number}`,
+          category: language.t("command.category.project"),
+          title: `Open Project {number}`,
+          keybind: `mod+${number}`,
+          disabled: layout.projects.list().length <= index,
+          hidden: true,
+          onSelect: () => navigateToProjectIndex(index),
+        })
       })
-    })
 
     for (const [id] of availableThemeEntries()) {
       commands.push({
@@ -1809,7 +1812,7 @@ export default function LegacyLayout(props: ParentProps) {
   createEffect(() => {
     document.documentElement.style.setProperty(
       "--dialog-left-margin",
-      `${layout.sidebar.opened() ? layout.sidebar.width() : 48}px`,
+      newDesign() ? "0px" : `${layout.sidebar.opened() ? layout.sidebar.width() : 48}px`,
     )
   })
 
@@ -2352,158 +2355,176 @@ export default function LegacyLayout(props: ParentProps) {
   )
 
   return (
-    <div class="relative bg-background-base flex-1 min-h-0 min-w-0 flex flex-col select-none [&_input]:select-text [&_textarea]:select-text [&_[contenteditable]]:select-text">
-      {autoselecting() ?? ""}
-      <Titlebar update={titlebarUpdate} />
-      <Show when={updateVersion() !== undefined}>
-        <UpdateAvailableToast version={updateVersion() ?? ""} install={installUpdate} language={language} />
-      </Show>
-      <div class="flex-1 min-h-0 min-w-0 flex">
-        <div class="flex-1 min-h-0 relative">
-          <div class="size-full relative overflow-x-hidden">
-            <nav
-              aria-label={language.t("sidebar.nav.projectsAndSessions")}
-              data-component="sidebar-nav-desktop"
-              classList={{
-                "hidden xl:block": true,
-                "absolute inset-y-0 left-0": true,
-                "z-10": true,
-              }}
-              style={{ width: `${side()}px` }}
-              ref={(el) => {
-                setState("nav", el)
-              }}
-              onMouseEnter={() => {
-                disarm()
-              }}
-              onMouseLeave={() => {
-                aim.reset()
-                if (!sidebarHovering()) return
-
-                arm()
-              }}
-            >
-              <div class="@container w-full h-full contain-strict">{sidebarContent()}</div>
-            </nav>
-
-            <Show when={layout.sidebar.opened()}>
-              <div
-                class="hidden xl:block absolute inset-y-0 z-30 w-0 overflow-visible"
-                style={{ left: `${side()}px` }}
-                onPointerDown={() => setState("sizing", true)}
-              >
-                <ResizeHandle
-                  direction="horizontal"
-                  size={layout.sidebar.width()}
-                  min={244}
-                  max={typeof window === "undefined" ? 1000 : window.innerWidth * 0.3 + 64}
-                  onResize={(w) => {
-                    setState("sizing", true)
-                    if (sizet !== undefined) clearTimeout(sizet)
-                    sizet = window.setTimeout(() => setState("sizing", false), 120)
-                    layout.sidebar.resize(w)
-                  }}
-                />
-              </div>
+    <Show
+      when={!newDesign()}
+      fallback={
+        <div class="relative bg-v2-background-bg-deep flex-1 min-h-0 min-w-0 flex flex-col select-none [&_input]:select-text [&_textarea]:select-text [&_[contenteditable]]:select-text">
+          {autoselecting() ?? ""}
+          <Titlebar update={titlebarUpdate} />
+          <main class="flex-1 min-h-0 min-w-0 overflow-x-hidden flex flex-col items-start contain-strict">
+            <Show when={!autoselecting.loading} fallback={<div class="size-full" />}>
+              {props.children}
             </Show>
-
-            <div
-              class="hidden xl:block pointer-events-none absolute top-0 right-0 z-0 border-t border-border-weaker-base"
-              style={{ left: "calc(4rem + 12px)" }}
-            />
-
-            <div class="xl:hidden">
-              <div
-                classList={{
-                  "fixed inset-x-0 top-10 bottom-0 z-40 transition-opacity duration-200": true,
-                  "opacity-100 pointer-events-auto": layout.mobileSidebar.opened(),
-                  "opacity-0 pointer-events-none": !layout.mobileSidebar.opened(),
-                }}
-                onClick={(e) => {
-                  if (e.target === e.currentTarget) layout.mobileSidebar.hide()
-                }}
-              />
+          </main>
+          {import.meta.env.DEV && import.meta.env.VITE_DISABLE_DEBUG_BAR !== "1" && <DebugBar />}
+          <HelpButton />
+          <ToastRegion v2={newDesign()} />
+        </div>
+      }
+    >
+      <div class="relative bg-background-base flex-1 min-h-0 min-w-0 flex flex-col select-none [&_input]:select-text [&_textarea]:select-text [&_[contenteditable]]:select-text">
+        {autoselecting() ?? ""}
+        <Titlebar update={titlebarUpdate} />
+        <Show when={updateVersion() !== undefined}>
+          <UpdateAvailableToast version={updateVersion() ?? ""} install={installUpdate} language={language} />
+        </Show>
+        <div class="flex-1 min-h-0 min-w-0 flex">
+          <div class="flex-1 min-h-0 relative">
+            <div class="size-full relative overflow-x-hidden">
               <nav
                 aria-label={language.t("sidebar.nav.projectsAndSessions")}
-                data-component="sidebar-nav-mobile"
+                data-component="sidebar-nav-desktop"
                 classList={{
-                  "@container fixed top-10 bottom-0 left-0 z-50 w-full max-w-[400px] overflow-hidden border-r border-border-weaker-base bg-background-base transition-transform duration-200 ease-out": true,
-                  "translate-x-0": layout.mobileSidebar.opened(),
-                  "-translate-x-full": !layout.mobileSidebar.opened(),
+                  "hidden xl:block": true,
+                  "absolute inset-y-0 left-0": true,
+                  "z-10": true,
+                }}
+                style={{ width: `${side()}px` }}
+                ref={(el) => {
+                  setState("nav", el)
+                }}
+                onMouseEnter={() => {
+                  disarm()
+                }}
+                onMouseLeave={() => {
+                  aim.reset()
+                  if (!sidebarHovering()) return
+
+                  arm()
                 }}
-                onClick={(e) => e.stopPropagation()}
               >
-                {sidebarContent(true)}
+                <div class="@container w-full h-full contain-strict">{sidebarContent()}</div>
               </nav>
-            </div>
 
-            <div
-              classList={{
-                "absolute inset-0": true,
-                "xl:inset-y-0 xl:right-0 xl:left-[var(--main-left)]": true,
-                "z-20": true,
-                "transition-[left] duration-200 ease-[cubic-bezier(0.22,1,0.36,1)] will-change-[left] motion-reduce:transition-none":
-                  !state.sizing,
-              }}
-              style={{
-                "--main-left": layout.sidebar.opened() ? `${side()}px` : "4rem",
-              }}
-            >
-              <main
+              <Show when={layout.sidebar.opened()}>
+                <div
+                  class="hidden xl:block absolute inset-y-0 z-30 w-0 overflow-visible"
+                  style={{ left: `${side()}px` }}
+                  onPointerDown={() => setState("sizing", true)}
+                >
+                  <ResizeHandle
+                    direction="horizontal"
+                    size={layout.sidebar.width()}
+                    min={244}
+                    max={typeof window === "undefined" ? 1000 : window.innerWidth * 0.3 + 64}
+                    onResize={(w) => {
+                      setState("sizing", true)
+                      if (sizet !== undefined) clearTimeout(sizet)
+                      sizet = window.setTimeout(() => setState("sizing", false), 120)
+                      layout.sidebar.resize(w)
+                    }}
+                  />
+                </div>
+              </Show>
+
+              <div
+                class="hidden xl:block pointer-events-none absolute top-0 right-0 z-0 border-t border-border-weaker-base"
+                style={{ left: "calc(4rem + 12px)" }}
+              />
+
+              <div class="xl:hidden">
+                <div
+                  classList={{
+                    "fixed inset-x-0 top-10 bottom-0 z-40 transition-opacity duration-200": true,
+                    "opacity-100 pointer-events-auto": layout.mobileSidebar.opened(),
+                    "opacity-0 pointer-events-none": !layout.mobileSidebar.opened(),
+                  }}
+                  onClick={(e) => {
+                    if (e.target === e.currentTarget) layout.mobileSidebar.hide()
+                  }}
+                />
+                <nav
+                  aria-label={language.t("sidebar.nav.projectsAndSessions")}
+                  data-component="sidebar-nav-mobile"
+                  classList={{
+                    "@container fixed top-10 bottom-0 left-0 z-50 w-full max-w-[400px] overflow-hidden border-r border-border-weaker-base bg-background-base transition-transform duration-200 ease-out": true,
+                    "translate-x-0": layout.mobileSidebar.opened(),
+                    "-translate-x-full": !layout.mobileSidebar.opened(),
+                  }}
+                  onClick={(e) => e.stopPropagation()}
+                >
+                  {sidebarContent(true)}
+                </nav>
+              </div>
+
+              <div
                 classList={{
-                  "size-full overflow-x-hidden flex flex-col items-start contain-strict border-t border-border-weak-base bg-background-base xl:border-l xl:rounded-tl-[12px]": true,
+                  "absolute inset-0": true,
+                  "xl:inset-y-0 xl:right-0 xl:left-[var(--main-left)]": true,
+                  "z-20": true,
+                  "transition-[left] duration-200 ease-[cubic-bezier(0.22,1,0.36,1)] will-change-[left] motion-reduce:transition-none":
+                    !state.sizing,
+                }}
+                style={{
+                  "--main-left": layout.sidebar.opened() ? `${side()}px` : "4rem",
                 }}
               >
-                <Show when={!autoselecting.loading} fallback={<div class="size-full" />}>
-                  {props.children}
+                <main
+                  classList={{
+                    "size-full overflow-x-hidden flex flex-col items-start contain-strict border-t border-border-weak-base bg-background-base xl:border-l xl:rounded-tl-[12px]": true,
+                  }}
+                >
+                  <Show when={!autoselecting.loading} fallback={<div class="size-full" />}>
+                    {props.children}
+                  </Show>
+                </main>
+              </div>
+
+              <div
+                classList={{
+                  "hidden xl:flex absolute inset-y-0 left-16 z-30": true,
+                  "opacity-100 translate-x-0 pointer-events-auto": state.peeked && !layout.sidebar.opened(),
+                  "opacity-0 -translate-x-2 pointer-events-none": !state.peeked || layout.sidebar.opened(),
+                  "transition-[opacity,transform] motion-reduce:transition-none": true,
+                  "duration-180 ease-out": state.peeked && !layout.sidebar.opened(),
+                  "duration-120 ease-in": !state.peeked || layout.sidebar.opened(),
+                }}
+                onMouseMove={disarm}
+                onMouseEnter={() => {
+                  disarm()
+                  aim.reset()
+                }}
+                onPointerDown={disarm}
+                onMouseLeave={() => {
+                  arm()
+                }}
+              >
+                <Show when={peekProject()}>
+                  <SidebarPanel project={peekProject} merged={false} />
                 </Show>
-              </main>
-            </div>
+              </div>
 
-            <div
-              classList={{
-                "hidden xl:flex absolute inset-y-0 left-16 z-30": true,
-                "opacity-100 translate-x-0 pointer-events-auto": state.peeked && !layout.sidebar.opened(),
-                "opacity-0 -translate-x-2 pointer-events-none": !state.peeked || layout.sidebar.opened(),
-                "transition-[opacity,transform] motion-reduce:transition-none": true,
-                "duration-180 ease-out": state.peeked && !layout.sidebar.opened(),
-                "duration-120 ease-in": !state.peeked || layout.sidebar.opened(),
-              }}
-              onMouseMove={disarm}
-              onMouseEnter={() => {
-                disarm()
-                aim.reset()
-              }}
-              onPointerDown={disarm}
-              onMouseLeave={() => {
-                arm()
-              }}
-            >
-              <Show when={peekProject()}>
-                <SidebarPanel project={peekProject} merged={false} />
-              </Show>
-            </div>
-
-            <div
-              classList={{
-                "hidden xl:block pointer-events-none absolute inset-y-0 right-0 z-25 overflow-hidden": true,
-                "opacity-100 translate-x-0": state.peeked && !layout.sidebar.opened(),
-                "opacity-0 -translate-x-2": !state.peeked || layout.sidebar.opened(),
-                "transition-[opacity,transform] motion-reduce:transition-none": true,
-                "duration-180 ease-out": state.peeked && !layout.sidebar.opened(),
-                "duration-120 ease-in": !state.peeked || layout.sidebar.opened(),
-              }}
-              style={{ left: `calc(4rem + ${panel()}px)` }}
-            >
-              <div class="h-full w-px" style={{ "box-shadow": "var(--shadow-sidebar-overlay)" }} />
+              <div
+                classList={{
+                  "hidden xl:block pointer-events-none absolute inset-y-0 right-0 z-25 overflow-hidden": true,
+                  "opacity-100 translate-x-0": state.peeked && !layout.sidebar.opened(),
+                  "opacity-0 -translate-x-2": !state.peeked || layout.sidebar.opened(),
+                  "transition-[opacity,transform] motion-reduce:transition-none": true,
+                  "duration-180 ease-out": state.peeked && !layout.sidebar.opened(),
+                  "duration-120 ease-in": !state.peeked || layout.sidebar.opened(),
+                }}
+                style={{ left: `calc(4rem + ${panel()}px)` }}
+              >
+                <div class="h-full w-px" style={{ "box-shadow": "var(--shadow-sidebar-overlay)" }} />
+              </div>
             </div>
           </div>
+          {import.meta.env.DEV && import.meta.env.VITE_DISABLE_DEBUG_BAR !== "1" && <DebugBar />}
         </div>
-        {import.meta.env.DEV && import.meta.env.VITE_DISABLE_DEBUG_BAR !== "1" && <DebugBar />}
+        <HelpButton />
+        <ToastRegion v2={newDesign()} />
       </div>
-      <HelpButton />
-      <ToastRegion v2={false} />
-    </div>
+    </Show>
   )
 }
 

packages/app/src/pages/session.tsx

@@ -28,7 +28,7 @@ import { createAutoScroll } from "@opencode-ai/ui/hooks"
 import { previewSelectedLines } from "@opencode-ai/ui/pierre/selection-bridge"
 import { Button } from "@opencode-ai/ui/button"
 import { showToast } from "@/utils/toast"
-import { base64Encode, checksum } from "@opencode-ai/core/util/encode"
+import { checksum } from "@opencode-ai/core/util/encode"
 import { useLocation, useSearchParams } from "@solidjs/router"
 import { NewSessionView, SessionHeader } from "@/components/session"
 import { useComments } from "@/context/comments"
@@ -56,6 +56,7 @@ import { MessageTimeline } from "@/pages/session/timeline/message-timeline"
 import { createTimelineModel } from "@/pages/session/timeline/model"
 import { type DiffStyle, SessionReviewTab, type SessionReviewTabProps } from "@/pages/session/review-tab"
 import { useSessionLayout } from "@/pages/session/session-layout"
+import { useServer } from "@/context/server"
 import { syncSessionModel } from "@/pages/session/session-model-helpers"
 import { SessionSidePanel } from "@/pages/session/session-side-panel"
 import { TerminalPanel } from "@/pages/session/terminal-panel"
@@ -91,6 +92,7 @@ export default function Page() {
   const prompt = usePrompt()
   const comments = useComments()
   const terminal = useTerminal()
+  const server = useServer()
   const [searchParams, setSearchParams] = useSearchParams<{ prompt?: string }>()
   const location = useLocation()
   const { params, sessionKey, workspaceKey, tabs, view } = useSessionLayout()
@@ -135,11 +137,11 @@ export default function Page() {
           layout.handoff.clearTabs()
           return
         }
-        if (pending.scope !== serverSDK().scope) return
+        if (pending.scope !== server.scope()) return
 
         if (pending.id !== id) return
         layout.handoff.clearTabs()
-        if (pending.dir !== base64Encode(sdk().directory)) return
+        if (pending.dir !== (params.dir ?? "")) return
 
         const from = workspaceTabs().tabs()
         if (from.all.length === 0 && !from.active) return
@@ -245,7 +247,7 @@ export default function Page() {
 
   createEffect(
     on(
-      () => ({ dir: sdk().directory, id: params.id }),
+      () => ({ dir: params.dir, id: params.id }),
       (next, prev) => {
         if (!prev) return
         if (next.dir === prev.dir && next.id === prev.id) return
@@ -573,7 +575,7 @@ export default function Page() {
 
   createEffect(
     on(
-      () => sdk().directory,
+      () => params.dir,
       (dir) => {
         if (!dir) return
         setStore("newSessionWorktree", "main")
@@ -1568,56 +1570,40 @@ export default function Page() {
     />
   )
 
-  const mobileTabs = (compact = false, bottom = false) => (
-    <Tabs value={store.mobileTab} class="h-auto">
-      <Tabs.List
-        classList={{
-          "!h-9": compact,
-          "[&::after]:!border-b-0 [&::after]:!border-t [&::after]:!border-border-weak-base": bottom,
-        }}
-      >
-        <Tabs.Trigger
-          value="session"
-          classList={{
-            "!w-1/2 !max-w-none": true,
-            "!border-b-0 !border-t !border-border-weak-base [&:has([data-selected])]:!border-t-transparent": bottom,
-          }}
-          classes={{ button: compact ? "w-full !py-2" : "w-full" }}
-          onClick={() => setStore("mobileTab", "session")}
-        >
-          {language.t("session.tab.session")}
-        </Tabs.Trigger>
-        <Tabs.Trigger
-          value="changes"
-          classList={{
-            "!w-1/2 !max-w-none !border-r-0": true,
-            "!border-b-0 !border-t !border-border-weak-base [&:has([data-selected])]:!border-t-transparent": bottom,
-          }}
-          classes={{ button: compact ? "w-full !py-2" : "w-full" }}
-          onClick={() => setStore("mobileTab", "changes")}
-        >
-          {hasReview()
-            ? language.t("session.review.filesChanged", { count: reviewCount() })
-            : language.t("session.review.change.other")}
-        </Tabs.Trigger>
-      </Tabs.List>
-    </Tabs>
-  )
-  const mobileTabsBottom = createMemo(
-    () => !isDesktop() && settings.general.newLayoutDesigns() && settings.general.mobileTitlebarPosition() === "bottom",
-  )
-
   return (
     <div class="relative size-full overflow-hidden flex flex-col">
       {sessionSync() ?? ""}
       <SessionHeader />
       <div
-        class="flex-1 min-h-0 flex flex-col md:flex-row"
+        class="flex-1 min-h-0 flex flex-col md:flex-row "
         classList={{
           "gap-2 p-2": settings.general.newLayoutDesigns(),
         }}
       >
-        <Show when={!isDesktop() && !!params.id && !settings.general.newLayoutDesigns()}>{mobileTabs()}</Show>
+        <Show when={!isDesktop() && !!params.id}>
+          <Tabs value={store.mobileTab} class="h-auto">
+            <Tabs.List>
+              <Tabs.Trigger
+                value="session"
+                class="!w-1/2 !max-w-none"
+                classes={{ button: "w-full" }}
+                onClick={() => setStore("mobileTab", "session")}
+              >
+                {language.t("session.tab.session")}
+              </Tabs.Trigger>
+              <Tabs.Trigger
+                value="changes"
+                class="!w-1/2 !max-w-none !border-r-0"
+                classes={{ button: "w-full" }}
+                onClick={() => setStore("mobileTab", "changes")}
+              >
+                {hasReview()
+                  ? language.t("session.review.filesChanged", { count: reviewCount() })
+                  : language.t("session.review.change.other")}
+              </Tabs.Trigger>
+            </Tabs.List>
+          </Tabs>
+        </Show>
 
         <div
           classList={{
@@ -1636,9 +1622,6 @@ export default function Page() {
               "shadow-[var(--v2-elevation-raised)]": settings.general.newLayoutDesigns() && !!params.id,
             }}
           >
-            <Show when={!isDesktop() && !!params.id && settings.general.newLayoutDesigns() && !mobileTabsBottom()}>
-              {mobileTabs(true)}
-            </Show>
             <div class="flex-1 min-h-0 overflow-hidden">
               <Switch>
                 <Match when={params.id && mobileChanges()}>
@@ -1646,8 +1629,8 @@ export default function Page() {
                     {reviewContent({
                       diffStyle: "unified",
                       classes: {
-                        root: "pb-8 [&_[data-slot=session-review-list]]:pb-0",
-                        header: "px-4 !h-16 !pb-4",
+                        root: "pb-8",
+                        header: "px-4",
                         container: "px-4",
                       },
                       loadingClass: "px-4 py-4 text-text-weak",
@@ -1703,8 +1686,7 @@ export default function Page() {
               </Switch>
             </div>
 
-            <Show when={(params.id || !newSessionDesign()) && !mobileChanges()}>{composerRegion("dock")}</Show>
-            <Show when={!!params.id && mobileTabsBottom()}>{mobileTabs(true, true)}</Show>
+            <Show when={params.id || !newSessionDesign()}>{composerRegion("dock")}</Show>
           </div>
 
           <Show when={desktopReviewOpen()}>

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

@@ -29,7 +29,6 @@ import { useServer } from "@/context/server"
 import { useTabs } from "@/context/tabs"
 import { useDirectoryPicker } from "@/components/directory-picker"
 import { base64Encode } from "@opencode-ai/core/util/encode"
-import { legacySessionHref, requireServerKey, sessionHref } from "@/utils/session-route"
 
 export function SessionComposerRegion(props: {
   state: SessionComposerState
@@ -201,11 +200,7 @@ export function SessionComposerRegion(props: {
   const openParent = () => {
     const id = parentID()
     if (!id) return
-    navigate(
-      route.params.serverKey
-        ? sessionHref(requireServerKey(route.params.serverKey), id)
-        : legacySessionHref(sdk().directory, id),
-    )
+    navigate(`/${route.params.dir}/session/${id}`)
   }
 
   createEffect(() => {

packages/app/src/pages/session/file-tabs.tsx

@@ -405,7 +405,7 @@ export function FileTabContent(props: { tab: string }) {
           cacheKey: cacheKey(),
         }}
         enableLineSelection
-        enableGutterUtility
+        enableHoverUtility
         selectedLines={activeSelection()}
         commentedLines={commentedLines()}
         onRendered={() => {
@@ -413,10 +413,11 @@ export function FileTabContent(props: { tab: string }) {
         }}
         annotations={commentsUi.annotations()}
         renderAnnotation={commentsUi.renderAnnotation}
-        renderGutterUtility={commentsUi.renderGutterUtility}
+        renderHoverUtility={commentsUi.renderHoverUtility}
         onLineSelected={(range: SelectedLineRange | null) => {
           commentsUi.onLineSelected(range)
         }}
+        onLineNumberSelectionEnd={commentsUi.onLineNumberSelectionEnd}
         onLineSelectionEnd={(range: SelectedLineRange | null) => {
           commentsUi.onLineSelectionEnd(range)
         }}

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

@@ -1,19 +1,15 @@
 import { useParams } from "@solidjs/router"
 import { createMemo } from "solid-js"
 import { useLayout } from "@/context/layout"
+import { useServer } from "@/context/server"
 import { SessionRouteKey, SessionStateKey } from "@/utils/server-scope"
-import { useSDK } from "@/context/sdk"
-import { useServerSDK } from "@/context/server-sdk"
-import { base64Encode } from "@opencode-ai/core/util/encode"
 
 export const useSessionKey = () => {
   const params = useParams()
-  const sdk = useSDK()
-  const serverSDK = useServerSDK()
-  const scope = createMemo(() => serverSDK().scope)
-  const directory = createMemo(() => base64Encode(sdk().directory))
-  const workspaceKey = createMemo(() => SessionStateKey.from(scope(), SessionRouteKey.fromRoute(directory())))
-  const sessionKey = createMemo(() => SessionStateKey.from(scope(), SessionRouteKey.fromRoute(directory(), params.id)))
+  const server = useServer()
+  const scope = createMemo(() => server.scope())
+  const workspaceKey = createMemo(() => SessionStateKey.from(scope(), SessionRouteKey.fromRoute(params.dir)))
+  const sessionKey = createMemo(() => SessionStateKey.from(scope(), SessionRouteKey.fromRoute(params.dir, params.id)))
   return { params, sessionKey, workspaceKey }
 }
 

packages/app/src/pages/session/terminal-panel.tsx

@@ -16,7 +16,6 @@ import { useLanguage } from "@/context/language"
 import { useLayout } from "@/context/layout"
 import { useSettings } from "@/context/settings"
 import { useTerminal } from "@/context/terminal"
-import { useSDK } from "@/context/sdk"
 import { terminalTabLabel } from "@/pages/session/terminal-label"
 import { createSizing, focusTerminalById } from "@/pages/session/helpers"
 import { getTerminalHandoff, setTerminalHandoff } from "@/pages/session/handoff"
@@ -26,11 +25,10 @@ export function TerminalPanel() {
   const delays = [120, 240]
   const layout = useLayout()
   const terminal = useTerminal()
-  const sdk = useSDK()
   const language = useLanguage()
   const command = useCommand()
   const settings = useSettings()
-  const { workspaceKey, view } = useSessionLayout()
+  const { params, workspaceKey, view } = useSessionLayout()
 
   const opened = createMemo(() => view().terminal.opened())
   const size = createSizing()
@@ -124,7 +122,7 @@ export function TerminalPanel() {
   })
 
   createEffect(() => {
-    const dir = sdk().directory
+    const dir = params.dir
     if (!dir) return
     if (!terminal.ready()) return
     language.locale()
@@ -142,7 +140,7 @@ export function TerminalPanel() {
   })
 
   const handoff = createMemo(() => {
-    const dir = sdk().directory
+    const dir = params.dir
     if (!dir) return []
     return getTerminalHandoff(workspaceKey()) ?? []
   })

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

@@ -62,8 +62,6 @@ import { useSessionKey } from "@/pages/session/session-layout"
 import { useServerSDK } from "@/context/server-sdk"
 import { usePlatform } from "@/context/platform"
 import { useSettings } from "@/context/settings"
-import { useTabs } from "@/context/tabs"
-import { legacySessionHref, requireServerKey, sessionHref } from "@/utils/session-route"
 import { useSDK } from "@/context/sdk"
 import { useSync } from "@/context/sync"
 import { notifySessionTabsRemoved } from "@/components/titlebar-session-events"
@@ -73,7 +71,6 @@ import { makeTimer } from "@solid-primitives/timer"
 import { scheduleConnectedMeasure } from "./measure"
 import { createTimelineProjection } from "./projection"
 import { MessageComment, SummaryDiff, TimelineRow, TimelineRowMap } from "./rows"
-import { filterVirtualIndexes } from "./virtual-items"
 
 const emptyMessages: MessageType[] = []
 const emptyParts: PartType[] = []
@@ -263,7 +260,6 @@ export function MessageTimeline(props: {
   const sdk = useSDK()
   const sync = useSync()
   const settings = useSettings()
-  const tabs = useTabs()
   const dialog = useDialog()
   const language = useLanguage()
   const { params, sessionKey } = useSessionKey()
@@ -453,10 +449,7 @@ export function MessageTimeline(props: {
       const id = activeMessageID()
       const active = id ? (messageLastRowIndex().get(id) ?? -1) : -1
       const indexes = defaultRangeExtractor({ ...range, overscan: renderOverscan() })
-      return filterVirtualIndexes(
-        [...new Set([...resizePinnedIndexes, ...indexes, ...(active < 0 ? [] : [active])])].sort((a, b) => a - b),
-        range.count,
-      )
+      return [...new Set([...resizePinnedIndexes, ...indexes, ...(active < 0 ? [] : [active])])].sort((a, b) => a - b)
     },
   })
   const resizeItem = virtualizer.resizeItem
@@ -764,18 +757,12 @@ export function MessageTimeline(props: {
 
   const navigateAfterSessionRemoval = (sessionID: string, parentID?: string, nextSessionID?: string) => {
     if (params.id !== sessionID) return
-    const href = (id: string) =>
-      params.serverKey ? sessionHref(requireServerKey(params.serverKey), id) : legacySessionHref(sdk().directory, id)
     if (parentID) {
-      navigate(href(parentID))
+      navigate(`/${params.dir}/session/${parentID}`)
       return
     }
     if (nextSessionID) {
-      navigate(href(nextSessionID))
-      return
-    }
-    if (params.serverKey) {
-      tabs.newDraft({ server: requireServerKey(params.serverKey), directory: sdk().directory })
+      navigate(`/${params.dir}/session/${nextSessionID}`)
       return
     }
     navigate(`/${params.dir}/session`)
@@ -877,9 +864,7 @@ export function MessageTimeline(props: {
   const navigateParent = () => {
     const id = parentID()
     if (!id) return
-    navigate(
-      params.serverKey ? sessionHref(requireServerKey(params.serverKey), id) : legacySessionHref(sdk().directory, id),
-    )
+    navigate(`/${params.dir}/session/${id}`)
   }
 
   function DialogDeleteSession(props: { sessionID: string }) {
@@ -1300,9 +1285,7 @@ export function MessageTimeline(props: {
               "sticky top-0 z-30 bg-[linear-gradient(to_bottom,var(--background-stronger)_48px,transparent)]": true,
               "w-full": true,
               "pb-4": true,
-              "pr-3": true,
-              "pl-4": settings.general.newLayoutDesigns(),
-              "pl-2 md:pl-4": !settings.general.newLayoutDesigns(),
+              "pl-2 pr-3 md:pl-4 md:pr-3": true,
               "md:max-w-200 md:mx-auto 2xl:max-w-[1000px]": props.centered,
             }}
           >

packages/app/src/pages/session/timeline/virtual-items.ts

@@ -1,3 +0,0 @@
-export function filterVirtualIndexes(indexes: number[], count: number) {
-  return indexes.filter((index) => index >= 0 && index < count)
-}

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

@@ -18,8 +18,6 @@ import { createSessionTabs } from "@/pages/session/helpers"
 import { extractPromptFromParts } from "@/utils/prompt"
 import { UserMessage } from "@opencode-ai/sdk/v2"
 import { useSessionLayout } from "@/pages/session/session-layout"
-import { useTabs } from "@/context/tabs"
-import { requireServerKey } from "@/utils/session-route"
 
 export type SessionCommandContext = {
   navigateMessageByOffset: (offset: number) => void
@@ -47,7 +45,6 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   const settings = useSettings()
   const sync = useSync()
   const terminal = useTerminal()
-  const sessionTabs = useTabs()
   const layout = useLayout()
   const navigate = useNavigate()
   const { params, tabs, view } = useSessionLayout()
@@ -384,13 +381,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
       title: language.t("command.session.new"),
       keybind: "mod+shift+s",
       slash: "new",
-      onSelect: () => {
-        if (params.serverKey) {
-          sessionTabs.newDraft({ server: requireServerKey(params.serverKey), directory: sdk().directory })
-          return
-        }
-        navigate(`/${params.dir}/session`)
-      },
+      onSelect: () => navigate(`/${params.dir}/session`),
     }),
     sessionCommand({
       id: "session.undo",

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

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { ServerConnection } from "@/context/server"
-import { legacySessionHref, requireServerKey, rootSession, sessionHref } from "./session-route"
-
-describe("session routes", () => {
-  test("builds and decodes a server-keyed session route", () => {
-    const server = ServerConnection.Key.make("https://example.com:4096")
-    const href = sessionHref(server, "session-1")
-
-    expect(href).toBe("/server/aHR0cHM6Ly9leGFtcGxlLmNvbTo0MDk2/session/session-1")
-    expect(requireServerKey(href.split("/")[2])).toBe(server)
-  })
-
-  test("rejects malformed server keys", () => {
-    expect(() => requireServerKey("not-base64")).toThrow("Invalid server route")
-  })
-
-  test("builds the legacy directory-keyed route", () => {
-    expect(legacySessionHref("/Users/example/project", "session-1")).toBe(
-      "/L1VzZXJzL2V4YW1wbGUvcHJvamVjdA/session/session-1",
-    )
-  })
-
-  test("resolves the root session", async () => {
-    const sessions: Record<string, { id: string; parentID?: string }> = {
-      child: { id: "child", parentID: "parent" },
-      parent: { id: "parent", parentID: "root" },
-      root: { id: "root" },
-    }
-
-    expect(
-      await rootSession(sessions.child, async (id) => {
-        const session = sessions[id]
-        if (!session) throw new Error(`Missing session: ${id}`)
-        return session
-      }),
-    ).toBe(sessions.root)
-  })
-})

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

@@ -1,25 +0,0 @@
-import { base64Encode } from "@opencode-ai/core/util/encode"
-import { ServerConnection } from "@/context/server"
-import { decode64 } from "@/utils/base64"
-
-export function sessionHref(server: ServerConnection.Key, sessionID: string) {
-  return `/server/${base64Encode(server)}/session/${sessionID}`
-}
-
-export function legacySessionHref(directory: string, sessionID: string) {
-  return `/${base64Encode(directory)}/session/${sessionID}`
-}
-
-export function requireServerKey(segment: string | undefined) {
-  const key = decode64(segment)
-  if (!key || base64Encode(key) !== segment) throw new Error("Invalid server route")
-  return ServerConnection.Key.make(key)
-}
-
-type SessionParent = { id: string; parentID?: string }
-
-export async function rootSession(session: SessionParent, get: (sessionID: string) => Promise<SessionParent>) {
-  let current = session
-  while (current.parentID) current = await get(current.parentID)
-  return current
-}

packages/app/src/wsl/settings.tsx

@@ -24,11 +24,11 @@ export function isWslServer(server: ServerConnection.Any) {
   return server.type === "sidecar" && server.variant === "wsl"
 }
 
-export function AddServerMenu(props: { onAddServer: () => void }) {
+export function WslAddServerButton() {
   const platform = usePlatform()
   const dialog = useDialog()
   const language = useLanguage()
-  const openAddWsl = () => {
+  const openAdd = () => {
     dialog.push(() => (
       <Dialog title={language.t("wsl.server.add")} size="large" fit class="settings-v2-wsl-dialog">
         <DialogAddWslServer />
@@ -36,25 +36,10 @@ export function AddServerMenu(props: { onAddServer: () => void }) {
     ))
   }
   return (
-    <Show
-      when={platform.wslServers}
-      fallback={
-        <ButtonV2 variant="ghost-muted" icon="plus" onClick={props.onAddServer}>
-          {language.t("dialog.server.add.button")}
-        </ButtonV2>
-      }
-    >
-      <MenuV2 gutter={4} modal={false} placement="bottom-end">
-        <MenuV2.Trigger as={ButtonV2} variant="ghost-muted" icon="plus">
-          {language.t("dialog.server.add.button")}
-        </MenuV2.Trigger>
-        <MenuV2.Portal>
-          <MenuV2.Content>
-            <MenuV2.Item onSelect={props.onAddServer}>{language.t("dialog.server.add.button")}</MenuV2.Item>
-            <MenuV2.Item onSelect={openAddWsl}>{language.t("wsl.server.add")}</MenuV2.Item>
-          </MenuV2.Content>
-        </MenuV2.Portal>
-      </MenuV2>
+    <Show when={platform.wslServers}>
+      <ButtonV2 variant="ghost-muted" icon="plus" onClick={openAdd}>
+        {language.t("wsl.server.addShort")}
+      </ButtonV2>
     </Show>
   )
 }

packages/app/test-browser/solid-virtual.test.ts

@@ -1,7 +1,6 @@
 import { expect, test } from "bun:test"
-import { createVirtualizer, defaultRangeExtractor } from "@tanstack/solid-virtual"
+import { createVirtualizer } from "@tanstack/solid-virtual"
 import { createRoot, createSignal } from "solid-js"
-import { filterVirtualIndexes } from "@/pages/session/timeline/virtual-items"
 
 test("reactive count updates preserve measured row sizes", () => {
   createRoot((dispose) => {
@@ -45,26 +44,3 @@ test("logical scroll offset includes pending measurement adjustments", () => {
     dispose()
   })
 })
-
-test("stale pinned indexes do not produce missing virtual items after count shrinks", () => {
-  createRoot((dispose) => {
-    const [count, setCount] = createSignal(2)
-    const pinned = [1]
-    const virtualizer = createVirtualizer<HTMLDivElement, HTMLDivElement>({
-      get count() {
-        return count()
-      },
-      getScrollElement: () => null,
-      estimateSize: () => 60,
-      initialRect: { width: 800, height: 600 },
-      rangeExtractor: (range) =>
-        filterVirtualIndexes([...new Set([...defaultRangeExtractor(range), ...pinned])], range.count),
-    })
-
-    expect(virtualizer.getVirtualItems().map((item) => item.index)).toEqual([0, 1])
-    setCount(1)
-    expect(virtualizer.getVirtualItems().map((item) => item.index)).toEqual([0])
-    expect(() => new Map(virtualizer.getVirtualItems().map((item) => [item.key, item]))).not.toThrow()
-    dispose()
-  })
-})

packages/cli/src/commands/handlers/serve.ts

@@ -27,11 +27,9 @@ export default Runtime.handler(
 
 function listen(hostname: string, port: Option.Option<number>, password: string) {
   if (Option.isSome(port)) return bind(hostname, port.value, password)
-  const next = (port: number): ReturnType<typeof bind> =>
-    bind(hostname, port, password).pipe(
-      Effect.catch((error) => (port === 65_535 ? Effect.fail(error) : next(port + 1))),
-    )
-  return next(4096)
+  // Preserve the familiar default when available, but let the OS choose a free
+  // port when another local server already owns 4096.
+  return bind(hostname, 4096, password).pipe(Effect.catch(() => bind(hostname, 0, password)))
 }
 
 function bind(hostname: string, port: number, password: string) {

packages/console/app/src/routes/zen/util/handler.ts

@@ -105,7 +105,6 @@ export async function handler(
     const sessionId = input.request.headers.get("x-opencode-session") ?? ""
     const requestId = input.request.headers.get("x-opencode-request") ?? ""
     const ocClient = input.request.headers.get("x-opencode-client") ?? ""
-    const projectId = input.request.headers.get("x-opencode-project") ?? ""
     const userAgent = input.request.headers.get("user-agent") ?? ""
     logger.metric({
       is_stream: isStream,
@@ -194,13 +193,8 @@ export async function handler(
         headers: (() => {
           const headers = new Headers(input.request.headers)
           providerInfo.modifyHeaders(headers, providerInfo.apiKey, stickyId)
-          Object.entries(providerInfo.headerModifier ?? {}).forEach(([k, v]) => {
-            if (v === "$ip") return headers.set(k, ip)
-            if (v === "$session") return headers.set(k, sessionId)
-            if (v === "$model") return headers.set(k, model)
-            if (v === "$request") return headers.set(k, requestId)
-            if (v === "$project") return headers.set(k, projectId)
-            headers.set(k, v)
+          Object.entries(providerInfo.headerMappings ?? {}).forEach(([k, v]) => {
+            headers.set(k, headers.get(v)!)
           })
           headers.delete("host")
           headers.delete("content-length")

packages/console/core/src/model.ts

@@ -52,8 +52,9 @@ export namespace ZenData {
     api: z.string(),
     apiKey: z.union([z.string(), z.record(z.string(), z.string())]),
     format: FormatSchema.optional(),
-    headerModifier: z.record(z.string(), z.any()).optional(),
+    headerMappings: z.record(z.string(), z.string()).optional(),
     payloadModifier: z.record(z.string(), z.any()).optional(),
+    payloadMappings: z.record(z.string(), z.string()).optional(),
     adjustCacheUsage: z.boolean().optional(),
     budget: z.number().optional(),
   })

packages/core/bunfig.toml

@@ -1,2 +0,0 @@
-[test]
-preload = ["./test/preload.ts"]

packages/core/package.json

@@ -91,7 +91,6 @@
     "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
     "@opencode-ai/effect-sqlite-node": "workspace:*",
     "@opencode-ai/llm": "workspace:*",
-    "@opencode-ai/plugin": "workspace:*",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/context-async-hooks": "2.6.1",
     "@opentelemetry/exporter-trace-otlp-http": "0.214.0",

packages/core/schema.json

@@ -1,8 +1,8 @@
 {
   "version": "7",
   "dialect": "sqlite",
-  "id": "f14a9b18-8207-487e-a3d3-227e629ba9ad",
-  "prevIds": ["169a0f0f-d58f-479f-b024-fa1c7b9a09db"],
+  "id": "169a0f0f-d58f-479f-b024-fa1c7b9a09db",
+  "prevIds": ["abd2f920-b822-49af-b8a7-2e48367d424f"],
   "ddl": [
     {
       "name": "workspace",
@@ -900,6 +900,16 @@
       "entityType": "columns",
       "table": "session_context_epoch"
     },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'build'",
+      "generated": null,
+      "name": "agent",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
     {
       "type": "text",
       "notNull": true,
@@ -920,6 +930,26 @@
       "entityType": "columns",
       "table": "session_context_epoch"
     },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "replacement_seq",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "revision",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
     {
       "type": "text",
       "notNull": false,

packages/core/script/migration.ts

@@ -45,17 +45,15 @@ async function generate() {
       if (await Bun.file(target).exists()) throw new Error(`Database migration already exists: ${name}`)
       await Bun.write(
         target,
-        await formatTypescript(
-          renderMigration(name, await Bun.file(path.join(incremental, name, "migration.sql")).text()),
-        ),
+        renderMigration(name, await Bun.file(path.join(incremental, name, "migration.sql")).text()),
       )
       await fs.copyFile(path.join(incremental, name, "snapshot.json"), snapshot)
     }
 
     await fs.mkdir(full)
     await drizzle(temporary, full, "schema")
-    await Bun.write(schema, await formatTypescript(renderSchema(await generatedSql(full))))
-    await Bun.write(registry, await formatTypescript(renderRegistry(await typescriptMigrations())))
+    await Bun.write(schema, renderSchema(await generatedSql(full)))
+    await Bun.write(registry, renderRegistry(await typescriptMigrations()))
   } finally {
     await fs.rm(temporary, { recursive: true, force: true })
   }
@@ -78,12 +76,12 @@ async function check() {
 
     await fs.mkdir(full)
     await drizzle(temporary, full, "schema")
-    if ((await Bun.file(schema).text()) !== (await formatTypescript(renderSchema(await generatedSql(full))))) {
+    if ((await Bun.file(schema).text()) !== renderSchema(await generatedSql(full))) {
       throw new Error("Current database schema is stale. Run `bun script/migration.ts` from packages/core.")
     }
 
     const migrations = await typescriptMigrations()
-    if ((await Bun.file(registry).text()) !== (await formatTypescript(renderRegistry(migrations)))) {
+    if ((await Bun.file(registry).text()) !== renderRegistry(migrations)) {
       throw new Error("Database migration registry is stale. Run `bun script/migration.ts` from packages/core.")
     }
   } finally {
@@ -172,18 +170,6 @@ function escapeTemplate(line: string) {
   return line.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${")
 }
 
-async function formatTypescript(input: string) {
-  const prettier = await import("prettier")
-  const typescript = await import("prettier/plugins/typescript")
-  const estree = await import("prettier/plugins/estree")
-  return prettier.format(input, {
-    parser: "typescript",
-    plugins: [typescript.default, estree.default],
-    semi: false,
-    printWidth: 120,
-  })
-}
-
 function renderRegistry(names: string[]) {
   return `import type { DatabaseMigration } from "./migration"
 

packages/core/src/agent.ts

@@ -1,6 +1,7 @@
 export * as AgentV2 from "./agent"
 
-import { Array, Context, Effect, Layer, Schema, Scope, Types } from "effect"
+import { Array, Context, Effect, Layer, Schema, Scope } from "effect"
+import { castDraft, enableMapSet, type Draft } from "immer"
 import { ModelV2 } from "./model"
 import { PermissionSchema } from "./permission/schema"
 import { ProviderV2 } from "./provider"
@@ -48,19 +49,21 @@ export interface Selection {
 }
 
 type Data = {
-  agents: Map<ID, Types.DeepMutable<Info>>
+  agents: Map<ID, Info>
   default?: ID
 }
 
-export type Draft = {
+export type Editor = {
   list: () => readonly Info[]
   get: (id: ID) => Info | undefined
   default: (id: ID | undefined) => void
-  update: (id: ID, fn: (agent: Types.DeepMutable<Info>) => void) => void
+  update: (id: ID, fn: (agent: Draft<Info>) => void) => void
   remove: (id: ID) => void
 }
 
-export interface Interface extends State.Transformable<Draft> {
+export interface Interface {
+  readonly transform: State.Interface<Data, Editor>["transform"]
+  readonly update: State.Interface<Data, Editor>["update"]
   readonly get: (id: ID) => Effect.Effect<Info | undefined>
   readonly default: () => Effect.Effect<Info | undefined>
   readonly resolve: (id?: ID | string) => Effect.Effect<Info | undefined>
@@ -70,19 +73,21 @@ export interface Interface extends State.Transformable<Draft> {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Agent") {}
 
+enableMapSet()
+
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const state = State.create<Data, Draft>({
+    const state = State.create<Data, Editor>({
       initial: () => ({ agents: new Map() }),
-      draft: (draft) => ({
+      editor: (draft) => ({
         list: () => Array.fromIterable(draft.agents.values()) as Info[],
         get: (id) => draft.agents.get(id),
         default: (id) => {
           draft.default = id
         },
         update: (id, fn) => {
-          const current = draft.agents.get(id) ?? (Info.empty(id) as Types.DeepMutable<Info>)
+          const current = draft.agents.get(id) ?? castDraft(Info.empty(id))
           if (!draft.agents.has(id)) draft.agents.set(id, current)
           fn(current)
           current.id = id
@@ -108,7 +113,7 @@ export const layer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
-      reload: state.reload,
+      update: state.update,
       get: Effect.fn("AgentV2.get")(function* (id) {
         return state.get().agents.get(id)
       }),

packages/core/src/aisdk.ts

@@ -1,27 +1,14 @@
 export * as AISDK from "./aisdk"
 
 import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { Cause, Context, Effect, Layer, Schema, Scope } from "effect"
+import { Cause, Context, Effect, Layer, Schema } from "effect"
 import { ModelV2 } from "./model"
+import { EventV2 } from "./event"
+import { PluginV2 } from "./plugin"
 import { ProviderV2 } from "./provider"
-import { State } from "./state"
 
 type SDK = any
 
-export interface SDKEvent {
-  readonly model: ModelV2.Info
-  readonly package: string
-  readonly options: Record<string, any>
-  sdk?: SDK
-}
-
-export interface LanguageEvent {
-  readonly model: ModelV2.Info
-  readonly sdk: SDK
-  readonly options: Record<string, any>
-  language?: LanguageModelV3
-}
-
 function wrapSSE(res: Response, ms: number, ctl: AbortController) {
   if (typeof ms !== "number" || ms <= 0) return res
   if (!res.body) return res
@@ -130,70 +117,19 @@ function initError(providerID: ProviderV2.ID) {
 }
 
 export interface Interface {
-  readonly hook: {
-    readonly sdk: (
-      callback: (event: SDKEvent) => Effect.Effect<void> | void,
-    ) => Effect.Effect<State.Registration, never, Scope.Scope>
-    readonly language: (
-      callback: (event: LanguageEvent) => Effect.Effect<void> | void,
-    ) => Effect.Effect<State.Registration, never, Scope.Scope>
-  }
-  readonly runSDK: (event: SDKEvent) => Effect.Effect<SDKEvent>
-  readonly runLanguage: (event: LanguageEvent) => Effect.Effect<LanguageEvent>
   readonly language: (model: ModelV2.Info) => Effect.Effect<LanguageModelV3, InitError>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/AISDK") {}
 
-export const locationLayer = Layer.effect(
+export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    let sdkHooks: ((event: SDKEvent) => Effect.Effect<void> | void)[] = []
-    let languageHooks: ((event: LanguageEvent) => Effect.Effect<void> | void)[] = []
+    const plugin = yield* PluginV2.Service
     const languages = new Map<string, LanguageModelV3>()
     const sdks = new Map<string, SDK>()
 
-    const register = <Event>(
-      hooks: () => ((event: Event) => Effect.Effect<void> | void)[],
-      update: (hooks: ((event: Event) => Effect.Effect<void> | void)[]) => void,
-    ) =>
-      Effect.fn("AISDK.hook")(function* (callback: (event: Event) => Effect.Effect<void> | void) {
-        const scope = yield* Scope.Scope
-        let active = true
-        update([...hooks(), callback])
-        const dispose = Effect.sync(() => {
-          if (!active) return
-          active = false
-          update(hooks().filter((item) => item !== callback))
-        })
-        yield* Scope.addFinalizer(scope, dispose)
-        return { dispose }
-      })
-
-    const run = Effect.fnUntraced(function* <Event>(
-      hooks: readonly ((event: Event) => Effect.Effect<void> | void)[],
-      event: Event,
-    ) {
-      for (const hook of hooks) {
-        const result = hook(event)
-        if (Effect.isEffect(result)) yield* result
-      }
-      return event
-    })
-
-    const service = Service.of({
-      hook: {
-        sdk: register(
-          () => sdkHooks,
-          (next) => (sdkHooks = next),
-        ),
-        language: register(
-          () => languageHooks,
-          (next) => (languageHooks = next),
-        ),
-      },
-      runSDK: (event) => run(sdkHooks, event),
-      runLanguage: (event) => run(languageHooks, event),
+    return Service.of({
       language: Effect.fn("AISDK.language")(function* (model) {
         const key = `${model.providerID}/${model.id}/${model.request.variant ?? "default"}`
         const existing = languages.get(key)
@@ -212,14 +148,26 @@ export const locationLayer = Layer.effect(
         })
         const sdk =
           sdks.get(sdkKey) ??
-          (yield* service.runSDK({ model, package: model.api.package, options }).pipe(initError(model.providerID))).sdk
+          (yield* plugin
+            .trigger("aisdk.sdk", { model, package: model.api.package, options }, {})
+            .pipe(initError(model.providerID))).sdk
         if (!sdk)
           return yield* new InitError({
             providerID: model.providerID,
             cause: new Error("No AISDK provider plugin returned an SDK"),
           })
         sdks.set(sdkKey, sdk)
-        const result = yield* service.runLanguage({ model, sdk, options }).pipe(initError(model.providerID))
+        const result = yield* plugin
+          .trigger(
+            "aisdk.language",
+            {
+              model,
+              sdk,
+              options,
+            },
+            {},
+          )
+          .pipe(initError(model.providerID))
         const language = yield* Effect.sync(() => result.language ?? sdk.languageModel(model.api.id)).pipe(
           initError(model.providerID),
         )
@@ -227,8 +175,7 @@ export const locationLayer = Layer.effect(
         return language
       }),
     })
-    return service
   }),
 )
 
-export const defaultLayer = locationLayer
+export const defaultLayer = layer.pipe(Layer.provide(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer))))

packages/core/src/catalog.ts

@@ -1,21 +1,36 @@
 export * as Catalog from "./catalog"
 
-import { Array, Context, Effect, Layer, Option, Order, pipe, Schema } from "effect"
+import { Array, Context, Effect, Layer, Option, Order, pipe, Schema, Scope, Stream } from "effect"
+import { castDraft, enableMapSet, type Draft } from "immer"
 import { ModelV2 } from "./model"
 import { ModelRequest } from "./model-request"
+import { PluginV2 } from "./plugin"
 import { ProviderV2 } from "./provider"
+import { Location } from "./location"
 import { EventV2 } from "./event"
 import { Policy } from "./policy"
 import { State } from "./state"
 import { Integration } from "./integration"
 
 export type ProviderRecord = {
-  provider: ProviderV2.MutableInfo
-  models: Map<ModelV2.ID, ModelV2.MutableInfo>
+  provider: ProviderV2.Info
+  models: Map<ModelV2.ID, ModelV2.Info>
 }
 
 export type DefaultModel = { providerID: ProviderV2.ID; modelID: ModelV2.ID }
 
+export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFoundError>()(
+  "CatalogV2.ProviderNotFound",
+  {
+    providerID: ProviderV2.ID,
+  },
+) {}
+
+export class ModelNotFoundError extends Schema.TaggedErrorClass<ModelNotFoundError>()("CatalogV2.ModelNotFound", {
+  providerID: ProviderV2.ID,
+  modelID: ModelV2.ID,
+}) {}
+
 export const PolicyActions = Schema.Literals(["provider.use"])
 
 export const Event = {
@@ -27,16 +42,16 @@ type Data = {
   defaultModel?: DefaultModel
 }
 
-export type Draft = {
+export type Editor = {
   provider: {
     list: () => readonly ProviderRecord[]
     get: (providerID: ProviderV2.ID) => ProviderRecord | undefined
-    update: (providerID: ProviderV2.ID, fn: (provider: ProviderV2.MutableInfo) => void) => void
+    update: (providerID: ProviderV2.ID, fn: (provider: Draft<ProviderV2.Info>) => void) => void
     remove: (providerID: ProviderV2.ID) => void
   }
   model: {
     get: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => ModelV2.Info | undefined
-    update: (providerID: ProviderV2.ID, modelID: ModelV2.ID, fn: (model: ModelV2.MutableInfo) => void) => void
+    update: (providerID: ProviderV2.ID, modelID: ModelV2.ID, fn: (model: Draft<ModelV2.Info>) => void) => void
     remove: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => void
     default: {
       get: () => DefaultModel | undefined
@@ -45,34 +60,43 @@ export type Draft = {
   }
 }
 
-export interface Interface extends State.Transformable<Draft> {
+export interface Interface {
+  readonly transform: State.Interface<Data, Editor>["transform"]
   readonly provider: {
-    readonly get: (providerID: ProviderV2.ID) => Effect.Effect<ProviderV2.Info | undefined>
+    readonly get: (providerID: ProviderV2.ID) => Effect.Effect<ProviderV2.Info, ProviderNotFoundError>
     readonly all: () => Effect.Effect<ProviderV2.Info[]>
     readonly available: () => Effect.Effect<ProviderV2.Info[]>
   }
   readonly model: {
-    readonly get: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => Effect.Effect<ModelV2.Info | undefined>
+    readonly get: (
+      providerID: ProviderV2.ID,
+      modelID: ModelV2.ID,
+    ) => Effect.Effect<ModelV2.Info, ProviderNotFoundError | ModelNotFoundError>
     readonly all: () => Effect.Effect<ModelV2.Info[]>
     readonly available: () => Effect.Effect<ModelV2.Info[]>
-    readonly default: () => Effect.Effect<ModelV2.Info | undefined>
-    readonly small: (providerID: ProviderV2.ID) => Effect.Effect<ModelV2.Info | undefined>
+    readonly default: () => Effect.Effect<Option.Option<ModelV2.Info>>
+    readonly small: (providerID: ProviderV2.ID) => Effect.Effect<Option.Option<ModelV2.Info>>
   }
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Catalog") {}
 
+enableMapSet()
+
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const location = yield* Location.Service
+    const plugin = yield* PluginV2.Service
     const events = yield* EventV2.Service
     const policy = yield* Policy.Service
     const integrations = yield* Integration.Service
+    const scope = yield* Scope.Scope
 
-    const available = (provider: ProviderV2.Info, integration: Integration.Info | undefined) => {
+    const available = (provider: ProviderV2.Info, integration: Integration.Info | undefined, connected: boolean) => {
       if (provider.disabled) return false
       if (typeof provider.request.body.apiKey === "string") return true
-      if (integration?.connections.length) return true
+      if (connected) return true
       return !integration
     }
 
@@ -96,26 +120,32 @@ export const layer = Layer.effect(
       })
     }
 
-    const normalizeApi = (item: ProviderV2.MutableInfo | ModelV2.MutableInfo) => {
+    function* getRecord(providerID: ProviderV2.ID) {
+      const match = state.get().providers.get(providerID)
+      if (!match) return yield* new ProviderNotFoundError({ providerID })
+      return match
+    }
+
+    const normalizeApi = (item: Draft<ProviderV2.Info> | Draft<ModelV2.Info>) => {
       if (typeof item.request.body.baseURL !== "string") return
       item.api.url = item.request.body.baseURL
       delete item.request.body.baseURL
     }
 
-    const state = State.create<Data, Draft>({
+    const state = State.create<Data, Editor>({
       initial: () => ({ providers: new Map() }),
-      draft: (draft) => {
-        const result: Draft = {
+      editor: (draft) => {
+        const result: Editor = {
           provider: {
             list: () => Array.fromIterable(draft.providers.values()) as ProviderRecord[],
             get: (providerID) => draft.providers.get(providerID),
             update: (providerID, fn) => {
               let current = draft.providers.get(providerID)
               if (!current) {
-                current = {
-                  provider: ProviderV2.Info.empty(providerID) as ProviderV2.MutableInfo,
-                  models: new Map<ModelV2.ID, ModelV2.MutableInfo>(),
-                }
+                current = castDraft({
+                  provider: ProviderV2.Info.empty(providerID),
+                  models: new Map<ModelV2.ID, ModelV2.Info>(),
+                })
                 draft.providers.set(providerID, current)
               }
               fn(current.provider)
@@ -130,14 +160,13 @@ export const layer = Layer.effect(
             update: (providerID, modelID, fn) => {
               let record = draft.providers.get(providerID)
               if (!record) {
-                record = {
-                  provider: ProviderV2.Info.empty(providerID) as ProviderV2.MutableInfo,
-                  models: new Map<ModelV2.ID, ModelV2.MutableInfo>(),
-                }
+                record = castDraft({
+                  provider: ProviderV2.Info.empty(providerID),
+                  models: new Map<ModelV2.ID, ModelV2.Info>(),
+                })
                 draft.providers.set(providerID, record)
               }
-              const model =
-                record.models.get(modelID) ?? (ModelV2.Info.empty(providerID, modelID) as ModelV2.MutableInfo)
+              const model = record.models.get(modelID) ?? castDraft(ModelV2.Info.empty(providerID, modelID))
               if (!record.models.has(modelID)) record.models.set(modelID, model)
               fn(model)
               model.id = modelID
@@ -157,7 +186,8 @@ export const layer = Layer.effect(
         }
         return result
       },
-      finalize: Effect.fn("CatalogV2.finalize")(function* (catalog) {
+      finalize: Effect.fn("CatalogV2.finalize")(function* (catalog, reason) {
+        if (reason !== "plugin.added") yield* plugin.trigger("catalog.transform", catalog, {}).pipe(Effect.asVoid)
         if (policy.hasStatements()) {
           for (const record of [...catalog.provider.list()]) {
             if ((yield* policy.evaluate("provider.use", record.provider.id, "allow")) === "deny") {
@@ -168,13 +198,25 @@ export const layer = Layer.effect(
         yield* events.publish(Event.Updated, {})
       }),
     })
+    yield* events.subscribe(PluginV2.Event.Added).pipe(
+      // Plugin registries are location scoped even though the event bus is process scoped.
+      Stream.filter(
+        (event) =>
+          event.location?.directory === location.directory && event.location.workspaceID === location.workspaceID,
+      ),
+      Stream.runForEach((event) =>
+        state.mutate((catalog) => plugin.triggerFor(event.data.id, "catalog.transform", catalog, {}), "plugin.added"),
+      ),
+      Effect.forkIn(scope, { startImmediately: true }),
+    )
+
     const result: Interface = {
       transform: state.transform,
-      reload: state.reload,
 
       provider: {
         get: Effect.fn("CatalogV2.provider.get")(function* (providerID) {
-          return state.get().providers.get(providerID)?.provider
+          const record = yield* getRecord(providerID)
+          return record.provider
         }),
 
         all: Effect.fn("CatalogV2.provider.all")(function* () {
@@ -183,18 +225,23 @@ export const layer = Layer.effect(
 
         available: Effect.fn("CatalogV2.provider.available")(function* () {
           const active = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]))
+          const connections = yield* integrations.connection.list()
           return (yield* result.provider.all()).filter((provider) =>
-            available(provider, active.get(Integration.ID.make(provider.id))),
+            available(
+              provider,
+              active.get(Integration.ID.make(provider.id)),
+              connections.has(Integration.ID.make(provider.id)),
+            ),
           )
         }),
       },
 
       model: {
         get: Effect.fn("CatalogV2.model.get")(function* (providerID, modelID) {
-          const record = state.get().providers.get(providerID)
-          if (!record) return
+          const record = yield* getRecord(providerID)
           const model = record.models.get(modelID)
-          return model && projectModel(model, record.provider)
+          if (!model) return yield* new ModelNotFoundError({ providerID, modelID })
+          return projectModel(model, record.provider)
         }),
 
         all: Effect.fn("CatalogV2.model.all")(function* () {
@@ -203,7 +250,7 @@ export const layer = Layer.effect(
             Array.flatMap((record) => {
               return Array.fromIterable(record.models.values()).map((model) => projectModel(model, record.provider))
             }),
-            Array.sortWith((item) => item.time.released, Order.flip(Order.Number)),
+            Array.sortWith((item) => item.time.released.epochMilliseconds, Order.flip(Order.Number)),
           )
         }),
 
@@ -215,30 +262,31 @@ export const layer = Layer.effect(
         default: Effect.fn("CatalogV2.model.default")(function* () {
           const defaultModel = state.get().defaultModel
           if (defaultModel) {
-            const provider = yield* result.provider.get(defaultModel.providerID)
-            if (provider && (yield* result.provider.available()).some((item) => item.id === provider.id)) {
-              const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID)
-              if (model?.enabled) return model
+            const provider = yield* result.provider.get(defaultModel.providerID).pipe(Effect.option)
+            if (
+              Option.isSome(provider) &&
+              (yield* result.provider.available()).some((item) => item.id === provider.value.id)
+            ) {
+              const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID).pipe(Effect.option)
+              if (Option.isSome(model) && model.value.enabled) return model
             }
           }
 
-          return Option.getOrUndefined(
-            pipe(
-              yield* result.model.available(),
-              Array.sortWith((item) => item.time.released, Order.flip(Order.Number)),
-              Array.head,
-            ),
+          return pipe(
+            yield* result.model.available(),
+            Array.sortWith((item) => item.time.released.epochMilliseconds, Order.flip(Order.Number)),
+            Array.head,
           )
         }),
 
         small: Effect.fn("CatalogV2.model.small")(function* (providerID) {
           const record = state.get().providers.get(providerID)
-          if (!record) return
+          if (!record) return Option.none<ModelV2.Info>()
           const provider = record.provider
 
           if (providerID === ProviderV2.ID.opencode) {
             const gpt5Nano = record.models.get(ModelV2.ID.make("gpt-5-nano"))
-            if (gpt5Nano?.enabled && gpt5Nano.status === "active") return projectModel(gpt5Nano, provider)
+            if (gpt5Nano?.enabled && gpt5Nano.status === "active") return Option.some(projectModel(gpt5Nano, provider))
           }
 
           const candidates = pipe(
@@ -254,7 +302,7 @@ export const layer = Layer.effect(
             Array.map((model) => ({
               model,
               cost: model.cost[0] ? model.cost[0].input + model.cost[0].output : 999,
-              age: (Date.now() - model.time.released) / (1000 * 60 * 60 * 24 * 30),
+              age: (Date.now() - model.time.released.epochMilliseconds) / (1000 * 60 * 60 * 24 * 30),
               small: SMALL_MODEL_RE.test(`${model.id} ${model.family ?? ""} ${model.name}`.toLowerCase()),
             })),
             Array.filter((item) => item.cost > 0 && item.age <= 18),
@@ -271,12 +319,10 @@ export const layer = Layer.effect(
             )
           }
 
-          return Option.getOrUndefined(
-            pipe(
-              candidates,
-              Array.filter((item) => item.small),
-              (items) => (items.length > 0 ? pick(items) : pick(candidates)),
-            ),
+          return pipe(
+            candidates,
+            Array.filter((item) => item.small),
+            (items) => (items.length > 0 ? pick(items) : pick(candidates)),
           )
         }),
       },
@@ -290,5 +336,6 @@ const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/
 
 export const locationLayer = layer.pipe(
   Layer.provideMerge(Integration.locationLayer),
+  Layer.provideMerge(PluginV2.locationLayer),
   Layer.provideMerge(Policy.locationLayer),
 )

packages/core/src/command.ts

@@ -1,6 +1,8 @@
 export * as CommandV2 from "./command"
 
-import { Context, Effect, Layer, Schema, Types } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
+import { castDraft, type Draft } from "immer"
+import { LayerNode } from "./effect/layer-node"
 import { ModelV2 } from "./model"
 import { State } from "./state"
 
@@ -14,17 +16,19 @@ export class Info extends Schema.Class<Info>("CommandV2.Info")({
 }) {}
 
 export type Data = {
-  commands: Map<string, Types.DeepMutable<Info>>
+  commands: Map<string, Info>
 }
 
-export type Draft = {
+export type Editor = {
   list: () => readonly Info[]
   get: (name: string) => Info | undefined
-  update: (name: string, update: (command: Types.DeepMutable<Info>) => void) => void
+  update: (name: string, update: (command: Draft<Info>) => void) => void
   remove: (name: string) => void
 }
 
-export interface Interface extends State.Transformable<Draft> {
+export interface Interface {
+  readonly transform: State.Interface<Data, Editor>["transform"]
+  readonly update: State.Interface<Data, Editor>["update"]
   readonly get: (name: string) => Effect.Effect<Info | undefined>
   readonly list: () => Effect.Effect<Info[]>
 }
@@ -34,13 +38,13 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
   Service,
   Effect.sync(() => {
-    const state = State.create<Data, Draft>({
+    const state = State.create<Data, Editor>({
       initial: () => ({ commands: new Map() }),
-      draft: (draft) => ({
+      editor: (draft) => ({
         list: () => Array.from(draft.commands.values()) as Info[],
         get: (name) => draft.commands.get(name),
         update: (name, update) => {
-          const current = draft.commands.get(name) ?? (new Info({ name, template: "" }) as Types.DeepMutable<Info>)
+          const current = draft.commands.get(name) ?? castDraft(new Info({ name, template: "" }))
           if (!draft.commands.has(name)) draft.commands.set(name, current)
           update(current)
           current.name = name
@@ -52,7 +56,7 @@ export const layer = Layer.effect(
     })
 
     return Service.of({
-      reload: state.reload,
+      update: state.update,
       transform: state.transform,
       get: Effect.fn("CommandV2.get")(function* (name) {
         return state.get().commands.get(name)
@@ -65,3 +69,4 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
+export const node = LayerNode.make(layer, [])

packages/core/src/config/plugin/agent.ts

@@ -1,6 +1,5 @@
 export * as ConfigAgentPlugin from "./agent"
 
-import { define } from "../../plugin/internal"
 import path from "path"
 import { Effect, Option, Schema } from "effect"
 import { AgentV2 } from "../../agent"
@@ -9,6 +8,7 @@ import { ConfigAgent } from "../agent"
 import { ConfigMarkdown } from "../markdown"
 import { FSUtil } from "../../fs-util"
 import { ModelV2 } from "../../model"
+import { PluginV2 } from "../../plugin"
 import { ConfigAgentV1 } from "../../v1/config/agent"
 import { ConfigMigrateV1 } from "../../v1/config/migrate"
 
@@ -33,70 +33,70 @@ const agentKeys = new Set([
   "permissions",
 ])
 
-export const Plugin = define({
-  id: "config-agent",
-  effect: Effect.fn(function* (ctx) {
+export const Plugin = PluginV2.define({
+  id: PluginV2.ID.make("config-agent"),
+  effect: Effect.gen(function* () {
+    const agent = yield* AgentV2.Service
     const config = yield* Config.Service
     const fs = yield* FSUtil.Service
-    yield* ctx.agent.transform(
-      Effect.fn(function* (draft) {
-        const documents = yield* Effect.forEach(yield* config.entries(), (entry) => {
-          if (entry.type === "document") return Effect.succeed([entry])
-          return Effect.gen(function* () {
-            const files = yield* discover(fs, entry.path)
-            return yield* Effect.forEach(files, (file) =>
-              fs.readFileStringSafe(file.filepath).pipe(
-                Effect.map((content) => content && decode(file, content)),
-                Effect.catch(() => Effect.succeed(undefined)),
-              ),
-            ).pipe(
-              Effect.map((documents) =>
-                documents.filter((document): document is Config.Document => document !== undefined),
-              ),
-            )
-          })
-        }).pipe(Effect.map((documents) => documents.flat()))
-        const global = documents.flatMap((document) => document.info.permissions ?? [])
-        const configuredDefault = Config.latest(documents, "default_agent")
-        if (configuredDefault !== undefined) draft.default(AgentV2.ID.make(configuredDefault))
-        for (const current of draft.list()) {
-          draft.update(current.id, (agent) => agent.permissions.push(...global))
-        }
+    const documents = yield* Effect.forEach(yield* config.entries(), (entry) => {
+      if (entry.type === "document") return Effect.succeed([entry])
+      return Effect.gen(function* () {
+        const files = yield* discover(fs, entry.path)
+        return yield* Effect.forEach(files, (file) =>
+          fs.readFileStringSafe(file.filepath).pipe(
+            Effect.map((content) => content && decode(file, content)),
+            Effect.catch(() => Effect.succeed(undefined)),
+          ),
+        ).pipe(
+          Effect.map((documents) =>
+            documents.filter((document): document is Config.Document => document !== undefined),
+          ),
+        )
+      })
+    }).pipe(Effect.map((documents) => documents.flat()))
 
-        for (const document of documents) {
-          for (const [id, item] of Object.entries(document.info.agents ?? {})) {
-            const agentID = AgentV2.ID.make(id)
-            if (item.disabled) {
-              draft.remove(agentID)
-              continue
-            }
+    yield* agent.update((editor) => {
+      const global = documents.flatMap((document) => document.info.permissions ?? [])
+      const configuredDefault = Config.latest(documents, "default_agent")
+      if (configuredDefault !== undefined) editor.default(AgentV2.ID.make(configuredDefault))
+      for (const current of editor.list()) {
+        editor.update(current.id, (agent) => agent.permissions.push(...global))
+      }
 
-            const exists = draft.get(agentID) !== undefined
-            draft.update(agentID, (agent) => {
-              if (!exists) agent.permissions.push(...global)
-              if (item.model !== undefined) {
-                const model = ModelV2.parse(item.model)
-                agent.model = { id: model.modelID, providerID: model.providerID, variant: agent.model?.variant }
-              }
-              if (item.variant !== undefined && agent.model !== undefined) {
-                agent.model.variant = ModelV2.VariantID.make(item.variant)
-              }
-              if (item.request !== undefined) {
-                Object.assign(agent.request.headers, item.request.headers ?? {})
-                Object.assign(agent.request.body, item.request.body ?? {})
-              }
-              if (item.system !== undefined) agent.system = item.system
-              if (item.description !== undefined) agent.description = item.description
-              if (item.mode !== undefined) agent.mode = item.mode
-              if (item.hidden !== undefined) agent.hidden = item.hidden
-              if (item.color !== undefined) agent.color = item.color
-              if (item.steps !== undefined) agent.steps = item.steps
-              if (item.permissions !== undefined) agent.permissions.push(...item.permissions)
-            })
+      for (const document of documents) {
+        for (const [id, item] of Object.entries(document.info.agents ?? {})) {
+          const agentID = AgentV2.ID.make(id)
+          if (item.disabled) {
+            editor.remove(agentID)
+            continue
           }
+
+          const exists = editor.get(agentID) !== undefined
+          editor.update(agentID, (agent) => {
+            if (!exists) agent.permissions.push(...global)
+            if (item.model !== undefined) {
+              const model = ModelV2.parse(item.model)
+              agent.model = { id: model.modelID, providerID: model.providerID, variant: agent.model?.variant }
+            }
+            if (item.variant !== undefined && agent.model !== undefined) {
+              agent.model.variant = ModelV2.VariantID.make(item.variant)
+            }
+            if (item.request !== undefined) {
+              Object.assign(agent.request.headers, item.request.headers ?? {})
+              Object.assign(agent.request.body, item.request.body ?? {})
+            }
+            if (item.system !== undefined) agent.system = item.system
+            if (item.description !== undefined) agent.description = item.description
+            if (item.mode !== undefined) agent.mode = item.mode
+            if (item.hidden !== undefined) agent.hidden = item.hidden
+            if (item.color !== undefined) agent.color = item.color
+            if (item.steps !== undefined) agent.steps = item.steps
+            if (item.permissions !== undefined) agent.permissions.push(...item.permissions)
+          })
         }
-      }),
-    )
+      }
+    })
   }),
 })
 

packages/core/src/config/plugin/command.ts

@@ -1,51 +1,52 @@
 export * as ConfigCommandPlugin from "./command"
 
-import { define } from "../../plugin/internal"
 import path from "path"
 import { Effect, Option, Schema } from "effect"
 import { CommandV2 } from "../../command"
 import { Config } from "../../config"
 import { FSUtil } from "../../fs-util"
 import { ModelV2 } from "../../model"
+import { PluginV2 } from "../../plugin"
 import { ConfigCommand } from "../command"
 import { ConfigMarkdown } from "../markdown"
 
 const decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info)
 
-export const Plugin = define({
-  id: "config-command",
-  effect: Effect.fn(function* (ctx) {
+export const Plugin = PluginV2.define({
+  id: PluginV2.ID.make("config-command"),
+  effect: Effect.gen(function* () {
+    const command = yield* CommandV2.Service
     const config = yield* Config.Service
     const fs = yield* FSUtil.Service
-    yield* ctx.command.transform(
-      Effect.fn(function* (draft) {
-        const documents = yield* Effect.forEach(yield* config.entries(), (entry) => {
-          if (entry.type === "document") return Effect.succeed([{ commands: entry.info.commands }])
-          return loadDirectory(fs, entry.path).pipe(
-            Effect.map((commands) => [
-              { commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) },
-            ]),
-          )
-        }).pipe(Effect.map((documents) => documents.flat()))
-        for (const document of documents) {
-          for (const [name, command] of Object.entries(document.commands ?? {})) {
-            draft.update(name, (item) => {
-              item.template = command.template
-              if (command.description !== undefined) item.description = command.description
-              if (command.agent !== undefined) item.agent = command.agent
-              if (command.model !== undefined) {
-                const model = ModelV2.parse(command.model)
-                item.model = { id: model.modelID, providerID: model.providerID, variant: item.model?.variant }
-              }
-              if (command.variant !== undefined && item.model !== undefined) {
-                item.model.variant = ModelV2.VariantID.make(command.variant)
-              }
-              if (command.subtask !== undefined) item.subtask = command.subtask
-            })
-          }
+    const transform = yield* command.transform()
+    const documents = yield* Effect.forEach(yield* config.entries(), (entry) => {
+      if (entry.type === "document") return Effect.succeed([{ commands: entry.info.commands }])
+      return loadDirectory(fs, entry.path).pipe(
+        Effect.map((commands) => [
+          { commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) },
+        ]),
+      )
+    }).pipe(Effect.map((documents) => documents.flat()))
+
+    yield* transform((editor) => {
+      for (const document of documents) {
+        for (const [name, command] of Object.entries(document.commands ?? {})) {
+          editor.update(name, (item) => {
+            item.template = command.template
+            if (command.description !== undefined) item.description = command.description
+            if (command.agent !== undefined) item.agent = command.agent
+            if (command.model !== undefined) {
+              const model = ModelV2.parse(command.model)
+              item.model = { id: model.modelID, providerID: model.providerID, variant: item.model?.variant }
+            }
+            if (command.variant !== undefined && item.model !== undefined) {
+              item.model.variant = ModelV2.VariantID.make(command.variant)
+            }
+            if (command.subtask !== undefined) item.subtask = command.subtask
+          })
         }
-      }),
-    )
+      }
+    })
   }),
 })
 

packages/core/src/config/plugin/external.ts

@@ -1,91 +0,0 @@
-export * as ConfigExternalPlugin from "./external"
-
-import type { Plugin as EffectPlugin } from "@opencode-ai/plugin/v2/effect"
-import type { Plugin as PromisePlugin } from "@opencode-ai/plugin/v2/promise"
-import { Effect, Schema } from "effect"
-import path from "path"
-import { fileURLToPath, pathToFileURL } from "url"
-import { Config } from "../../config"
-import { FSUtil } from "../../fs-util"
-import { Location } from "../../location"
-import { Npm } from "../../npm"
-import { define } from "../../plugin/internal"
-import { PluginPromise } from "../../plugin/promise"
-
-const PluginModule = Schema.Struct({
-  default: Schema.Union([
-    Schema.Struct({
-      id: Schema.String,
-      effect: Schema.declare<EffectPlugin["effect"]>(
-        (input): input is EffectPlugin["effect"] => typeof input === "function",
-      ),
-    }),
-    Schema.Struct({
-      id: Schema.String,
-      setup: Schema.declare<PromisePlugin["setup"]>(
-        (input): input is PromisePlugin["setup"] => typeof input === "function",
-      ),
-    }),
-  ]),
-})
-
-export const Plugin = define({
-  id: "config-plugin",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const fs = yield* FSUtil.Service
-    const location = yield* Location.Service
-    const npm = yield* Npm.Service
-    yield* Effect.gen(function* () {
-      const configured: { package: string; options?: Record<string, any> }[] = []
-
-      for (const entry of yield* config.entries()) {
-        if (entry.type === "document") {
-          const directory = entry.path ? path.dirname(entry.path) : location.directory
-          for (const item of entry.info.plugins ?? []) {
-            const ref = typeof item === "string" ? { package: item } : item
-            const packageName = (() => {
-              if (ref.package.startsWith("file://")) return fileURLToPath(ref.package)
-              if (ref.package.startsWith("./") || ref.package.startsWith("../")) {
-                return path.resolve(directory, ref.package)
-              }
-              return ref.package
-            })()
-            configured.push({ package: packageName, options: ref.options })
-          }
-        }
-
-        if (entry.type === "directory") {
-          const files = yield* fs
-            .glob("{plugin,plugins}/*.{ts,js}", {
-              cwd: entry.path,
-              absolute: true,
-              include: "file",
-              dot: true,
-              symlink: true,
-            })
-            .pipe(Effect.orElseSucceed(() => []))
-          files.sort()
-          for (const file of files) configured.push({ package: file })
-        }
-      }
-
-      for (const ref of configured) {
-        yield* Effect.gen(function* () {
-          const entrypoint = path.isAbsolute(ref.package)
-            ? pathToFileURL(ref.package).href
-            : (yield* npm.add(ref.package)).entrypoint
-          if (!entrypoint) return
-
-          const mod = yield* Effect.promise(() => import(entrypoint))
-          const value = (yield* Schema.decodeUnknownEffect(PluginModule)(mod)).default
-          const plugin = "effect" in value ? value : PluginPromise.fromPromise(value)
-          yield* ctx.plugin.add({
-            id: plugin.id,
-            effect: (host) => plugin.effect({ ...host, options: ref.options ?? {} }),
-          })
-        }).pipe(Effect.ignoreCause)
-      }
-    }).pipe(Effect.forkScoped({ startImmediately: true }))
-  }),
-})

packages/core/src/config/plugin/provider.ts

@@ -1,124 +1,123 @@
 export * as ConfigProviderPlugin from "./provider"
 
-import { define } from "../../plugin/internal"
 import { Effect } from "effect"
+import { Catalog } from "../../catalog"
 import { Config } from "../../config"
+import { Integration } from "../../integration"
 import { ModelV2 } from "../../model"
 import { ModelRequest } from "../../model-request"
+import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
-export const Plugin = define({
-  id: "config-provider",
-  effect: Effect.fn(function* (ctx) {
+export const Plugin = PluginV2.define({
+  id: PluginV2.ID.make("config-provider"),
+  effect: Effect.gen(function* () {
+    const catalog = yield* Catalog.Service
     const config = yield* Config.Service
-    yield* ctx.integration.transform(
-      Effect.fn(function* (integrations) {
-        const files = (yield* config.entries()).filter((entry): entry is Config.Document => entry.type === "document")
-        const configuredIntegrations = new Set(
-          files.flatMap((file) =>
-            Object.entries(file.info.providers ?? {}).flatMap(([id, provider]) =>
-              provider.env === undefined ? [] : [id],
-            ),
-          ),
-        )
-        for (const file of files) {
-          for (const [id, item] of Object.entries(file.info.providers ?? {})) {
-            const integrationID = id
-            if (!configuredIntegrations.has(id) && !integrations.get(integrationID)) continue
-            integrations.update(integrationID, (integration) => {
-              integration.name = item.name ?? integration.name
+    const integrations = yield* Integration.Service
+    const transform = yield* catalog.transform()
+    const integrationTransform = yield* integrations.transform()
+    const entries = yield* config.entries()
+    const files = entries.filter((entry): entry is Config.Document => entry.type === "document")
+    const configuredIntegrations = new Set(
+      files.flatMap((file) =>
+        Object.entries(file.info.providers ?? {}).flatMap(([id, provider]) => (provider.env === undefined ? [] : [id])),
+      ),
+    )
+    yield* integrationTransform((integrations) => {
+      for (const file of files) {
+        for (const [id, item] of Object.entries(file.info.providers ?? {})) {
+          const integrationID = Integration.ID.make(id)
+          if (!configuredIntegrations.has(id) && !integrations.get(integrationID)) continue
+          integrations.update(integrationID, (integration) => {
+            integration.name = item.name ?? integration.name
+          })
+          if (item.env !== undefined) {
+            integrations.method.update({
+              integrationID,
+              method: { type: "env", names: [...item.env] },
             })
-            if (item.env !== undefined) {
-              integrations.method.update({
-                integrationID,
-                method: { type: "env", names: [...item.env] },
-              })
-            }
           }
         }
-      }),
-    )
+      }
+    })
 
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (catalog) {
-        const entries = yield* config.entries()
-        const files = entries.filter((entry): entry is Config.Document => entry.type === "document")
-        const configuredDefault = Config.latest(entries, "model")
-        if (configuredDefault !== undefined) {
-          const model = ModelV2.parse(configuredDefault)
-          catalog.model.default.set(model.providerID, model.modelID)
-        }
-        for (const file of files) {
-          for (const [id, item] of Object.entries(file.info.providers ?? {})) {
-            const providerID = id
-            catalog.provider.update(providerID, (provider) => {
-              if (item.name !== undefined) provider.name = item.name
-              if (item.api !== undefined) provider.api = { ...item.api }
-              if (item.request !== undefined) {
-                Object.assign(provider.request.headers, item.request.headers)
-                Object.assign(provider.request.body, item.request.body)
+    yield* transform((catalog) => {
+      const configuredDefault = Config.latest(entries, "model")
+      if (configuredDefault !== undefined) {
+        const model = ModelV2.parse(configuredDefault)
+        catalog.model.default.set(model.providerID, model.modelID)
+      }
+      for (const file of files) {
+        for (const [id, item] of Object.entries(file.info.providers ?? {})) {
+          const providerID = ProviderV2.ID.make(id)
+          catalog.provider.update(providerID, (provider) => {
+            if (item.name !== undefined) provider.name = item.name
+            if (item.api !== undefined) provider.api = { ...item.api }
+            if (item.request !== undefined) {
+              Object.assign(provider.request.headers, item.request.headers)
+              Object.assign(provider.request.body, item.request.body)
+            }
+          })
+          const providerApi = catalog.provider.get(providerID)?.provider.api
+          const providerPackage = providerApi?.type === "aisdk" ? providerApi.package : undefined
+
+          for (const [id, config] of Object.entries(item.models ?? {})) {
+            catalog.model.update(providerID, ModelV2.ID.make(id), (model) => {
+              if (config.family !== undefined) model.family = config.family
+              if (config.name !== undefined) model.name = config.name
+              if (config.api !== undefined) model.api = { ...model.api, ...config.api }
+              const packageName = model.api.type === "aisdk" ? model.api.package : providerPackage
+              if (config.capabilities !== undefined) {
+                model.capabilities = {
+                  tools: config.capabilities.tools,
+                  input: [...config.capabilities.input],
+                  output: [...config.capabilities.output],
+                }
               }
-            })
-            const providerApi = catalog.provider.get(providerID)?.provider.api
-            const providerPackage = providerApi?.type === "aisdk" ? providerApi.package : undefined
-
-            for (const [id, config] of Object.entries(item.models ?? {})) {
-              catalog.model.update(providerID, id, (model) => {
-                if (config.family !== undefined) model.family = config.family
-                if (config.name !== undefined) model.name = config.name
-                if (config.api !== undefined) model.api = { ...model.api, ...config.api }
-                const packageName = model.api.type === "aisdk" ? model.api.package : providerPackage
-                if (config.capabilities !== undefined) {
-                  model.capabilities = {
-                    tools: config.capabilities.tools,
-                    input: [...config.capabilities.input],
-                    output: [...config.capabilities.output],
-                  }
-                }
-                if (config.request !== undefined) {
-                  ModelRequest.assign(model.request, {
-                    headers: config.request.headers,
-                    ...ModelRequest.normalizeAiSdkOptions(packageName, config.request.body ?? {}),
-                  })
-                  if (config.request.variant !== undefined) model.request.variant = config.request.variant
-                }
-                if (config.variants !== undefined) {
-                  for (const variant of config.variants) {
-                    let existing = model.variants.find((item) => item.id === variant.id)
-                    if (!existing) {
-                      existing = {
-                        id: variant.id,
-                        headers: {},
-                        body: {},
-                        generation: {},
-                        options: {},
-                      }
-                      model.variants.push(existing)
+              if (config.request !== undefined) {
+                ModelRequest.assign(model.request, {
+                  headers: config.request.headers,
+                  ...ModelRequest.normalizeAiSdkOptions(packageName, config.request.body ?? {}),
+                })
+                if (config.request.variant !== undefined) model.request.variant = config.request.variant
+              }
+              if (config.variants !== undefined) {
+                for (const variant of config.variants) {
+                  let existing = model.variants.find((item) => item.id === variant.id)
+                  if (!existing) {
+                    existing = {
+                      id: variant.id,
+                      headers: {},
+                      body: {},
+                      generation: {},
+                      options: {},
                     }
-                    ModelRequest.assign(existing, {
-                      headers: variant.headers,
-                      ...ModelRequest.normalizeAiSdkOptions(packageName, variant.body ?? {}),
-                    })
+                    model.variants.push(existing)
                   }
+                  ModelRequest.assign(existing, {
+                    headers: variant.headers,
+                    ...ModelRequest.normalizeAiSdkOptions(packageName, variant.body ?? {}),
+                  })
                 }
-                if (config.cost !== undefined) {
-                  model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
-                    tier: cost.tier && { ...cost.tier },
-                    input: cost.input,
-                    output: cost.output,
-                    cache: {
-                      read: cost.cache?.read ?? 0,
-                      write: cost.cache?.write ?? 0,
-                    },
-                  }))
-                }
-                if (config.disabled !== undefined) model.enabled = !config.disabled
-                if (config.limit !== undefined) model.limit = { ...model.limit, ...config.limit }
-              })
-            }
+              }
+              if (config.cost !== undefined) {
+                model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
+                  tier: cost.tier && { ...cost.tier },
+                  input: cost.input,
+                  output: cost.output,
+                  cache: {
+                    read: cost.cache?.read ?? 0,
+                    write: cost.cache?.write ?? 0,
+                  },
+                }))
+              }
+              if (config.disabled !== undefined) model.enabled = !config.disabled
+              if (config.limit !== undefined) model.limit = { ...model.limit, ...config.limit }
+            })
           }
         }
-      }),
-    )
+      }
+    })
   }),
 })

packages/core/src/config/plugin/reference.ts

@@ -1,56 +1,57 @@
 export * as ConfigReferencePlugin from "./reference"
 
-import { define } from "../../plugin/internal"
 import path from "path"
 import { Effect } from "effect"
 import { Config } from "../../config"
 import { ConfigReference } from "../reference"
-import { Reference } from "../../reference"
-import { AbsolutePath } from "../../schema"
 import { Global } from "../../global"
 import { Location } from "../../location"
+import { PluginV2 } from "../../plugin"
+import { Reference } from "../../reference"
+import { AbsolutePath } from "../../schema"
 
-export const Plugin = define({
-  id: "core/config-reference",
-  effect: Effect.fn(function* (ctx) {
+export const Plugin = {
+  id: PluginV2.ID.make("core/config-reference"),
+  effect: Effect.gen(function* () {
     const config = yield* Config.Service
-    const location = yield* Location.Service
     const global = yield* Global.Service
-    yield* ctx.reference.transform(
-      Effect.fn(function* (draft) {
-        const entries = new Map<string, Reference.Source>()
-        for (const doc of (yield* config.entries()).filter(
-          (entry): entry is Config.Document => entry.type === "document",
-        )) {
-          const directory = doc.path ? path.dirname(doc.path) : location.directory
-          for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
-            if (!validAlias(name)) continue
-            entries.set(
-              name,
-              local(entry)
-                ? new Reference.LocalSource({
-                    type: "local",
-                    path: AbsolutePath.make(
-                      localPath(directory, global.home, typeof entry === "string" ? entry : entry.path),
-                    ),
-                    description: typeof entry === "string" ? undefined : entry.description,
-                    hidden: typeof entry === "string" ? undefined : entry.hidden,
-                  })
-                : new Reference.GitSource({
-                    type: "git",
-                    repository: typeof entry === "string" ? entry : entry.repository,
-                    branch: typeof entry === "string" ? undefined : entry.branch,
-                    description: typeof entry === "string" ? undefined : entry.description,
-                    hidden: typeof entry === "string" ? undefined : entry.hidden,
-                  }),
-            )
-          }
-        }
-        for (const [name, source] of entries) draft.add(name, source)
-      }),
-    )
+    const location = yield* Location.Service
+    const references = yield* Reference.Service
+    const update = yield* references.transform()
+    const entries = new Map<string, Reference.Source>()
+    for (const doc of (yield* config.entries()).filter(
+      (entry): entry is Config.Document => entry.type === "document",
+    )) {
+      const directory = doc.path ? path.dirname(doc.path) : location.directory
+      for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
+        if (!validAlias(name)) continue
+        entries.set(
+          name,
+          local(entry)
+            ? new Reference.LocalSource({
+                type: "local",
+                path: AbsolutePath.make(
+                  localPath(directory, global.home, typeof entry === "string" ? entry : entry.path),
+                ),
+                description: typeof entry === "string" ? undefined : entry.description,
+                hidden: typeof entry === "string" ? undefined : entry.hidden,
+              })
+            : new Reference.GitSource({
+                type: "git",
+                repository: typeof entry === "string" ? entry : entry.repository,
+                branch: typeof entry === "string" ? undefined : entry.branch,
+                description: typeof entry === "string" ? undefined : entry.description,
+                hidden: typeof entry === "string" ? undefined : entry.hidden,
+              }),
+        )
+      }
+    }
+
+    yield* update((editor) => {
+      for (const [name, source] of entries) editor.add(name, source)
+    })
   }),
-})
+}
 
 function validAlias(name: string) {
   return name.length > 0 && !/[\/\s`,]/.test(name)

packages/core/src/config/plugin/skill.ts

@@ -1,47 +1,48 @@
 export * as ConfigSkillPlugin from "./skill"
 
-import { define } from "../../plugin/internal"
 import path from "path"
 import { Effect } from "effect"
 import { Config } from "../../config"
-import { AbsolutePath } from "../../schema"
-import { SkillV2 } from "../../skill"
 import { Global } from "../../global"
 import { Location } from "../../location"
+import { PluginV2 } from "../../plugin"
+import { AbsolutePath } from "../../schema"
+import { SkillV2 } from "../../skill"
 
-export const Plugin = define({
-  id: "config-skill",
-  effect: Effect.fn(function* (ctx) {
+export const Plugin = PluginV2.define({
+  id: PluginV2.ID.make("config-skill"),
+  effect: Effect.gen(function* () {
     const config = yield* Config.Service
     const global = yield* Global.Service
     const location = yield* Location.Service
-    yield* ctx.skill.transform(
-      Effect.fn(function* (draft) {
-        const entries = yield* config.entries()
-        const directories = entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
-        const items = entries.flatMap((entry) => (entry.type === "document" ? (entry.info.skills ?? []) : []))
-        for (const directory of directories) {
-          draft.source(
-            new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
-          )
-          draft.source(
-            new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }),
-          )
+    const skill = yield* SkillV2.Service
+    const transform = yield* skill.transform()
+    const entries = yield* config.entries()
+    const directories = entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
+    const items = entries.flatMap((entry) => (entry.type === "document" ? (entry.info.skills ?? []) : []))
+
+    yield* transform((editor) => {
+      for (const directory of directories) {
+        editor.source(
+          new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
+        )
+        editor.source(
+          new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }),
+        )
+      }
+      for (const item of items) {
+        if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
+          editor.source(new SkillV2.UrlSource({ type: "url", url: item }))
+          continue
         }
-        for (const item of items) {
-          if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
-            draft.source(new SkillV2.UrlSource({ type: "url", url: item }))
-            continue
-          }
-          const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
-          draft.source(
-            new SkillV2.DirectorySource({
-              type: "directory",
-              path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded)),
-            }),
-          )
-        }
-      }),
-    )
+        const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
+        editor.source(
+          new SkillV2.DirectorySource({
+            type: "directory",
+            path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded)),
+          }),
+        )
+      }
+    })
   }),
 })

packages/core/src/credential.ts

@@ -29,33 +29,33 @@ export class Key extends Schema.Class<Key>("Credential.Key")({
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 }) {}
 
-export const Value = Schema.Union([OAuth, Key])
+export const Info = Schema.Union([OAuth, Key])
   .pipe(Schema.toTaggedUnion("type"))
-  .annotate({ identifier: "Credential.Value" })
-export type Value = Schema.Schema.Type<typeof Value>
+  .annotate({ identifier: "Credential.Info" })
+export type Info = Schema.Schema.Type<typeof Info>
 
-export class Info extends Schema.Class<Info>("Credential.Info")({
+export class Stored extends Schema.Class<Stored>("Credential.Stored")({
   id: ID,
   integrationID: IntegrationSchema.ID,
   label: Schema.String,
-  value: Value,
+  value: Info,
 }) {}
 
 export interface Interface {
   /** Returns every stored credential. */
-  readonly all: () => Effect.Effect<Info[]>
+  readonly all: () => Effect.Effect<Stored[]>
   /** Returns stored credentials belonging to one integration. */
-  readonly list: (integrationID: IntegrationSchema.ID) => Effect.Effect<Info[]>
+  readonly list: (integrationID: IntegrationSchema.ID) => Effect.Effect<Stored[]>
   /** Returns one stored credential by ID. */
-  readonly get: (id: ID) => Effect.Effect<Info | undefined>
+  readonly get: (id: ID) => Effect.Effect<Stored | undefined>
   /** Replaces any credential for an integration and returns the new record. */
   readonly create: (input: {
     readonly integrationID: IntegrationSchema.ID
-    readonly value: Value
+    readonly value: Info
     readonly label?: string
-  }) => Effect.Effect<Info>
+  }) => Effect.Effect<Stored>
   /** Updates the label or secret value of a stored credential. */
-  readonly update: (id: ID, updates: Partial<Pick<Info, "label" | "value">>) => Effect.Effect<void>
+  readonly update: (id: ID, updates: Partial<Pick<Stored, "label" | "value">>) => Effect.Effect<void>
   /** Removes a stored credential. */
   readonly remove: (id: ID) => Effect.Effect<void>
 }
@@ -66,10 +66,10 @@ export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const { db } = yield* Database.Service
-    const decode = Schema.decodeUnknownSync(Value)
+    const decode = Schema.decodeUnknownSync(Info)
     const stored = (row: typeof CredentialTable.$inferSelect) => {
       if (!row.integration_id) return
-      return new Info({
+      return new Stored({
         id: row.id,
         integrationID: row.integration_id,
         label: row.label,
@@ -106,7 +106,7 @@ export const layer = Layer.effect(
         return row ? stored(row) : undefined
       }),
       create: Effect.fn("Credential.create")(function* (input) {
-        const credential = new Info({
+        const credential = new Stored({
           id: ID.create(),
           integrationID: input.integrationID,
           label: input.label ?? "default",

packages/core/src/credential/sql.ts

@@ -7,7 +7,7 @@ export const CredentialTable = sqliteTable("credential", {
   id: text().$type<Credential.ID>().primaryKey(),
   integration_id: text().$type<IntegrationSchema.ID>(),
   label: text().notNull(),
-  value: text({ mode: "json" }).$type<Credential.Value>().notNull(),
+  value: text({ mode: "json" }).$type<Credential.Info>().notNull(),
   connector_id: text(),
   method_id: text(),
   active: integer({ mode: "boolean" }),

packages/core/src/database/migration.gen.ts

@@ -37,8 +37,5 @@ export const migrations = (
     import("./migration/20260611035744_credential"),
     import("./migration/20260611192811_lush_chimera"),
     import("./migration/20260612174303_project_dir_strategy"),
-    import("./migration/20260622142730_simplify_session_context_epoch"),
-    import("./migration/20260622170816_reset_v2_session_state"),
-    import("./migration/20260622202450_simplify_session_input"),
   ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260622142730_simplify_session_context_epoch.ts

@@ -1,13 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260622142730_simplify_session_context_epoch",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`agent\`;`)
-      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`replacement_seq\`;`)
-      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`revision\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration

packages/core/src/database/migration/20260622170816_reset_v2_session_state.ts

@@ -1,17 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260622170816_reset_v2_session_state",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`)
-      yield* tx.run(`DELETE FROM \`session_input\`;`)
-      yield* tx.run(`DELETE FROM \`session_message\`;`)
-      yield* tx.run(`DELETE FROM \`event\`;`)
-      yield* tx.run(`DELETE FROM \`event_sequence\`;`)
-      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL WHERE \`workspace_id\` IS NOT NULL;`)
-      yield* tx.run(`DELETE FROM \`workspace\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration

packages/core/src/database/migration/20260622202450_simplify_session_input.ts

@@ -1,17 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260622202450_simplify_session_input",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`)
-      yield* tx.run(`DELETE FROM \`session_input\`;`)
-      yield* tx.run(`DELETE FROM \`session_message\`;`)
-      yield* tx.run(`DELETE FROM \`event\`;`)
-      yield* tx.run(`DELETE FROM \`event_sequence\`;`)
-      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL WHERE \`workspace_id\` IS NOT NULL;`)
-      yield* tx.run(`DELETE FROM \`workspace\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration

packages/core/src/database/schema.gen.ts

@@ -149,8 +149,11 @@ export default {
         CREATE TABLE \`session_context_epoch\` (
           \`session_id\` text PRIMARY KEY,
           \`baseline\` text NOT NULL,
+          \`agent\` text DEFAULT 'build' NOT NULL,
           \`snapshot\` text NOT NULL,
           \`baseline_seq\` integer NOT NULL,
+          \`replacement_seq\` integer,
+          \`revision\` integer DEFAULT 0 NOT NULL,
           CONSTRAINT \`fk_session_context_epoch_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
         );
       `)

packages/core/src/event.ts

@@ -5,7 +5,7 @@ import { and, asc, eq, gt } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
-import { externalID, type ExternalID, withStatics } from "./schema"
+import { externalID, type ExternalID, NonNegativeInt, withStatics } from "./schema"
 import { Identifier } from "./util/identifier"
 import { LayerNode } from "./effect/layer-node"
 import { isDeepStrictEqual } from "node:util"
@@ -19,9 +19,16 @@ export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(
 )
 export type ID = typeof ID.Type
 
+/**
+ * Durable aggregate continuation position for embedded replay streams.
+ * TODO: Decide whether a future HTTP / SDK surface should expose an opaque cursor instead.
+ */
+export const Cursor = NonNegativeInt.pipe(Schema.brand("EventV2.Cursor"))
+export type Cursor = typeof Cursor.Type
+
 export type Definition<Type extends string = string, DataSchema extends Schema.Top = Schema.Top> = {
   readonly type: Type
-  readonly durable?: {
+  readonly sync?: {
     readonly version: number
     readonly aggregate: string
   }
@@ -34,31 +41,22 @@ export type Payload<D extends Definition = Definition> = {
   readonly id: ID
   readonly type: D["type"]
   readonly data: Data<D>
-  readonly durable?: {
-    readonly aggregateID: string
-    readonly seq: number
-    readonly version: number
-  }
+  /** Durable aggregate order, populated while synchronized events are projected. */
+  readonly seq?: number
+  readonly version?: number
   readonly location?: Location.Ref
   readonly metadata?: Record<string, unknown>
+  /** Internal replay marker for projectors that own non-replicated operational state. */
+  readonly replay?: boolean
 }
 
-export type Subscriber<D extends Definition = Definition> = (event: Payload<D>) => Effect.Effect<void>
+export type Projector<D extends Definition = Definition> = (event: Payload<D>) => Effect.Effect<void>
+type AnyProjector = (event: Payload) => Effect.Effect<void>
+export type CommitGuard = (event: Payload) => Effect.Effect<void>
+export type Listener = (event: Payload) => Effect.Effect<void>
+export type Sync = (event: Payload) => Effect.Effect<void>
 export type Unsubscribe = Effect.Effect<void>
 
-export const latestSequence = Effect.fn("EventV2.latestSequence")(function* (
-  db: Database.Interface["db"],
-  aggregateID: string,
-) {
-  const row = yield* db
-    .select({ seq: EventSequenceTable.seq })
-    .from(EventSequenceTable)
-    .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-    .get()
-    .pipe(Effect.orDie)
-  return row?.seq ?? -1
-})
-
 export type SerializedEvent = {
   readonly id: ID
   readonly type: string
@@ -67,8 +65,13 @@ export type SerializedEvent = {
   readonly data: Record<string, unknown>
 }
 
-export class InvalidDurableEventError extends Schema.TaggedErrorClass<InvalidDurableEventError>()(
-  "EventV2.InvalidDurableEvent",
+export type CursorEvent<E extends Payload = Payload> = {
+  readonly cursor: Cursor
+  readonly event: E
+}
+
+export class InvalidSyncEventError extends Schema.TaggedErrorClass<InvalidSyncEventError>()(
+  "EventV2.InvalidSyncEvent",
   {
     type: Schema.String,
     message: Schema.String,
@@ -80,11 +83,19 @@ export function versionedType(type: string, version: number) {
 }
 
 export const registry = new Map<string, Definition>()
-const durableRegistry = new Map<string, Definition>()
+type SyncDefinition = Definition & {
+  readonly sync: NonNullable<Definition["sync"]>
+  readonly encode: (data: unknown) => unknown
+  readonly decode: (data: unknown) => unknown
+}
+const syncRegistry = new Map<string, SyncDefinition>()
+
+// Synchronized events cross a JSON boundary, so their data schemas must encode and decode without services.
+const syncCodec = (definition: Definition) => definition.data as Schema.Codec<unknown, unknown, never, never>
 
 export function define<const Type extends string, Fields extends Schema.Struct.Fields>(input: {
   readonly type: Type
-  readonly durable?: {
+  readonly sync?: {
     readonly version: number
     readonly aggregate: string
   }
@@ -95,25 +106,28 @@ export function define<const Type extends string, Fields extends Schema.Struct.F
     id: ID,
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
     type: Schema.Literal(input.type),
-    durable: Schema.optional(Schema.Struct({ aggregateID: Schema.String, seq: Schema.Number, version: Schema.Number })),
+    version: Schema.optional(Schema.Number),
     location: Schema.optional(Location.Ref),
     data: Data,
   }).annotate({ identifier: input.type })
 
   const definition = Object.assign(Payload, {
     type: input.type,
-    ...(input.durable === undefined ? {} : { durable: input.durable }),
+    ...(input.sync === undefined ? {} : { sync: input.sync }),
     data: Data,
   })
   const existing = registry.get(input.type)
-  if (
-    input.durable === undefined ||
-    existing?.durable === undefined ||
-    input.durable.version >= existing.durable.version
-  ) {
+  if (input.sync === undefined || existing?.sync === undefined || input.sync.version >= existing.sync.version) {
     registry.set(input.type, definition)
   }
-  if (input.durable) durableRegistry.set(versionedType(input.type, input.durable.version), definition)
+  if (input.sync)
+    syncRegistry.set(
+      versionedType(input.type, input.sync.version),
+      Object.assign(definition, {
+        encode: Schema.encodeUnknownSync(syncCodec(definition)),
+        decode: Schema.decodeUnknownSync(syncCodec(definition)),
+      }) as SyncDefinition,
+    )
   return definition as Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> &
     Definition<Type, Schema.Struct<Fields>>
 }
@@ -126,7 +140,7 @@ export interface PublishOptions {
   readonly id?: ID
   readonly metadata?: Record<string, unknown>
   readonly location?: Location.Ref
-  /** Local operational projection committed atomically with a new durable event. Not replayed or serialized. */
+  /** Local operational projection committed atomically with a new synchronized event. Not replayed or serialized. */
   readonly commit?: (seq: number) => Effect.Effect<void>
 }
 
@@ -138,10 +152,14 @@ export interface Interface {
   ) => Effect.Effect<Payload<D>>
   readonly subscribe: <D extends Definition>(definition: D) => Stream.Stream<Payload<D>>
   readonly all: () => Stream.Stream<Payload>
-  readonly durable: (input: { readonly aggregateID: string; readonly after?: number }) => Stream.Stream<Payload>
-  /** @deprecated Use `all()` and consume the returned stream. */
-  readonly listen: (listener: Subscriber) => Effect.Effect<Unsubscribe>
-  readonly project: <D extends Definition>(definition: D, projector: Subscriber<D>) => Effect.Effect<void>
+  readonly aggregateEvents: (input: {
+    readonly aggregateID: string
+    readonly after?: Cursor
+  }) => Stream.Stream<CursorEvent>
+  readonly sync: (handler: Sync) => Effect.Effect<Unsubscribe>
+  readonly listen: (listener: Listener) => Effect.Effect<Unsubscribe>
+  readonly beforeCommit: (guard: CommitGuard) => Effect.Effect<void>
+  readonly project: <D extends Definition>(definition: D, projector: Projector<D>) => Effect.Effect<void>
   readonly replay: (
     event: SerializedEvent,
     options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },
@@ -164,37 +182,37 @@ export const layerWith = (options?: LayerOptions) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
-      const pubsub = {
-        all: yield* PubSub.unbounded<Payload>(),
-        durable: new Map<string, Set<PubSub.PubSub<void>>>(),
-        typed: new Map<string, PubSub.PubSub<Payload>>(),
-      }
-      const projectors = new Map<string, Subscriber[]>()
-      const listeners = new Array<Subscriber>()
+      const all = yield* PubSub.unbounded<Payload>()
+      const synchronized = new Map<string, Set<PubSub.PubSub<void>>>()
+      const typed = new Map<string, PubSub.PubSub<Payload>>()
+      const projectors = new Map<string, AnyProjector[]>()
+      const commitGuards = new Array<CommitGuard>()
+      const listeners = new Array<Listener>()
+      const syncHandlers = new Array<Sync>()
       const { db } = yield* Database.Service
 
       const getOrCreate = (definition: Definition) =>
         Effect.gen(function* () {
-          const existing = pubsub.typed.get(definition.type)
+          const existing = typed.get(definition.type)
           if (existing) return existing
-          const created = yield* PubSub.unbounded<Payload>()
-          pubsub.typed.set(definition.type, created)
-          return created
+          const pubsub = yield* PubSub.unbounded<Payload>()
+          typed.set(definition.type, pubsub)
+          return pubsub
         })
 
       yield* Effect.addFinalizer(() =>
         Effect.gen(function* () {
-          yield* PubSub.shutdown(pubsub.all)
+          yield* PubSub.shutdown(all)
           yield* Effect.forEach(
-            pubsub.durable.values(),
+            synchronized.values(),
             (pubsubs) => Effect.forEach(pubsubs, PubSub.shutdown, { discard: true }),
             { discard: true },
           )
-          yield* Effect.forEach(pubsub.typed.values(), PubSub.shutdown, { discard: true })
+          yield* Effect.forEach(typed.values(), PubSub.shutdown, { discard: true })
         }),
       )
 
-      function commitDurableEvent(
+      function commitSyncEvent(
         event: Payload,
         input?: {
           readonly seq: number
@@ -206,20 +224,28 @@ export const layerWith = (options?: LayerOptions) =>
       ) {
         return Effect.gen(function* () {
           const definition = registry.get(event.type)
-          const durable = definition?.durable
-          if (durable) {
-            const aggregateID = (event.data as Record<string, unknown>)[durable.aggregate]
+          const sync = definition?.sync
+          if (sync) {
+            if (event.version !== sync.version) {
+              yield* Effect.die(
+                new InvalidSyncEventError({
+                  type: event.type,
+                  message: `Expected event version ${sync.version}, got ${event.version}`,
+                }),
+              )
+            }
+            const aggregateID = (event.data as Record<string, unknown>)[sync.aggregate]
             if (typeof aggregateID !== "string") {
               yield* Effect.die(
-                new InvalidDurableEventError({
+                new InvalidSyncEventError({
                   type: event.type,
-                  message: `Expected string aggregate field ${durable.aggregate}`,
+                  message: `Expected string aggregate field ${sync.aggregate}`,
                 }),
               )
             } else {
               if (input && input.aggregateID !== aggregateID) {
                 yield* Effect.die(
-                  new InvalidDurableEventError({
+                  new InvalidSyncEventError({
                     type: event.type,
                     message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`,
                   }),
@@ -239,12 +265,12 @@ export const layerWith = (options?: LayerOptions) =>
                             .get()
                             .pipe(Effect.orDie)
                           const latest = row?.seq ?? -1
-                          const encoded = Schema.encodeUnknownSync(
-                            definition.data as Schema.Codec<unknown, unknown, never, never>,
-                          )(event.data) as Record<string, unknown>
+                          const encoded = syncRegistry
+                            .get(versionedType(definition.type, sync.version))!
+                            .encode(event.data) as Record<string, unknown>
                           if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
                             yield* Effect.die(
-                              new InvalidDurableEventError({
+                              new InvalidSyncEventError({
                                 type: event.type,
                                 message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`,
                               }),
@@ -259,7 +285,7 @@ export const layerWith = (options?: LayerOptions) =>
                               .pipe(Effect.orDie)
                             if (
                               stored?.id === event.id &&
-                              stored.type === versionedType(definition.type, durable.version) &&
+                              stored.type === versionedType(definition.type, sync.version) &&
                               isDeepStrictEqual(stored.data, encoded)
                             ) {
                               if (input.ownerID && row?.ownerID == null) {
@@ -273,7 +299,7 @@ export const layerWith = (options?: LayerOptions) =>
                               return
                             }
                             yield* Effect.die(
-                              new InvalidDurableEventError({
+                              new InvalidSyncEventError({
                                 type: event.type,
                                 message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`,
                               }),
@@ -285,7 +311,7 @@ export const layerWith = (options?: LayerOptions) =>
                           const seq = input?.seq ?? latest + 1
                           if (input && seq !== latest + 1) {
                             yield* Effect.die(
-                              new InvalidDurableEventError({
+                              new InvalidSyncEventError({
                                 type: event.type,
                                 message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`,
                               }),
@@ -299,17 +325,16 @@ export const layerWith = (options?: LayerOptions) =>
                             .pipe(Effect.orDie)
                           if (stored)
                             yield* Effect.die(
-                              new InvalidDurableEventError({
+                              new InvalidSyncEventError({
                                 type: event.type,
                                 message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`,
                               }),
                             )
-                          const committed = {
-                            ...event,
-                            durable: { aggregateID, seq, version: durable.version },
-                          } as Payload
+                          for (const guard of commitGuards) {
+                            yield* guard(event)
+                          }
                           for (const projector of list) {
-                            yield* projector(committed)
+                            yield* projector({ ...event, seq } as Payload)
                           }
                           if (commit) yield* commit(seq)
                           yield* db
@@ -331,7 +356,7 @@ export const layerWith = (options?: LayerOptions) =>
                                 id: event.id,
                                 aggregate_id: aggregateID,
                                 seq,
-                                type: versionedType(definition.type, durable.version),
+                                type: versionedType(definition.type, sync.version),
                                 data: encoded,
                               },
                             ])
@@ -344,8 +369,8 @@ export const layerWith = (options?: LayerOptions) =>
                     .pipe(Effect.orDie)
                   if (committed) {
                     yield* Effect.forEach(
-                      pubsub.durable.get(committed.aggregateID) ?? [],
-                      (wake) => PubSub.publish(wake, undefined),
+                      synchronized.get(committed.aggregateID) ?? [],
+                      (pubsub) => PubSub.publish(pubsub, undefined),
                       { discard: true },
                     )
                   }
@@ -359,25 +384,19 @@ export const layerWith = (options?: LayerOptions) =>
 
       function publishEvent<D extends Definition>(event: Payload<D>, commit?: PublishOptions["commit"]) {
         return Effect.gen(function* () {
-          const definition = registry.get(event.type)
-          if (!definition?.durable && commit)
+          const durable = registry.get(event.type)?.sync !== undefined
+          if (!durable && commit)
             return yield* Effect.die(
-              new InvalidDurableEventError({
+              new InvalidSyncEventError({
                 type: event.type,
-                message: "Local commit hooks require a durable event",
+                message: "Local commit hooks require a synchronized event",
               }),
             )
-          if (definition?.durable) {
-            const committed = yield* commitDurableEvent(event as Payload, undefined, commit)
+          if (durable) {
+            const committed = yield* commitSyncEvent(event as Payload, undefined, commit)
             if (committed) {
-              event = {
-                ...event,
-                durable: {
-                  aggregateID: committed.aggregateID,
-                  seq: committed.seq,
-                  version: definition.durable.version,
-                },
-              }
+              event = { ...event, seq: committed.seq }
+              yield* Effect.forEach(syncHandlers, (sync) => observe(event as Payload, "sync", sync), { discard: true })
               yield* notify(event as Payload, true)
               return event
             }
@@ -387,11 +406,12 @@ export const layerWith = (options?: LayerOptions) =>
         })
       }
 
-      const observe = (event: Payload, observer: (event: Payload) => Effect.Effect<void>) =>
+      const observe = (event: Payload, kind: "sync" | "listener", observer: (event: Payload) => Effect.Effect<void>) =>
         Effect.suspend(() => observer(event)).pipe(
           Effect.catchCauseIf(
             (cause) => !Cause.hasInterrupts(cause),
-            (cause) => Effect.logError("Event listener failed", { eventID: event.id, eventType: event.type, cause }),
+            (cause) =>
+              Effect.logError("Event observer failed", { eventID: event.id, eventType: event.type, kind, cause }),
           ),
         )
 
@@ -399,12 +419,12 @@ export const layerWith = (options?: LayerOptions) =>
         return Effect.gen(function* () {
           yield* Effect.forEach(
             listeners,
-            (listener) => (isolateListeners ? observe(event, listener) : listener(event)),
+            (listener) => (isolateListeners ? observe(event, "listener", listener) : listener(event)),
             { discard: true },
           )
-          const typed = pubsub.typed.get(event.type)
-          if (typed) yield* PubSub.publish(typed, event)
-          yield* PubSub.publish(pubsub.all, event)
+          const pubsub = typed.get(event.type)
+          if (pubsub) yield* PubSub.publish(pubsub, event)
+          yield* PubSub.publish(all, event)
         })
       }
 
@@ -421,6 +441,7 @@ export const layerWith = (options?: LayerOptions) =>
               id: options?.id ?? ID.create(),
               ...(options?.metadata ? { metadata: options.metadata } : {}),
               type: definition.type,
+              ...(definition.sync === undefined ? {} : { version: definition.sync.version }),
               ...(location ? { location } : {}),
               data,
             } as Payload<D>,
@@ -434,37 +455,27 @@ export const layerWith = (options?: LayerOptions) =>
         options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },
       ) {
         return Effect.gen(function* () {
-          const definition = durableRegistry.get(event.type)
-          if (!definition?.durable) {
+          const definition = syncRegistry.get(event.type)
+          if (!definition) {
             yield* Effect.die(
-              new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` }),
+              new InvalidSyncEventError({ type: event.type, message: `Unknown sync event type ${event.type}` }),
             )
           } else {
             const payload = {
               id: event.id,
               type: definition.type,
-              data: Schema.decodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)(
-                event.data,
-              ),
+              version: definition.sync.version,
+              data: definition.decode(event.data),
+              replay: true,
             } as Payload
-            const committed = yield* commitDurableEvent(payload, {
+            const committed = yield* commitSyncEvent(payload, {
               seq: event.seq,
               aggregateID: event.aggregateID,
               ownerID: options?.ownerID,
               strictOwner: options?.strictOwner,
             })
             if (committed && options?.publish) {
-              yield* notify(
-                {
-                  ...payload,
-                  durable: {
-                    aggregateID: committed.aggregateID,
-                    seq: committed.seq,
-                    version: definition.durable.version,
-                  },
-                },
-                true,
-              )
+              yield* notify({ ...payload, seq: committed.seq }, true)
             }
           }
         })
@@ -479,7 +490,7 @@ export const layerWith = (options?: LayerOptions) =>
           if (!source) return undefined
           if (events.some((event) => event.aggregateID !== source)) {
             yield* Effect.die(
-              new InvalidDurableEventError({
+              new InvalidSyncEventError({
                 type: events[0]?.type ?? "unknown",
                 message: "Replay events must belong to the same aggregate",
               }),
@@ -490,7 +501,7 @@ export const layerWith = (options?: LayerOptions) =>
             const seq = start + index
             if (event.seq !== seq) {
               yield* Effect.die(
-                new InvalidDurableEventError({
+                new InvalidSyncEventError({
                   type: event.type,
                   message: `Replay sequence mismatch at index ${index}: expected ${seq}, got ${event.seq}`,
                 }),
@@ -529,18 +540,22 @@ export const layerWith = (options?: LayerOptions) =>
           Stream.map((event) => event as Payload<D>),
         )
 
-      const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(pubsub.all)
+      const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(all)
 
-      const decodeSerializedEvent = (event: SerializedEvent): Payload => {
-        const definition = durableRegistry.get(event.type)
-        if (!definition?.durable) {
-          throw new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` })
+      const decodeSerializedEvent = (event: SerializedEvent): CursorEvent => {
+        const definition = syncRegistry.get(event.type)
+        if (!definition) {
+          throw new InvalidSyncEventError({ type: event.type, message: `Unknown sync event type ${event.type}` })
         }
         return {
-          id: event.id,
-          type: definition.type,
-          durable: { aggregateID: event.aggregateID, seq: event.seq, version: definition.durable.version },
-          data: Schema.decodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)(event.data),
+          cursor: Cursor.make(event.seq),
+          event: {
+            id: event.id,
+            type: definition.type,
+            version: definition.sync.version,
+            seq: event.seq,
+            data: definition.decode(event.data),
+          },
         }
       }
 
@@ -568,40 +583,43 @@ export const layerWith = (options?: LayerOptions) =>
           ),
         )
 
-      const subscribeDurable = (aggregateID: string) =>
+      const subscribeSynchronized = (aggregateID: string) =>
         Effect.gen(function* () {
-          const wake = yield* PubSub.sliding<void>(1)
-          const subscription = yield* PubSub.subscribe(wake)
+          const pubsub = yield* PubSub.sliding<void>(1)
+          const subscription = yield* PubSub.subscribe(pubsub)
           yield* Effect.acquireRelease(
             Effect.sync(() => {
-              const wakes = pubsub.durable.get(aggregateID) ?? new Set()
-              wakes.add(wake)
-              pubsub.durable.set(aggregateID, wakes)
+              const pubsubs = synchronized.get(aggregateID) ?? new Set()
+              pubsubs.add(pubsub)
+              synchronized.set(aggregateID, pubsubs)
             }),
             () =>
               Effect.sync(() => {
-                const wakes = pubsub.durable.get(aggregateID)
-                wakes?.delete(wake)
-                if (wakes?.size === 0) pubsub.durable.delete(aggregateID)
-              }).pipe(Effect.andThen(PubSub.shutdown(wake))),
+                const pubsubs = synchronized.get(aggregateID)
+                pubsubs?.delete(pubsub)
+                if (pubsubs?.size === 0) synchronized.delete(aggregateID)
+              }).pipe(Effect.andThen(PubSub.shutdown(pubsub))),
           )
           return subscription
         })
 
-      const durable = (input: { readonly aggregateID: string; readonly after?: number }): Stream.Stream<Payload> =>
+      const streamEvents = (input: {
+        readonly aggregateID: string
+        readonly after?: Cursor
+      }): Stream.Stream<CursorEvent> =>
         Stream.unwrap(
           Effect.gen(function* () {
-            const wakes = yield* subscribeDurable(input.aggregateID)
-            let sequence = input.after ?? -1
-            const read = Effect.suspend(() => readAfter(input.aggregateID, sequence)).pipe(
+            const synchronized = yield* subscribeSynchronized(input.aggregateID)
+            let cursor = input.after ?? -1
+            const read = Effect.suspend(() => readAfter(input.aggregateID, cursor)).pipe(
               Effect.tap((events) =>
                 Effect.sync(() => {
-                  sequence = events.at(-1)?.durable?.seq ?? sequence
+                  cursor = events.at(-1)?.cursor ?? cursor
                 }),
               ),
             )
             const historical = yield* read
-            const live = Stream.fromSubscription(wakes).pipe(
+            const live = Stream.fromSubscription(synchronized).pipe(
               Stream.mapEffect(() => read),
               Stream.flattenIterable,
             )
@@ -609,7 +627,7 @@ export const layerWith = (options?: LayerOptions) =>
           }),
         )
 
-      const listen = (listener: Subscriber): Effect.Effect<Unsubscribe> =>
+      const listen = (listener: Listener): Effect.Effect<Unsubscribe> =>
         Effect.sync(() => {
           listeners.push(listener)
           return Effect.sync(() => {
@@ -618,7 +636,21 @@ export const layerWith = (options?: LayerOptions) =>
           })
         })
 
-      const project = <D extends Definition>(definition: D, projector: Subscriber<D>): Effect.Effect<void> =>
+      const sync = (handler: Sync): Effect.Effect<Unsubscribe> =>
+        Effect.sync(() => {
+          syncHandlers.push(handler)
+          return Effect.sync(() => {
+            const index = syncHandlers.indexOf(handler)
+            if (index >= 0) syncHandlers.splice(index, 1)
+          })
+        })
+
+      const beforeCommit = (guard: CommitGuard): Effect.Effect<void> =>
+        Effect.sync(() => {
+          commitGuards.push(guard)
+        })
+
+      const project = <D extends Definition>(definition: D, projector: Projector<D>): Effect.Effect<void> =>
         Effect.sync(() => {
           const list = projectors.get(definition.type) ?? []
           list.push((event) => projector(event as Payload<D>))
@@ -629,8 +661,10 @@ export const layerWith = (options?: LayerOptions) =>
         publish,
         subscribe,
         all: streamAll,
-        durable,
+        aggregateEvents: streamEvents,
+        sync,
         listen,
+        beforeCommit,
         project,
         replay,
         replayAll,

packages/core/src/filesystem.ts

@@ -123,6 +123,6 @@ const baseLayer = Layer.effect(
   }),
 )
 
-export const layer = baseLayer.pipe(Layer.provide(FileSystemSearch.locationLayer), Layer.provide(FSUtil.defaultLayer))
+export const layer = baseLayer.pipe(Layer.provide(FileSystemSearch.defaultLayer), Layer.provide(FSUtil.defaultLayer))
 
 export const locationLayer = layer

packages/core/src/filesystem/search.ts

@@ -232,6 +232,6 @@ export const fffLayer = Layer.effect(
   }),
 )
 
-export const locationLayer = Layer.unwrap(
+export const defaultLayer = Layer.unwrap(
   Effect.sync(() => (Flag.OPENCODE_DISABLE_FFF || !Fff.available() ? ripgrepLayer : fffLayer)),
 )

packages/core/src/integration.ts

@@ -1,19 +1,7 @@
 export * as Integration from "./integration"
 
-import {
-  Cause,
-  Clock,
-  Context,
-  Duration,
-  Effect,
-  Exit,
-  Layer,
-  Schedule,
-  Schema,
-  Scope,
-  SynchronizedRef,
-  Types,
-} from "effect"
+import { Cause, Clock, Context, Duration, Effect, Exit, Layer, Schedule, Schema, Scope, SynchronizedRef } from "effect"
+import { castDraft, enableMapSet, type Draft } from "immer"
 import { Credential } from "./credential"
 import { IntegrationSchema } from "./integration/schema"
 import { withStatics } from "./schema"
@@ -54,14 +42,12 @@ export const SelectPrompt = Schema.Struct({
   type: Schema.Literal("select"),
   key: Schema.String,
   message: Schema.String,
-  options: Schema.mutable(
-    Schema.Array(
-      Schema.Struct({
-        label: Schema.String,
-        value: Schema.String,
-        hint: Schema.optional(Schema.String),
-      }),
-    ),
+  options: Schema.Array(
+    Schema.Struct({
+      label: Schema.String,
+      value: Schema.String,
+      hint: Schema.optional(Schema.String),
+    }),
   ),
   when: Schema.optional(When),
 }).annotate({ identifier: "Integration.SelectPrompt" })
@@ -74,7 +60,7 @@ export const OAuthMethod = Schema.Struct({
   id: MethodID,
   type: Schema.Literal("oauth"),
   label: Schema.String,
-  prompts: Schema.optional(Schema.mutable(Schema.Array(Prompt))),
+  prompts: Schema.optional(Schema.Array(Prompt)),
 }).annotate({ identifier: "Integration.OAuthMethod" })
 export type OAuthMethod = typeof OAuthMethod.Type
 
@@ -86,7 +72,7 @@ export type KeyMethod = typeof KeyMethod.Type
 
 export const EnvMethod = Schema.Struct({
   type: Schema.Literal("env"),
-  names: Schema.mutable(Schema.Array(Schema.String)),
+  names: Schema.Array(Schema.String),
 }).annotate({ identifier: "Integration.EnvMethod" })
 export type EnvMethod = typeof EnvMethod.Type
 
@@ -96,8 +82,8 @@ export type Method = typeof Method.Type
 export class Info extends Schema.Class<Info>("Integration.Info")({
   id: ID,
   name: Schema.String,
-  methods: Schema.mutable(Schema.Array(Method)),
-  connections: Schema.mutable(Schema.Array(IntegrationConnection.Info)),
+  methods: Schema.Array(Method),
+  connections: Schema.Array(IntegrationConnection.Info),
 }) {}
 
 export type Inputs = Readonly<{ [key: string]: string }>
@@ -108,11 +94,11 @@ export type OAuthAuthorization = {
 } & (
   | {
       readonly mode: "auto"
-      readonly callback: Effect.Effect<Credential.Value, unknown>
+      readonly callback: Effect.Effect<Credential.Info, unknown>
     }
   | {
       readonly mode: "code"
-      readonly callback: (code: string) => Effect.Effect<Credential.Value, unknown>
+      readonly callback: (code: string) => Effect.Effect<Credential.Info, unknown>
     }
 )
 
@@ -186,19 +172,19 @@ export type Ref = {
 }
 
 type Entry = {
-  ref: Types.DeepMutable<Ref>
-  methods: Types.DeepMutable<Method>[]
-  implementations: Map<MethodID, Types.DeepMutable<OAuthImplementation>>
+  ref: Ref
+  methods: Method[]
+  implementations: Map<MethodID, OAuthImplementation>
 }
 
 type Data = {
   integrations: Map<ID, Entry>
 }
 
-export type Draft = {
+export type Editor = {
   list: () => readonly Ref[]
   get: (id: ID) => Ref | undefined
-  update: (id: ID, update: (integration: Types.DeepMutable<Ref>) => void) => void
+  update: (id: ID, update: (integration: Draft<Ref>) => void) => void
   remove: (id: ID) => void
   method: {
     list: (integrationID: ID) => readonly Method[]
@@ -207,13 +193,18 @@ export type Draft = {
   }
 }
 
-export interface Interface extends State.Transformable<Draft> {
+export interface Interface {
   /** Registers a scoped transform over the integration registry. */
+  readonly transform: State.Interface<Data, Editor>["transform"]
+  /** Registers and immediately applies a scoped integration registry update. */
+  readonly update: State.Interface<Data, Editor>["update"]
   /** Returns one integration with its methods and current connections. */
   readonly get: (id: ID) => Effect.Effect<Info | undefined>
   /** Returns all integrations with their methods and current connections. */
   readonly list: () => Effect.Effect<Info[]>
   readonly connection: {
+    /** Returns active connections for every registered or credential-backed integration. */
+    readonly list: () => Effect.Effect<Map<ID, IntegrationConnection.Info>>
     /** Returns the active connection for one integration. */
     readonly forIntegration: (id: ID) => Effect.Effect<IntegrationConnection.Info | undefined>
     /** Runs a key method and stores the resulting credential. */
@@ -239,7 +230,7 @@ export interface Interface extends State.Transformable<Draft> {
     /** Updates a stored credential exposed as a connection. */
     readonly update: (
       credentialID: Credential.ID,
-      updates: Partial<Pick<Credential.Info, "label">>,
+      updates: Partial<Pick<Credential.Stored, "label">>,
     ) => Effect.Effect<void>
     /** Removes a stored credential connection. */
     readonly remove: (credentialID: Credential.ID) => Effect.Effect<void>
@@ -261,6 +252,8 @@ export interface Interface extends State.Transformable<Draft> {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Integration") {}
 
+enableMapSet()
+
 const attemptLifetime = Duration.toMillis(Duration.minutes(10))
 const terminalRetention = Duration.toMillis(Duration.minutes(1))
 const scrubInterval = Duration.seconds(30)
@@ -291,17 +284,15 @@ export const locationLayer = Layer.effect(
     const events = yield* EventV2.Service
     const scope = yield* Scope.Scope
     const attempts = SynchronizedRef.makeUnsafe(new Map<AttemptID, AttemptEntry>())
-    const state = State.create<Data, Draft>({
+    const state = State.create<Data, Editor>({
       initial: () => ({ integrations: new Map<ID, Entry>() }),
-      draft: (draft) => ({
+      editor: (draft) => ({
         list: () => Array.from(draft.integrations.values(), (entry) => entry.ref) as Ref[],
         get: (id) => draft.integrations.get(id)?.ref as Ref | undefined,
         update: (id, update) => {
-          const current = draft.integrations.get(id) ?? {
-            ref: { id, name: id },
-            methods: [],
-            implementations: new Map(),
-          }
+          const current =
+            draft.integrations.get(id) ??
+            castDraft({ ref: { id, name: id } as Ref, methods: [], implementations: new Map() })
           if (!draft.integrations.has(id)) draft.integrations.set(id, current)
           update(current.ref)
           current.ref.id = id
@@ -310,14 +301,16 @@ export const locationLayer = Layer.effect(
         method: {
           list: (integrationID) => (draft.integrations.get(integrationID)?.methods as Method[] | undefined) ?? [],
           update: (implementation) => {
-            const current = draft.integrations.get(implementation.integrationID) ?? {
-              ref: {
-                id: implementation.integrationID,
-                name: implementation.integrationID,
-              },
-              methods: [],
-              implementations: new Map<MethodID, Types.DeepMutable<OAuthImplementation>>(),
-            }
+            const current =
+              draft.integrations.get(implementation.integrationID) ??
+              castDraft({
+                ref: {
+                  id: implementation.integrationID,
+                  name: implementation.integrationID,
+                } as Ref,
+                methods: [],
+                implementations: new Map<MethodID, OAuthImplementation>(),
+              })
             if (!draft.integrations.has(implementation.integrationID)) {
               draft.integrations.set(implementation.integrationID, current)
             }
@@ -326,13 +319,10 @@ export const locationLayer = Layer.effect(
               if (method.type !== "oauth" || implementation.method.type !== "oauth") return true
               return method.id === implementation.method.id
             })
-            if (index === -1) current.methods.push(implementation.method as Types.DeepMutable<Method>)
-            else current.methods[index] = implementation.method as Types.DeepMutable<Method>
-            if (implementation.method.type === "oauth") {
-              current.implementations.set(
-                implementation.method.id,
-                implementation as Types.DeepMutable<OAuthImplementation>,
-              )
+            if (index === -1) current.methods.push(castDraft(implementation.method))
+            else current.methods[index] = castDraft(implementation.method)
+            if (isOAuthImplementation(implementation)) {
+              current.implementations.set(implementation.method.id, castDraft(implementation))
             }
           },
           remove: (integrationID, method) => {
@@ -351,27 +341,39 @@ export const locationLayer = Layer.effect(
       finalize: () => events.publish(Event.Updated, {}).pipe(Effect.asVoid),
     })
 
-    const resolveConnections = (entry: Entry | undefined, saved: readonly Credential.Info[]) => {
-      const credentials = saved
-        .map((credential) => ({
-          type: "credential" as const,
-          id: credential.id,
-          label: credential.label,
-        }))
-        .toReversed()
-      const env = (entry?.methods ?? [])
+    const connections = (entry: Entry, saved: readonly Credential.Stored[]): IntegrationConnection.Info[] => {
+      const connected = saved.map((credential) => ({
+        type: "credential" as const,
+        id: credential.id,
+        label: credential.label,
+      }))
+      const detected = entry.methods
         .filter((method) => method.type === "env")
         .flatMap((method) => method.names.filter((name) => process.env[name]))
         .map((name) => ({ type: "env" as const, name }))
-      return [...credentials, ...env]
+      return [...connected, ...detected]
     }
 
-    const project = (entry: Entry, connections: IntegrationConnection.Info[]) =>
+    const activeConnection = (
+      entry: Entry | undefined,
+      saved: readonly Credential.Stored[],
+    ): IntegrationConnection.Info | undefined => {
+      const credential = saved.at(-1)
+      if (credential) return { type: "credential", id: credential.id, label: credential.label }
+      if (!entry) return
+      const name = entry.methods
+        .filter((method) => method.type === "env")
+        .flatMap((method) => method.names)
+        .find((name) => process.env[name])
+      if (name) return { type: "env", name }
+    }
+
+    const project = (entry: Entry, saved: readonly Credential.Stored[]) =>
       new Info({
         id: entry.ref.id,
         name: entry.ref.name,
         methods: entry.methods,
-        connections,
+        connections: connections(entry, saved),
       })
 
     const authorize = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
@@ -385,7 +387,7 @@ export const locationLayer = Layer.effect(
       return error instanceof Error ? error.message : String(error)
     }
 
-    const settle = Effect.fnUntraced(function* (attemptID: AttemptID, exit: Exit.Exit<Credential.Value, unknown>) {
+    const settle = Effect.fnUntraced(function* (attemptID: AttemptID, exit: Exit.Exit<Credential.Info, unknown>) {
       const now = yield* Clock.currentTimeMillis
       const result = yield* SynchronizedRef.modify(attempts, (current) => {
         const attempt = current.get(attemptID)
@@ -432,22 +434,32 @@ export const locationLayer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
-      reload: state.reload,
+      update: state.update,
       get: Effect.fn("Integration.get")(function* (id) {
         const entry = state.get().integrations.get(id)
         if (!entry) return undefined
-        return project(entry, resolveConnections(entry, yield* credentials.list(id)))
+        return project(entry, yield* credentials.list(id))
       }),
       list: Effect.fn("Integration.list")(function* () {
-        const saved = Map.groupBy(yield* credentials.all(), (credential) => credential.integrationID)
-        return Array.from(state.get().integrations.values(), (entry) =>
-          project(entry, resolveConnections(entry, saved.get(entry.ref.id) ?? [])),
-        ).toSorted((a, b) => a.name.localeCompare(b.name))
+        return (yield* Effect.forEach(state.get().integrations.values(), (entry) =>
+          Effect.gen(function* () {
+            return project(entry, yield* credentials.list(entry.ref.id))
+          }),
+        )).toSorted((a, b) => a.name.localeCompare(b.name))
       }),
       connection: {
+        list: Effect.fn("Integration.connection.list")(function* () {
+          const saved = Map.groupBy(yield* credentials.all(), (credential) => credential.integrationID)
+          return new Map(
+            new Set([...state.get().integrations.keys(), ...saved.keys()]).values().flatMap((id) => {
+              const connection = activeConnection(state.get().integrations.get(id), saved.get(id) ?? [])
+              return connection ? [[id, connection] as const] : []
+            }),
+          )
+        }),
         forIntegration: Effect.fn("Integration.connection.forIntegration")(function* (id) {
           const entry = state.get().integrations.get(id)
-          return resolveConnections(entry, yield* credentials.list(id))[0]
+          return activeConnection(entry, yield* credentials.list(id))
         }),
         key: Effect.fn("Integration.connection.key")(function* (input) {
           const method = state

packages/core/src/location-layer.ts

@@ -7,7 +7,7 @@ import { Catalog } from "./catalog"
 import { Integration } from "./integration"
 import { CommandV2 } from "./command"
 import { AgentV2 } from "./agent"
-import { PluginInternal } from "./plugin/internal"
+import { PluginBoot } from "./plugin/boot"
 import { Project } from "./project"
 import { ProjectCopy } from "./project/copy"
 import { ProjectDirectories } from "./project/directories"
@@ -65,7 +65,7 @@ export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("
       Integration.locationLayer,
       CommandV2.locationLayer,
       AgentV2.locationLayer,
-      PluginInternal.locationLayer,
+      PluginBoot.locationLayer,
       ProjectCopy.locationLayer,
       FileSystem.locationLayer,
       Watcher.locationLayer,

packages/core/src/model-request.ts

@@ -33,7 +33,7 @@ export type Request = typeof Request.Type
 interface MutableRequest {
   headers: Record<string, string>
   body: Record<string, unknown>
-  generation?: Record<string, unknown>
+  generation?: Generation
   options?: Record<string, unknown>
 }
 

packages/core/src/model.ts

@@ -1,4 +1,5 @@
-import { Schema, Types } from "effect"
+import { DateTime, Schema } from "effect"
+import { DateTimeUtcFromMillis } from "effect/Schema"
 import { ProviderV2 } from "./provider"
 import { ModelRequest } from "./model-request"
 
@@ -15,8 +16,8 @@ export type Family = typeof Family.Type
 export const Capabilities = Schema.Struct({
   tools: Schema.Boolean,
   // mime patterns, image, audio, video/*, text/*
-  input: Schema.String.pipe(Schema.Array, Schema.mutable),
-  output: Schema.String.pipe(Schema.Array, Schema.mutable),
+  input: Schema.String.pipe(Schema.Array),
+  output: Schema.String.pipe(Schema.Array),
 })
 export type Capabilities = typeof Capabilities.Type
 
@@ -66,11 +67,11 @@ export class Info extends Schema.Class<Info>("ModelV2.Info")({
   variants: Schema.Struct({
     id: VariantID,
     ...ModelRequest.Request.fields,
-  }).pipe(Schema.Array, Schema.mutable),
+  }).pipe(Schema.Array),
   time: Schema.Struct({
-    released: Schema.Finite,
+    released: DateTimeUtcFromMillis,
   }),
-  cost: Cost.pipe(Schema.Array, Schema.mutable),
+  cost: Cost.pipe(Schema.Array),
   status: Schema.Literals(["alpha", "beta", "deprecated", "active"]),
   enabled: Schema.Boolean,
   limit: Schema.Struct({
@@ -102,7 +103,7 @@ export class Info extends Schema.Class<Info>("ModelV2.Info")({
       },
       variants: [],
       time: {
-        released: 0,
+        released: DateTime.makeUnsafe(0),
       },
       cost: [],
       status: "active",
@@ -115,10 +116,6 @@ export class Info extends Schema.Class<Info>("ModelV2.Info")({
   }
 }
 
-export type MutableInfo = Omit<Types.DeepMutable<Info>, "api"> & {
-  api: ProviderV2.MutableApi<Api>
-}
-
 export function parse(input: string): { providerID: ProviderV2.ID; modelID: ID } {
   const [providerID, ...modelID] = input.split("/")
   return {

packages/core/src/npm.ts

@@ -20,7 +20,7 @@ export class InstallFailedError extends Schema.TaggedErrorClass<InstallFailedErr
 
 export interface EntryPoint {
   readonly directory: string
-  readonly entrypoint?: string
+  readonly entrypoint: Option.Option<string>
 }
 
 export interface Interface {
@@ -34,7 +34,7 @@ export interface Interface {
       }[]
     },
   ) => Effect.Effect<void, EffectFlock.LockError | InstallFailedError>
-  readonly which: (pkg: string, bin?: string) => Effect.Effect<string | undefined>
+  readonly which: (pkg: string, bin?: string) => Effect.Effect<Option.Option<string>>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Npm") {}
@@ -47,11 +47,12 @@ export function sanitize(pkg: string) {
 }
 
 const resolveEntryPoint = (name: string, dir: string): EntryPoint => {
-  let entrypoint: string | undefined
+  let entrypoint: Option.Option<string>
   try {
-    entrypoint = typeof Bun !== "undefined" ? import.meta.resolve(name, dir) : import.meta.resolve(dir)
+    const resolved = typeof Bun !== "undefined" ? import.meta.resolve(name, dir) : import.meta.resolve(dir)
+    entrypoint = Option.some(resolved)
   } catch {
-    entrypoint = undefined
+    entrypoint = Option.none()
   }
   return {
     directory: dir,
@@ -129,7 +130,7 @@ export const layer = Layer.effect(
       const first = tree.edgesOut.values().next().value?.to
       if (!first) {
         const result = resolveEntryPoint(name, path.join(dir, "node_modules", name))
-        if (result.entrypoint) return result
+        if (Option.isSome(result.entrypoint)) return result
         return yield* new InstallFailedError({ add: [pkg], dir })
       }
       return resolveEntryPoint(first.name, first.path)
@@ -218,24 +219,22 @@ export const layer = Layer.effect(
         return Option.some(files[0])
       })
 
-      return Option.getOrUndefined(
-        yield* Effect.gen(function* () {
-          const bin = yield* pick()
-          if (Option.isSome(bin)) {
-            return Option.some(path.join(binDir, bin.value))
-          }
+      return yield* Effect.gen(function* () {
+        const bin = yield* pick()
+        if (Option.isSome(bin)) {
+          return Option.some(path.join(binDir, bin.value))
+        }
 
-          yield* fs.remove(path.join(dir, "package-lock.json")).pipe(Effect.orElseSucceed(() => {}))
+        yield* fs.remove(path.join(dir, "package-lock.json")).pipe(Effect.orElseSucceed(() => {}))
 
-          yield* add(pkg)
+        yield* add(pkg)
 
-          const resolved = yield* pick()
-          if (Option.isNone(resolved)) return Option.none<string>()
-          return Option.some(path.join(binDir, resolved.value))
-        }).pipe(
-          Effect.scoped,
-          Effect.orElseSucceed(() => Option.none<string>()),
-        ),
+        const resolved = yield* pick()
+        if (Option.isNone(resolved)) return Option.none<string>()
+        return Option.some(path.join(binDir, resolved.value))
+      }).pipe(
+        Effect.scoped,
+        Effect.orElseSucceed(() => Option.none<string>()),
       )
     })
 
@@ -262,9 +261,14 @@ export async function install(...args: Parameters<Interface["install"]>) {
 }
 
 export async function add(...args: Parameters<Interface["add"]>) {
-  return runPromise((svc) => svc.add(...args))
+  const entry = await runPromise((svc) => svc.add(...args))
+  return {
+    directory: entry.directory,
+    entrypoint: Option.getOrUndefined(entry.entrypoint),
+  }
 }
 
 export async function which(...args: Parameters<Interface["which"]>) {
-  return runPromise((svc) => svc.which(...args))
+  const resolved = await runPromise((svc) => svc.which(...args))
+  return Option.getOrUndefined(resolved)
 }

packages/core/src/permission/schema.ts

@@ -12,5 +12,5 @@ export const Rule = Schema.Struct({
 }).annotate({ identifier: "PermissionV2.Rule" })
 export type Rule = typeof Rule.Type
 
-export const Ruleset = Schema.mutable(Schema.Array(Rule)).annotate({ identifier: "PermissionV2.Ruleset" })
+export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionV2.Ruleset" })
 export type Ruleset = typeof Ruleset.Type

packages/core/src/plugin.ts

@@ -1,18 +1,12 @@
 export * as PluginV2 from "./plugin"
 
-import { Context, Deferred, Effect, Exit, Layer, Schema, Scope } from "effect"
-import type { Plugin } from "@opencode-ai/plugin/v2/effect"
-import { AgentV2 } from "./agent"
-import { AISDK } from "./aisdk"
-import { Catalog } from "./catalog"
-import { CommandV2 } from "./command"
+import { createDraft, finishDraft, type Draft } from "immer"
+import type { LanguageModelV3 } from "@ai-sdk/provider"
+import { Context, Effect, Exit, Layer, Schema, Scope } from "effect"
+import type { ModelV2 } from "./model"
+import type { Catalog } from "./catalog"
 import { EventV2 } from "./event"
-import { Integration } from "./integration"
 import { KeyedMutex } from "./effect/keyed-mutex"
-import { PluginHost } from "./plugin/host"
-import { Reference } from "./reference"
-import { SkillV2 } from "./skill"
-import { State } from "./state"
 
 export const ID = Schema.String.pipe(Schema.brand("Plugin.ID"))
 export type ID = typeof ID.Type
@@ -26,10 +20,71 @@ export const Event = {
   }),
 }
 
+type HookSpec = {
+  "catalog.transform": {
+    input: Catalog.Editor
+    output: {}
+  }
+  "aisdk.language": {
+    input: {
+      model: ModelV2.Info
+      sdk: any
+      options: Record<string, any>
+    }
+    output: {
+      language?: LanguageModelV3
+    }
+  }
+  "aisdk.sdk": {
+    input: {
+      model: ModelV2.Info
+      package: string
+      options: Record<string, any>
+    }
+    output: {
+      sdk?: any
+    }
+  }
+}
+
+export type Hooks = {
+  [Name in keyof HookSpec]: Readonly<HookSpec[Name]["input"]> & {
+    -readonly [Field in keyof HookSpec[Name]["output"]]: HookSpec[Name]["output"][Field] extends object
+      ? Draft<HookSpec[Name]["output"][Field]>
+      : HookSpec[Name]["output"][Field]
+  }
+}
+
+export type HookFunctions = {
+  [key in keyof Hooks]?: (input: Hooks[key]) => Effect.Effect<void>
+}
+
+export type HookInput<Name extends keyof Hooks> = HookSpec[Name]["input"]
+export type HookOutput<Name extends keyof Hooks> = HookSpec[Name]["output"]
+
+export type Effect<R = never> = Effect.Effect<HookFunctions | void, never, R | Scope.Scope>
+
+export function define<R>(input: { id: ID; effect: Effect.Effect<HookFunctions | void, never, R> }) {
+  return input
+}
+
 export interface Interface {
-  readonly add: (id: ID, effect: Plugin["effect"]) => Effect.Effect<void>
+  readonly add: (input: {
+    id: ID
+    effect: Effect.Effect<void | HookFunctions, never, Scope.Scope>
+  }) => Effect.Effect<void, never, never>
   readonly remove: (id: ID) => Effect.Effect<void>
-  readonly wait: (id: ID) => Effect.Effect<void>
+  readonly triggerFor: <Name extends keyof Hooks>(
+    id: ID,
+    name: Name,
+    input: HookInput<Name>,
+    output: HookOutput<Name>,
+  ) => Effect.Effect<HookInput<Name> & HookOutput<Name>>
+  readonly trigger: <Name extends keyof Hooks>(
+    name: Name,
+    input: HookInput<Name>,
+    output: HookOutput<Name>,
+  ) => Effect.Effect<HookInput<Name> & HookOutput<Name>>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Plugin") {}
@@ -37,123 +92,95 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    let hooks: {
+      id: ID
+      hooks: HookFunctions
+      scope: Scope.Closeable
+    }[] = []
     const events = yield* EventV2.Service
+    const scope = yield* Scope.Scope
     const locks = KeyedMutex.makeUnsafe<ID>()
-    const scope = yield* Scope.make()
-    const active = new Map<ID, Scope.Closeable>()
-    const loading = new Set<ID>()
-    const waiters = new Map<ID, Set<Deferred.Deferred<void>>>()
-    const failures = new Map<ID, Exit.Exit<void, never>>()
-    let host: Parameters<Plugin["effect"]>[0]
 
-    const add = Effect.fn("Plugin.add")(function* (id: ID, effect: Plugin["effect"]) {
-      if (loading.has(id)) return yield* Effect.die(`Plugin load cycle detected for ${id}`)
-
-      yield* locks.withLock(id)(
-        Effect.sync(() => {
-          loading.add(id)
-          failures.delete(id)
-        }).pipe(
-          Effect.andThen(
-            State.batch(
-              Effect.gen(function* () {
-                const existing = active.get(id)
-                active.delete(id)
-                if (existing) yield* Scope.close(existing, Exit.void).pipe(Effect.ignore)
-
-                const child = yield* Scope.fork(scope)
-                yield* effect(host).pipe(
-                  Scope.provide(child),
-                  Effect.withSpan("Plugin.load", { attributes: { "plugin.id": id } }),
-                  Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void)),
-                )
-                yield* events.publish(Event.Added, { id })
-                active.set(id, child)
-                yield* Effect.forEach(waiters.get(id) ?? [], (waiter) => Deferred.succeed(waiter, undefined), {
-                  discard: true,
-                })
-                waiters.delete(id)
-              }),
-            ),
-          ),
-          Effect.onExit((exit) => {
-            if (Exit.isSuccess(exit)) return Effect.void
-            failures.set(id, exit)
-            return Effect.forEach(waiters.get(id) ?? [], (waiter) => Deferred.done(waiter, exit), {
-              discard: true,
-            }).pipe(Effect.ensuring(Effect.sync(() => waiters.delete(id))))
-          }),
-          Effect.ensuring(Effect.sync(() => loading.delete(id))),
-        ),
-      )
-    })
-
-    const remove = Effect.fn("Plugin.remove")(function* (id: ID) {
-      if (loading.has(id)) return yield* Effect.die(`Cannot remove plugin ${id} while it is loading`)
-
-      yield* locks.withLock(id)(
-        State.batch(
+    const svc = Service.of({
+      add: Effect.fn("Plugin.add")(function* (input) {
+        yield* locks.withLock(input.id)(
           Effect.gen(function* () {
-            const current = active.get(id)
-            active.delete(id)
-            failures.delete(id)
-            if (current) yield* Scope.close(current, Exit.void).pipe(Effect.ignore)
+            const existing = hooks.find((item) => item.id === input.id)
+            if (existing) yield* Scope.close(existing.scope, Exit.void).pipe(Effect.ignore)
+            const childScope = yield* Scope.fork(scope)
+            const result = yield* input.effect.pipe(
+              Scope.provide(childScope),
+              Effect.withSpan("Plugin.load", {
+                attributes: {
+                  "plugin.id": input.id,
+                },
+              }),
+              Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(childScope, exit) : Effect.void)),
+            )
+            hooks = [
+              ...hooks.filter((item) => item.id !== input.id),
+              {
+                id: input.id,
+                hooks: result ?? {},
+                scope: childScope,
+              },
+            ]
+            yield* events.publish(Event.Added, { id: input.id })
           }),
-        ),
-      )
-    })
-
-    const wait = Effect.fn("Plugin.wait")(function* (id: ID) {
-      const waiter = yield* Deferred.make<void>()
-      const pending = yield* locks.withLock(id)(
-        Effect.sync(() => {
-          if (active.has(id)) return false
-          const failure = failures.get(id)
-          if (failure) return failure
-          const current = waiters.get(id) ?? new Set()
-          current.add(waiter)
-          waiters.set(id, current)
-          return true
-        }),
-      )
-      if (!pending) return
-      if (typeof pending !== "boolean") return yield* pending
-      yield* Deferred.await(waiter).pipe(
-        Effect.ensuring(
-          locks.withLock(id)(
-            Effect.sync(() => {
-              const current = waiters.get(id)
-              current?.delete(waiter)
-              if (current?.size === 0) waiters.delete(id)
-            }),
-          ),
-        ),
-      )
-    })
-
-    yield* Effect.addFinalizer((exit) =>
-      Effect.gen(function* () {
-        active.clear()
-        yield* State.batch(Scope.close(scope, exit))
+        )
       }),
-    )
+      trigger: Effect.fn("Plugin.trigger")(function* (name, input, output) {
+        return yield* svc.triggerFor(ID.make("*"), name, input, output)
+      }),
+      triggerFor: Effect.fn("Plugin.triggerFor")(function* (id, name, input, output) {
+        const draftEntries = new Map<string, ReturnType<typeof createDraft>>()
+        const event = {
+          ...input,
+          ...output,
+        } as Record<string, unknown>
 
-    const service = Service.of({
-      add,
-      remove,
-      wait,
+        for (const [field, value] of Object.entries(output)) {
+          if (value && typeof value === "object") {
+            draftEntries.set(field, createDraft(value))
+            event[field] = draftEntries.get(field)
+          }
+        }
+
+        for (const item of hooks) {
+          if (id !== ID.make("*") && item.id !== id) continue
+          const match = item.hooks[name]
+          if (!match) continue
+          yield* match(event as any).pipe(
+            Effect.withSpan(`Plugin.hook.${name}`, {
+              attributes: {
+                plugin: item.id,
+                hook: name,
+              },
+            }),
+          )
+        }
+
+        for (const [field, draft] of draftEntries) {
+          event[field] = finishDraft(draft)
+        }
+
+        return event as any
+      }),
+      remove: Effect.fn("Plugin.remove")(function* (id) {
+        yield* locks.withLock(id)(
+          Effect.gen(function* () {
+            const existing = hooks.find((item) => item.id === id)
+            hooks = hooks.filter((item) => item.id !== id)
+            if (existing) yield* Scope.close(existing.scope, Exit.void).pipe(Effect.ignore)
+          }),
+        )
+      }),
     })
-    host = yield* PluginHost.make(service)
-    return service
+    return svc
   }),
 )
 
-export const locationLayer = layer.pipe(
-  Layer.provideMerge(AgentV2.locationLayer),
-  Layer.provideMerge(AISDK.locationLayer),
-  Layer.provideMerge(Catalog.locationLayer),
-  Layer.provideMerge(CommandV2.locationLayer),
-  Layer.provideMerge(Integration.locationLayer),
-  Layer.provideMerge(Reference.locationLayer),
-  Layer.provideMerge(SkillV2.locationLayer),
-)
+export const locationLayer = layer
+
+// opencode
+// sdcok

packages/core/src/plugin/agent.ts

@@ -1,12 +1,12 @@
 export * as AgentPlugin from "./agent"
 
 import path from "path"
-import { define } from "./internal"
 import { Effect } from "effect"
 import { AgentV2 } from "../agent"
 import { Global } from "../global"
 import { Location } from "../location"
 import { PermissionV2 } from "../permission"
+import { PluginV2 } from "../plugin"
 
 const TRUNCATION_GLOB = path.join(Global.Path.data, "tool-output", "*")
 const BUILD_SYSTEM =
@@ -97,9 +97,10 @@ Rules:
 - If the conversation ends with an unanswered question to the user, preserve that exact question
 - If the conversation ends with an imperative statement or request to the user (e.g. "Now please run the command and paste the console output"), always include that exact request in the summary`
 
-export const Plugin = define({
-  id: "agent",
-  effect: Effect.fn(function* (ctx) {
+export const Plugin = PluginV2.define({
+  id: PluginV2.ID.make("agent"),
+  effect: Effect.gen(function* () {
+    const agent = yield* AgentV2.Service
     const location = yield* Location.Service
     const worktree = location.directory
     const whitelistedDirs = [TRUNCATION_GLOB, path.join(Global.Path.tmp, "*")]
@@ -121,8 +122,8 @@ export const Plugin = define({
       { action: "read", resource: "*.env.example", effect: "allow" },
     ]
 
-    yield* ctx.agent.transform((draft) => {
-      draft.update(AgentV2.defaultID, (item) => {
+    yield* agent.update((editor) => {
+      editor.update(AgentV2.defaultID, (item) => {
         item.description = "The default agent. Executes tools based on configured permissions."
         item.system ??= BUILD_SYSTEM
         item.mode = "primary"
@@ -134,7 +135,7 @@ export const Plugin = define({
         )
       })
 
-      draft.update(AgentV2.ID.make("plan"), (item) => {
+      editor.update(AgentV2.ID.make("plan"), (item) => {
         item.description = "Plan mode. Disallows all edit tools."
         item.mode = "primary"
         item.permissions.push(
@@ -153,14 +154,14 @@ export const Plugin = define({
         )
       })
 
-      draft.update(AgentV2.ID.make("general"), (item) => {
+      editor.update(AgentV2.ID.make("general"), (item) => {
         item.description =
           "General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel."
         item.mode = "subagent"
         item.permissions.push(...PermissionV2.merge(defaults, [{ action: "todowrite", resource: "*", effect: "deny" }]))
       })
 
-      draft.update(AgentV2.ID.make("explore"), (item) => {
+      editor.update(AgentV2.ID.make("explore"), (item) => {
         item.description =
           'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.'
         item.system = PROMPT_EXPLORE
@@ -181,21 +182,21 @@ export const Plugin = define({
         )
       })
 
-      draft.update(AgentV2.ID.make("compaction"), (item) => {
+      editor.update(AgentV2.ID.make("compaction"), (item) => {
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_COMPACTION
         item.permissions.push(...PermissionV2.merge(defaults, [{ action: "*", resource: "*", effect: "deny" }]))
       })
 
-      draft.update(AgentV2.ID.make("title"), (item) => {
+      editor.update(AgentV2.ID.make("title"), (item) => {
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_TITLE
         item.permissions.push(...PermissionV2.merge(defaults, [{ action: "*", resource: "*", effect: "deny" }]))
       })
 
-      draft.update(AgentV2.ID.make("summary"), (item) => {
+      editor.update(AgentV2.ID.make("summary"), (item) => {
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_SUMMARY

packages/core/src/plugin/boot.ts

@@ -0,0 +1,135 @@
+export * as PluginBoot from "./boot"
+
+import { Context, Deferred, Effect, Layer } from "effect"
+import { Credential } from "../credential"
+import { Integration } from "../integration"
+import { AgentV2 } from "../agent"
+import { Catalog } from "../catalog"
+import { CommandV2 } from "../command"
+import { Config } from "../config"
+import { ConfigAgentPlugin } from "../config/plugin/agent"
+import { ConfigCommandPlugin } from "../config/plugin/command"
+import { ConfigSkillPlugin } from "../config/plugin/skill"
+import { ConfigReferencePlugin } from "../config/plugin/reference"
+import { EventV2 } from "../event"
+import { FSUtil } from "../fs-util"
+import { Global } from "../global"
+import { Location } from "../location"
+import { ModelsDev } from "../models-dev"
+import { Npm } from "../npm"
+import { PluginV2 } from "../plugin"
+import { AgentPlugin } from "./agent"
+import { CommandPlugin } from "./command"
+import { SkillPlugin } from "./skill"
+import { ConfigProviderPlugin } from "../config/plugin/provider"
+import { ModelsDevPlugin } from "./models-dev"
+import { ProviderPlugins } from "./provider"
+import { SkillV2 } from "../skill"
+import { Reference } from "../reference"
+
+type Plugin = {
+  id: PluginV2.ID
+  effect: PluginV2.Effect<
+    | Catalog.Service
+    | CommandV2.Service
+    | Credential.Service
+    | Integration.Service
+    | AgentV2.Service
+    | Npm.Service
+    | EventV2.Service
+    | FSUtil.Service
+    | Global.Service
+    | Location.Service
+    | PluginV2.Service
+    | Config.Service
+    | ModelsDev.Service
+    | SkillV2.Service
+    | Reference.Service
+  >
+}
+
+export interface Interface {
+  readonly wait: () => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/PluginBoot") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const catalog = yield* Catalog.Service
+    const commands = yield* CommandV2.Service
+    const plugin = yield* PluginV2.Service
+    const credentials = yield* Credential.Service
+    const integrations = yield* Integration.Service
+    const agents = yield* AgentV2.Service
+    const config = yield* Config.Service
+    const location = yield* Location.Service
+    const modelsDev = yield* ModelsDev.Service
+    const npm = yield* Npm.Service
+    const events = yield* EventV2.Service
+    const fs = yield* FSUtil.Service
+    const global = yield* Global.Service
+    const skill = yield* SkillV2.Service
+    const references = yield* Reference.Service
+    const done = yield* Deferred.make<void>()
+
+    const add = Effect.fn("PluginBoot.add")(function* (input: Plugin) {
+      yield* plugin.add({
+        id: input.id,
+        effect: input.effect.pipe(
+          Effect.provideService(Catalog.Service, catalog),
+          Effect.provideService(CommandV2.Service, commands),
+          Effect.provideService(Credential.Service, credentials),
+          Effect.provideService(Integration.Service, integrations),
+          Effect.provideService(AgentV2.Service, agents),
+          Effect.provideService(Config.Service, config),
+          Effect.provideService(Location.Service, location),
+          Effect.provideService(ModelsDev.Service, modelsDev),
+          Effect.provideService(Npm.Service, npm),
+          Effect.provideService(EventV2.Service, events),
+          Effect.provideService(FSUtil.Service, fs),
+          Effect.provideService(Global.Service, global),
+          Effect.provideService(SkillV2.Service, skill),
+          Effect.provideService(Reference.Service, references),
+          Effect.provideService(PluginV2.Service, plugin),
+        ),
+      })
+    })
+
+    const boot = Effect.gen(function* () {
+      yield* add(AgentPlugin.Plugin)
+      yield* add(CommandPlugin.Plugin)
+      yield* add(SkillPlugin.Plugin)
+      for (const item of ProviderPlugins) {
+        yield* add(item)
+      }
+      yield* add(ModelsDevPlugin)
+      yield* add(ConfigProviderPlugin.Plugin)
+      yield* add(ConfigAgentPlugin.Plugin)
+      yield* add(ConfigCommandPlugin.Plugin)
+      yield* add(ConfigSkillPlugin.Plugin)
+      yield* add(ConfigReferencePlugin.Plugin)
+    }).pipe(Effect.withSpan("PluginBoot.boot"))
+
+    yield* boot.pipe(
+      Effect.exit,
+      Effect.flatMap((exit) => Deferred.done(done, exit)),
+      Effect.forkScoped,
+    )
+
+    return Service.of({
+      wait: () => Deferred.await(done),
+    })
+  }),
+)
+
+export const locationLayer = layer.pipe(
+  Layer.provideMerge(Integration.locationLayer),
+  Layer.provideMerge(Catalog.locationLayer),
+  Layer.provideMerge(CommandV2.locationLayer),
+  Layer.provideMerge(Config.locationLayer),
+  Layer.provideMerge(AgentV2.locationLayer),
+  Layer.provideMerge(SkillV2.locationLayer),
+  Layer.provideMerge(Reference.locationLayer),
+)

packages/core/src/plugin/command.ts

@@ -1,21 +1,25 @@
 export * as CommandPlugin from "./command"
 
-import { define } from "./internal"
 import { Effect } from "effect"
+import { CommandV2 } from "../command"
 import { Location } from "../location"
+import { PluginV2 } from "../plugin"
 import PROMPT_INITIALIZE from "./command/initialize.txt"
 import PROMPT_REVIEW from "./command/review.txt"
 
-export const Plugin = define({
-  id: "command",
-  effect: Effect.fn(function* (ctx) {
+export const Plugin = PluginV2.define({
+  id: PluginV2.ID.make("command"),
+  effect: Effect.gen(function* () {
+    const command = yield* CommandV2.Service
     const location = yield* Location.Service
-    yield* ctx.command.transform((draft) => {
-      draft.update("init", (command) => {
+    const transform = yield* command.transform()
+
+    yield* transform((editor) => {
+      editor.update("init", (command) => {
         command.template = PROMPT_INITIALIZE.replace("${path}", location.project.directory)
         command.description = "guided AGENTS.md setup"
       })
-      draft.update("review", (command) => {
+      editor.update("review", (command) => {
         command.template = PROMPT_REVIEW.replace("${path}", location.project.directory)
         command.description = "review changes [commit|branch|pr], defaults to uncommitted"
         command.subtask = true

packages/core/src/plugin/host.ts

@@ -1,154 +0,0 @@
-export * as PluginHost from "./host"
-
-import type { PluginContext as Interface } from "@opencode-ai/plugin/v2/effect"
-import { Effect, Schema } from "effect"
-import { AgentV2 } from "../agent"
-import { AISDK } from "../aisdk"
-import { Catalog } from "../catalog"
-import { CommandV2 } from "../command"
-import { Integration } from "../integration"
-import { ModelV2 } from "../model"
-import { PluginV2 } from "../plugin"
-import { ProviderV2 } from "../provider"
-import { Reference } from "../reference"
-import { SkillV2 } from "../skill"
-
-export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Interface) {
-  const agents = yield* AgentV2.Service
-  const aisdk = yield* AISDK.Service
-  const catalog = yield* Catalog.Service
-  const commands = yield* CommandV2.Service
-  const integration = yield* Integration.Service
-  const reference = yield* Reference.Service
-  const skill = yield* SkillV2.Service
-
-  return {
-    options: {},
-    agent: {
-      reload: agents.reload,
-      transform: (callback) =>
-        agents.transform((draft) =>
-          callback({
-            list: draft.list,
-            get: (id) => draft.get(AgentV2.ID.make(id)),
-            default: (id) => draft.default(id === undefined ? undefined : AgentV2.ID.make(id)),
-            update: (id, update) => draft.update(AgentV2.ID.make(id), update),
-            remove: (id) => draft.remove(AgentV2.ID.make(id)),
-          }),
-        ),
-    },
-    aisdk: {
-      sdk: (callback) =>
-        aisdk.hook.sdk((event) => {
-          const output = {
-            model: event.model,
-            package: event.package,
-            options: event.options,
-            sdk: event.sdk,
-          }
-          const result = callback(output)
-          return Effect.suspend(() => (Effect.isEffect(result) ? result : Effect.void)).pipe(
-            Effect.tap(() => Effect.sync(() => (event.sdk = output.sdk))),
-          )
-        }),
-      language: (callback) =>
-        aisdk.hook.language((event) => {
-          const output = {
-            model: event.model,
-            sdk: event.sdk,
-            options: event.options,
-            language: event.language,
-          }
-          const result = callback(output)
-          return Effect.suspend(() => (Effect.isEffect(result) ? result : Effect.void)).pipe(
-            Effect.tap(() => Effect.sync(() => (event.language = output.language))),
-          )
-        }),
-    },
-    catalog: {
-      reload: catalog.reload,
-      transform: (callback) =>
-        catalog.transform((draft) =>
-          callback({
-            provider: {
-              list: draft.provider.list,
-              get: (id) => draft.provider.get(ProviderV2.ID.make(id)),
-              update: (id, update) => draft.provider.update(ProviderV2.ID.make(id), update),
-              remove: (id) => draft.provider.remove(ProviderV2.ID.make(id)),
-            },
-            model: {
-              get: (providerID, modelID) => draft.model.get(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
-              update: (providerID, modelID, update) =>
-                draft.model.update(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID), update),
-              remove: (providerID, modelID) =>
-                draft.model.remove(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
-              default: {
-                get: draft.model.default.get,
-                set: (providerID, modelID) =>
-                  draft.model.default.set(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
-              },
-            },
-          }),
-        ),
-    },
-    command: {
-      reload: commands.reload,
-      transform: commands.transform,
-    },
-    integration: {
-      reload: integration.reload,
-      transform: (callback) =>
-        integration.transform((draft) =>
-          callback({
-            list: draft.list,
-            get: (id) => draft.get(Integration.ID.make(id)),
-            update: (id, update) => draft.update(Integration.ID.make(id), update),
-            remove: (id) => draft.remove(Integration.ID.make(id)),
-            method: {
-              list: (id) => draft.method.list(Integration.ID.make(id)),
-              update: (input) => {
-                if (input.method.type === "env") {
-                  draft.method.update({
-                    integrationID: Integration.ID.make(input.integrationID),
-                    method: { type: "env", names: input.method.names },
-                  })
-                  return
-                }
-                draft.method.update({
-                  integrationID: Integration.ID.make(input.integrationID),
-                  method: { type: "key", label: input.method.label },
-                })
-              },
-              remove: (id, method) =>
-                draft.method.remove(Integration.ID.make(id), Schema.decodeUnknownSync(Integration.Method)(method)),
-            },
-          }),
-        ),
-    },
-    plugin: {
-      add: (input) => plugin.add(PluginV2.ID.make(input.id), input.effect),
-      remove: (id) => plugin.remove(PluginV2.ID.make(id)),
-    },
-    reference: {
-      reload: reference.reload,
-      transform: (callback) =>
-        reference.transform((draft) =>
-          callback({
-            add: (name, source) => draft.add(name, Schema.decodeUnknownSync(Reference.Source)(source)),
-            remove: draft.remove,
-            list: draft.list,
-          }),
-        ),
-    },
-    skill: {
-      reload: skill.reload,
-      transform: (callback) =>
-        skill.transform((draft) =>
-          callback({
-            source: (source) => draft.source(Schema.decodeUnknownSync(SkillV2.Source)(source)),
-            list: draft.list,
-          }),
-        ),
-    },
-  } satisfies Interface
-})

packages/core/src/plugin/internal.ts

@@ -1,118 +0,0 @@
-export * as PluginInternal from "./internal"
-
-import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
-import { Effect, Layer, Scope } from "effect"
-import { AgentV2 } from "../agent"
-import { Catalog } from "../catalog"
-import { CommandV2 } from "../command"
-import { Config } from "../config"
-import { ConfigAgentPlugin } from "../config/plugin/agent"
-import { ConfigCommandPlugin } from "../config/plugin/command"
-import { ConfigExternalPlugin } from "../config/plugin/external"
-import { ConfigProviderPlugin } from "../config/plugin/provider"
-import { ConfigReferencePlugin } from "../config/plugin/reference"
-import { ConfigSkillPlugin } from "../config/plugin/skill"
-import { EventV2 } from "../event"
-import { FileSystem } from "../filesystem"
-import { FSUtil } from "../fs-util"
-import { Global } from "../global"
-import { Integration } from "../integration"
-import { Location } from "../location"
-import { ModelsDev } from "../models-dev"
-import { Npm } from "../npm"
-import { PluginV2 } from "../plugin"
-import { Reference } from "../reference"
-import { SkillV2 } from "../skill"
-import { AgentPlugin } from "./agent"
-import { CommandPlugin } from "./command"
-import { ModelsDevPlugin } from "./models-dev"
-import { ProviderPlugins } from "./provider"
-import { SkillPlugin } from "./skill"
-
-export type Requirements =
-  | AgentV2.Service
-  | Catalog.Service
-  | CommandV2.Service
-  | Config.Service
-  | EventV2.Service
-  | FileSystem.Service
-  | FSUtil.Service
-  | Global.Service
-  | Integration.Service
-  | Location.Service
-  | ModelsDev.Service
-  | Npm.Service
-  | Reference.Service
-  | SkillV2.Service
-
-export interface Plugin<R = never> {
-  readonly id: string
-  readonly effect: (context: PluginContext) => Effect.Effect<void, never, R | Scope.Scope>
-}
-
-export function define<R>(plugin: Plugin<R>) {
-  return plugin
-}
-
-export const locationLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const catalog = yield* Catalog.Service
-    const commands = yield* CommandV2.Service
-    const plugin = yield* PluginV2.Service
-    const integration = yield* Integration.Service
-    const agents = yield* AgentV2.Service
-    const config = yield* Config.Service
-    const location = yield* Location.Service
-    const modelsDev = yield* ModelsDev.Service
-    const npm = yield* Npm.Service
-    const events = yield* EventV2.Service
-    const fs = yield* FSUtil.Service
-    const filesystem = yield* FileSystem.Service
-    const global = yield* Global.Service
-    const skill = yield* SkillV2.Service
-    const reference = yield* Reference.Service
-    const add = <R>(input: Plugin<R>) => {
-      const loaded = {
-        id: input.id,
-        effect: (context: PluginContext) =>
-          input
-            .effect(context)
-            .pipe(
-              Effect.provideService(Catalog.Service, catalog),
-              Effect.provideService(CommandV2.Service, commands),
-              Effect.provideService(Integration.Service, integration),
-              Effect.provideService(AgentV2.Service, agents),
-              Effect.provideService(Config.Service, config),
-              Effect.provideService(Location.Service, location),
-              Effect.provideService(ModelsDev.Service, modelsDev),
-              Effect.provideService(Npm.Service, npm),
-              Effect.provideService(EventV2.Service, events),
-              Effect.provideService(FSUtil.Service, fs),
-              Effect.provideService(FileSystem.Service, filesystem),
-              Effect.provideService(Global.Service, global),
-              Effect.provideService(SkillV2.Service, skill),
-              Effect.provideService(Reference.Service, reference),
-            ),
-      }
-      return plugin.add(PluginV2.ID.make(loaded.id), loaded.effect)
-    }
-
-    yield* Effect.gen(function* () {
-      yield* add(ConfigReferencePlugin.Plugin)
-      yield* add(AgentPlugin.Plugin)
-      yield* add(CommandPlugin.Plugin)
-      yield* add(SkillPlugin.Plugin)
-      yield* add(ModelsDevPlugin)
-      yield* add(ConfigProviderPlugin.Plugin)
-      yield* add(ConfigAgentPlugin.Plugin)
-      yield* add(ConfigCommandPlugin.Plugin)
-      yield* add(ConfigSkillPlugin.Plugin)
-      for (const item of ProviderPlugins) yield* add(item)
-      yield* add(ConfigExternalPlugin.Plugin)
-    }).pipe(Effect.withSpan("PluginInternal.boot"), Effect.forkScoped({ startImmediately: true }))
-  }),
-).pipe(
-  Layer.provideMerge(PluginV2.locationLayer),
-  Layer.provideMerge(Config.locationLayer),
-  Layer.provideMerge(FileSystem.locationLayer),
-)

packages/core/src/plugin/models-dev.ts

@@ -1,14 +1,16 @@
-import { define } from "./internal"
-import { Effect, Stream } from "effect"
+import { DateTime, Effect, Scope, Stream } from "effect"
+import { Catalog } from "../catalog"
+import { Integration } from "../integration"
 import { EventV2 } from "../event"
 import { ModelV2 } from "../model"
 import { ModelRequest } from "../model-request"
 import { ModelsDev } from "../models-dev"
+import { PluginV2 } from "../plugin"
 import { ProviderV2 } from "../provider"
 
 function released(date: string) {
   const time = Date.parse(date)
-  return Number.isFinite(time) ? time : 0
+  return DateTime.makeUnsafe(Number.isFinite(time) ? time : 0)
 }
 
 function cost(input: ModelsDev.Model["cost"]) {
@@ -49,17 +51,22 @@ function variants(model: ModelsDev.Model, packageName?: string) {
   })
 }
 
-export const ModelsDevPlugin = define({
-  id: "models-dev",
-  effect: Effect.fn(function* (ctx) {
+export const ModelsDevPlugin = PluginV2.define({
+  id: PluginV2.ID.make("models-dev"),
+  effect: Effect.gen(function* () {
+    const catalog = yield* Catalog.Service
+    const integrations = yield* Integration.Service
     const modelsDev = yield* ModelsDev.Service
     const events = yield* EventV2.Service
-    yield* ctx.integration.transform(
-      Effect.fn(function* (integrations) {
-        const data = yield* modelsDev.get()
+    const scope = yield* Scope.Scope
+    const transform = yield* catalog.transform()
+    const integrationTransform = yield* integrations.transform()
+    const refresh = Effect.fn("ModelsDevPlugin.refresh")(function* () {
+      const data = yield* modelsDev.get()
+      yield* integrationTransform((integrations) => {
         for (const item of Object.values(data)) {
           if (item.env.length === 0) continue
-          const integrationID = item.id
+          const integrationID = Integration.ID.make(item.id)
           integrations.update(integrationID, (integration) => (integration.name = item.name))
           integrations.method.update({
             integrationID,
@@ -70,11 +77,8 @@ export const ModelsDevPlugin = define({
             method: { type: "env", names: [...item.env] },
           })
         }
-      }),
-    )
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (catalog) {
-        const data = yield* modelsDev.get()
+      })
+      yield* transform((catalog) => {
         for (const item of Object.values(data)) {
           const providerID = ProviderV2.ID.make(item.id)
           catalog.provider.update(providerID, (provider) => {
@@ -128,10 +132,11 @@ export const ModelsDevPlugin = define({
             })
           }
         }
-      }),
-    )
+      })
+    })
+    yield* refresh()
     yield* events.subscribe(ModelsDev.Event.Refreshed).pipe(
-      Stream.runForEach(() => ctx.integration.reload().pipe(Effect.andThen(ctx.catalog.reload()))),
+      Stream.runForEach(() => refresh()),
       Effect.forkScoped({ startImmediately: true }),
     )
   }),

packages/core/src/plugin/promise.ts

@@ -1,89 +0,0 @@
-export * as PluginPromise from "./promise"
-
-import { define } from "@opencode-ai/plugin/v2/effect"
-import type { Plugin, PluginContext, Registration } from "@opencode-ai/plugin/v2/promise"
-import { Effect, Scope } from "effect"
-
-// The Effect host hands back this registration shape; mirror it structurally so
-// we do not have to alias the Effect package's `Registration` against the Promise one.
-type HostRegistration = { readonly dispose: Effect.Effect<void> }
-
-/**
- * Adapts a Promise plugin into an Effect plugin so the existing Effect-only
- * loader (`PluginV2` / `PluginInternal`) can run it unchanged.
- *
- * Hook registrations created during the async `setup` attach to the plugin's
- * scope, so unloading the plugin disposes them. The captured fiber context
- * preserves boot-time batching, so Promise-plugin transforms still coalesce
- * into one reload per domain.
- */
-export function fromPromise(plugin: Plugin) {
-  return define({
-    id: plugin.id,
-    effect: (host) =>
-      Effect.gen(function* () {
-        const scope = yield* Scope.Scope
-        const context = yield* Effect.context<Scope.Scope>()
-
-        // Run a hook registration on the plugin scope and resolve once it is registered.
-        const register = (effect: Effect.Effect<HostRegistration, never, Scope.Scope>): Promise<Registration> =>
-          Effect.runPromiseWith(context)(Scope.provide(scope)(effect)).then((registration) => ({
-            dispose: () => Effect.runPromiseWith(context)(registration.dispose),
-          }))
-
-        const run = (effect: Effect.Effect<void>) => Effect.runPromiseWith(context)(effect)
-
-        const transform =
-          <Draft>(domain: {
-            transform: (
-              callback: (draft: Draft) => Effect.Effect<void> | void,
-            ) => Effect.Effect<HostRegistration, never, Scope.Scope>
-          }) =>
-          (callback: (draft: Draft) => Promise<void> | void) =>
-            register(domain.transform((draft) => Effect.promise(() => Promise.resolve(callback(draft)))))
-
-        const context2: PluginContext = {
-          options: host.options,
-          agent: {
-            transform: transform(host.agent),
-            reload: () => run(host.agent.reload()),
-          },
-          aisdk: {
-            sdk: (callback) =>
-              register(host.aisdk.sdk((event) => Effect.promise(() => Promise.resolve(callback(event))))),
-            language: (callback) =>
-              register(host.aisdk.language((event) => Effect.promise(() => Promise.resolve(callback(event))))),
-          },
-          catalog: {
-            transform: transform(host.catalog),
-            reload: () => run(host.catalog.reload()),
-          },
-          command: {
-            transform: transform(host.command),
-            reload: () => run(host.command.reload()),
-          },
-          integration: {
-            transform: transform(host.integration),
-            reload: () => run(host.integration.reload()),
-          },
-          plugin: {
-            add: (input) => {
-              const child = fromPromise(input)
-              return run(host.plugin.add(child))
-            },
-            remove: (id) => run(host.plugin.remove(id)),
-          },
-          reference: {
-            transform: transform(host.reference),
-            reload: () => run(host.reference.reload()),
-          },
-          skill: {
-            transform: transform(host.skill),
-            reload: () => run(host.skill.reload()),
-          },
-        }
-
-        yield* Effect.promise(() => Promise.resolve(plugin.setup(context2)))
-      }),
-  })
-}

packages/core/src/plugin/provider.ts

@@ -30,10 +30,8 @@ import { VercelPlugin } from "./provider/vercel"
 import { VenicePlugin } from "./provider/venice"
 import { XAIPlugin } from "./provider/xai"
 import { ZenmuxPlugin } from "./provider/zenmux"
-import type { PluginInternal } from "./internal"
-import type { Scope } from "effect"
 
-export const ProviderPlugins: PluginInternal.Plugin<PluginInternal.Requirements | Scope.Scope>[] = [
+export const ProviderPlugins = [
   AlibabaPlugin,
   AmazonBedrockPlugin,
   AnthropicPlugin,

packages/core/src/plugin/provider/alibaba.ts

@@ -1,15 +1,15 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 
-export const AlibabaPlugin = define({
-  id: "alibaba",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+export const AlibabaPlugin = PluginV2.define({
+  id: PluginV2.ID.make("alibaba"),
+  effect: Effect.gen(function* () {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/alibaba") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/alibaba"))
         evt.sdk = mod.createAlibaba(evt.options)
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/amazon-bedrock.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
 type MantleSDK = {
@@ -59,11 +59,11 @@ function selectMantleModel(sdk: MantleSDK, modelID: string) {
   return sdk.responses(modelID)
 }
 
-export const AmazonBedrockPlugin = define({
-  id: "amazon-bedrock",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
+export const AmazonBedrockPlugin = PluginV2.define({
+  id: PluginV2.ID.make("amazon-bedrock"),
+  effect: Effect.gen(function* () {
+    return {
+      "catalog.transform": Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/amazon-bedrock") continue
@@ -77,9 +77,7 @@ export const AmazonBedrockPlugin = define({
           })
         }
       }),
-    )
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (!["@ai-sdk/amazon-bedrock", "@ai-sdk/amazon-bedrock/mantle"].includes(evt.package)) return
         const options = { ...evt.options }
         const profile = typeof options.profile === "string" ? options.profile : process.env.AWS_PROFILE
@@ -110,9 +108,7 @@ export const AmazonBedrockPlugin = define({
         const mod = yield* Effect.promise(() => import("@ai-sdk/amazon-bedrock"))
         evt.sdk = mod.createAmazonBedrock(options)
       }),
-    )
-    yield* ctx.aisdk.language(
-      Effect.fn(function* (evt) {
+      "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.amazonBedrock) return
         if (evt.model.api.type === "aisdk" && evt.model.api.package === "@ai-sdk/amazon-bedrock/mantle") {
           evt.language = selectMantleModel(evt.sdk, evt.model.api.id)
@@ -121,6 +117,6 @@ export const AmazonBedrockPlugin = define({
         const region = typeof evt.options.region === "string" ? evt.options.region : process.env.AWS_REGION
         evt.language = evt.sdk.languageModel(resolveModelID(evt.model.api.id, region))
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/anthropic.ts

@@ -1,11 +1,11 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 
-export const AnthropicPlugin = define({
-  id: "anthropic",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
+export const AnthropicPlugin = PluginV2.define({
+  id: PluginV2.ID.make("anthropic"),
+  effect: Effect.gen(function* () {
+    return {
+      "catalog.transform": Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/anthropic") continue
@@ -15,13 +15,11 @@ export const AnthropicPlugin = define({
           })
         }
       }),
-    )
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/anthropic") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/anthropic"))
         evt.sdk = mod.createAnthropic(evt.options)
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/azure.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
 function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
@@ -10,11 +10,11 @@ function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
   return sdk.languageModel(modelID)
 }
 
-export const AzurePlugin = define({
-  id: "azure",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
+export const AzurePlugin = PluginV2.define({
+  id: PluginV2.ID.make("azure"),
+  effect: Effect.gen(function* () {
+    return {
+      "catalog.transform": Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/azure") continue
@@ -27,9 +27,7 @@ export const AzurePlugin = define({
           })
         }
       }),
-    )
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/azure") return
         if (evt.model.providerID === ProviderV2.ID.azure) {
           if (
@@ -45,21 +43,19 @@ export const AzurePlugin = define({
         const mod = yield* Effect.promise(() => import("@ai-sdk/azure"))
         evt.sdk = mod.createAzure(evt.options)
       }),
-    )
-    yield* ctx.aisdk.language(
-      Effect.fn(function* (evt) {
+      "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.azure) return
         evt.language = selectLanguage(evt.sdk, evt.model.api.id, Boolean(evt.options.useCompletionUrls))
       }),
-    )
+    }
   }),
 })
 
-export const AzureCognitiveServicesPlugin = define({
-  id: "azure-cognitive-services",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
+export const AzureCognitiveServicesPlugin = PluginV2.define({
+  id: PluginV2.ID.make("azure-cognitive-services"),
+  effect: Effect.gen(function* () {
+    return {
+      "catalog.transform": Effect.fn(function* (evt) {
         const resourceName = process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME
         if (!resourceName) return
         for (const item of evt.provider.list()) {
@@ -71,12 +67,10 @@ export const AzureCognitiveServicesPlugin = define({
           })
         }
       }),
-    )
-    yield* ctx.aisdk.language(
-      Effect.fn(function* (evt) {
+      "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("azure-cognitive-services")) return
         evt.language = selectLanguage(evt.sdk, evt.model.api.id, Boolean(evt.options.useCompletionUrls))
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/cerebras.ts

@@ -1,26 +1,24 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 
-export const CerebrasPlugin = define({
-  id: "cerebras",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
-        for (const item of evt.provider.list()) {
+export const CerebrasPlugin = PluginV2.define({
+  id: PluginV2.ID.make("cerebras"),
+  effect: Effect.gen(function* () {
+    return {
+      "catalog.transform": Effect.fn(function* (ctx) {
+        for (const item of ctx.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/cerebras") continue
-          evt.provider.update(item.provider.id, (provider) => {
+          ctx.provider.update(item.provider.id, (provider) => {
             provider.request.headers["X-Cerebras-3rd-Party-Integration"] = "opencode"
           })
         }
       }),
-    )
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/cerebras") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/cerebras"))
         evt.sdk = mod.createCerebras(evt.options)
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/cloudflare-ai-gateway.ts

@@ -1,13 +1,13 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect, Option, Schema } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 
-export const CloudflareAIGatewayPlugin = define({
-  id: "cloudflare-ai-gateway",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+export const CloudflareAIGatewayPlugin = PluginV2.define({
+  id: PluginV2.ID.make("cloudflare-ai-gateway"),
+  effect: Effect.gen(function* () {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "ai-gateway-provider") return
         if (evt.options.baseURL) return
 
@@ -31,7 +31,7 @@ export const CloudflareAIGatewayPlugin = define({
           },
         }
       }),
-    )
+    }
   }),
 })
 

packages/core/src/plugin/provider/cloudflare-workers-ai.ts

@@ -1,16 +1,16 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
 const providerID = ProviderV2.ID.make("cloudflare-workers-ai")
 
-export const CloudflareWorkersAIPlugin = define({
-  id: "cloudflare-workers-ai",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
+export const CloudflareWorkersAIPlugin = PluginV2.define({
+  id: PluginV2.ID.make("cloudflare-workers-ai"),
+  effect: Effect.gen(function* () {
+    return {
+      "catalog.transform": Effect.fn(function* (evt) {
         const item = evt.provider.get(providerID)
         if (!item) return
         evt.provider.update(item.provider.id, (provider) => {
@@ -20,9 +20,7 @@ export const CloudflareWorkersAIPlugin = define({
           if (accountId) provider.api.url = workersEndpoint(accountId)
         })
       }),
-    )
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.model.providerID !== providerID) return
         if (evt.package !== "@ai-sdk/openai-compatible") return
 
@@ -36,13 +34,11 @@ export const CloudflareWorkersAIPlugin = define({
           }) as any,
         )
       }),
-    )
-    yield* ctx.aisdk.language(
-      Effect.fn(function* (evt) {
+      "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== providerID) return
         evt.language = evt.sdk.languageModel(evt.model.api.id)
       }),
-    )
+    }
   }),
 })
 

packages/core/src/plugin/provider/cohere.ts

@@ -1,15 +1,15 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 
-export const CoherePlugin = define({
-  id: "cohere",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+export const CoherePlugin = PluginV2.define({
+  id: PluginV2.ID.make("cohere"),
+  effect: Effect.gen(function* () {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/cohere") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/cohere"))
         evt.sdk = mod.createCohere(evt.options)
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/deepinfra.ts

@@ -1,15 +1,15 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 
-export const DeepInfraPlugin = define({
-  id: "deepinfra",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+export const DeepInfraPlugin = PluginV2.define({
+  id: PluginV2.ID.make("deepinfra"),
+  effect: Effect.gen(function* () {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/deepinfra") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/deepinfra"))
         evt.sdk = mod.createDeepInfra(evt.options)
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/dynamic.ts

@@ -1,19 +1,19 @@
-import { Effect } from "effect"
-import { pathToFileURL } from "url"
-import { define } from "../internal"
 import { Npm } from "../../npm"
+import { Effect, Option } from "effect"
+import { pathToFileURL } from "url"
+import { PluginV2 } from "../../plugin"
 
-export const DynamicProviderPlugin = define({
-  id: "dynamic-provider",
-  effect: Effect.fn(function* (ctx) {
+export const DynamicProviderPlugin = PluginV2.define({
+  id: PluginV2.ID.make("dynamic-provider"),
+  effect: Effect.gen(function* () {
     const npm = yield* Npm.Service
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.sdk) return
 
         const installedPath = evt.package.startsWith("file://")
           ? evt.package
-          : (yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint
+          : Option.getOrUndefined((yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint)
         if (!installedPath) throw new Error(`Package ${evt.package} has no import entrypoint`)
 
         const mod = yield* Effect.promise(async () => {
@@ -26,6 +26,6 @@ export const DynamicProviderPlugin = define({
 
         evt.sdk = mod[match](evt.options)
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/gateway.ts

@@ -1,15 +1,15 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 
-export const GatewayPlugin = define({
-  id: "gateway",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+export const GatewayPlugin = PluginV2.define({
+  id: PluginV2.ID.make("gateway"),
+  effect: Effect.gen(function* () {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/gateway") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/gateway"))
         evt.sdk = mod.createGateway(evt.options)
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/github-copilot.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
 function shouldUseResponses(modelID: string) {
@@ -11,29 +11,16 @@ function shouldUseResponses(modelID: string) {
   return Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini")
 }
 
-export const GithubCopilotPlugin = define({
-  id: "github-copilot",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
-        const item = evt.provider.get(ProviderV2.ID.githubCopilot)
-        if (!item || !item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) return
-        evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
-          // This chat-only alias conflicts with the Copilot GPT-5 Responses route,
-          // so hide it only for Copilot rather than for every provider catalog.
-          model.enabled = false
-        })
-      }),
-    )
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+export const GithubCopilotPlugin = PluginV2.define({
+  id: PluginV2.ID.make("github-copilot"),
+  effect: Effect.gen(function* () {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/github-copilot") return
         const mod = yield* Effect.promise(() => import("../../github-copilot/copilot-provider"))
         evt.sdk = mod.createOpenaiCompatible(evt.options)
       }),
-    )
-    yield* ctx.aisdk.language(
-      Effect.fn(function* (evt) {
+      "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.githubCopilot) return
         if (evt.sdk.responses === undefined && evt.sdk.chat === undefined) {
           evt.language = evt.sdk.languageModel(evt.model.api.id)
@@ -43,6 +30,15 @@ export const GithubCopilotPlugin = define({
           ? evt.sdk.responses(evt.model.api.id)
           : evt.sdk.chat(evt.model.api.id)
       }),
-    )
+      "catalog.transform": Effect.fn(function* (evt) {
+        const item = evt.provider.get(ProviderV2.ID.githubCopilot)
+        if (!item || !item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) return
+        evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
+          // This chat-only alias conflicts with the Copilot GPT-5 Responses route,
+          // so hide it only for Copilot rather than for every provider catalog.
+          model.enabled = false
+        })
+      }),
+    }
   }),
 })

packages/core/src/plugin/provider/gitlab.ts

@@ -1,14 +1,14 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
-export const GitLabPlugin = define({
-  id: "gitlab",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+export const GitLabPlugin = PluginV2.define({
+  id: PluginV2.ID.make("gitlab"),
+  effect: Effect.gen(function* () {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "gitlab-ai-provider") return
         const mod = yield* Effect.promise(() => import("gitlab-ai-provider"))
         evt.sdk = mod.createGitLab({
@@ -30,9 +30,7 @@ export const GitLabPlugin = define({
           },
         })
       }),
-    )
-    yield* ctx.aisdk.language(
-      Effect.fn(function* (evt) {
+      "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.gitlab) return
         const featureFlags =
           typeof evt.options.featureFlags === "object" && evt.options.featureFlags ? evt.options.featureFlags : {}
@@ -60,6 +58,6 @@ export const GitLabPlugin = define({
           featureFlags,
         })
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/google-vertex.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
 function resolveProject(options: Record<string, any>) {
@@ -54,11 +54,11 @@ function authFetch(fetchWithRuntimeOptions?: unknown) {
   }
 }
 
-export const GoogleVertexPlugin = define({
-  id: "google-vertex",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
+export const GoogleVertexPlugin = PluginV2.define({
+  id: PluginV2.ID.make("google-vertex"),
+  effect: Effect.gen(function* () {
+    return {
+      "catalog.transform": Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (
@@ -83,9 +83,7 @@ export const GoogleVertexPlugin = define({
           })
         }
       }),
-    )
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.model.providerID === ProviderV2.ID.googleVertex && evt.package.includes("@ai-sdk/openai-compatible")) {
           evt.options.fetch = authFetch(evt.options.fetch)
           return
@@ -102,21 +100,19 @@ export const GoogleVertexPlugin = define({
           location,
         })
       }),
-    )
-    yield* ctx.aisdk.language(
-      Effect.fn(function* (evt) {
+      "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.googleVertex) return
         evt.language = evt.sdk.languageModel(String(evt.model.api.id).trim())
       }),
-    )
+    }
   }),
 })
 
-export const GoogleVertexAnthropicPlugin = define({
-  id: "google-vertex-anthropic",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
+export const GoogleVertexAnthropicPlugin = PluginV2.define({
+  id: PluginV2.ID.make("google-vertex-anthropic"),
+  effect: Effect.gen(function* () {
+    return {
+      "catalog.transform": Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/google-vertex/anthropic") continue
@@ -136,9 +132,7 @@ export const GoogleVertexAnthropicPlugin = define({
           })
         }
       }),
-    )
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/google-vertex/anthropic") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"))
         const project =
@@ -162,12 +156,10 @@ export const GoogleVertexAnthropicPlugin = define({
             : {}),
         })
       }),
-    )
-    yield* ctx.aisdk.language(
-      Effect.fn(function* (evt) {
+      "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("google-vertex-anthropic")) return
         evt.language = evt.sdk.languageModel(String(evt.model.api.id).trim())
       }),
-    )
+    }
   }),
 })

packages/core/src/plugin/provider/google.ts

@@ -1,15 +1,15 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { PluginV2 } from "../../plugin"
 
-export const GooglePlugin = define({
-  id: "google",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
-      Effect.fn(function* (evt) {
+export const GooglePlugin = PluginV2.define({
+  id: PluginV2.ID.make("google"),
+  effect: Effect.gen(function* () {
+    return {
+      "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/google") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/google"))
         evt.sdk = mod.createGoogleGenerativeAI(evt.options)
       }),
-    )
+    }
   }),
 })