fix(app): restore exact timeline row

AGENTS.md

@@ -1,6 +1,4 @@
-- To regenerate the legacy JavaScript SDK, run `./packages/sdk/js/script/build.ts`.
-- After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit `src/generated` or `src/generated-effect` directly.
-- Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk-next` composes Client, Core, and Server.
+- To regenerate the JavaScript SDK, run `./packages/sdk/js/script/build.ts`.
 - The default branch in this repo is `dev`.
 - Local `main` ref may not exist; use `dev` or `origin/dev` for diffs.
 

CONTEXT.md

@@ -57,21 +57,11 @@ The bounded projection of a Core-executed tool result persisted in Session histo
 **Managed Tool Output File**:
 A temporary file created under OpenCode's shared tool-output directory to retain complete output that was too large for Session history.
 
-**Model Request Options**:
-Provider-semantic model settings selected from the Catalog and active Session variant before the LLM protocol adapter encodes them for a provider request.
-_Avoid_: Request body, wire options
-
-**Generation Controls**:
-Provider-neutral sampling and output controls, partitioned from provider semantics and compatibility wire fields when model metadata enters the Catalog.
-
-**Native Continuation Metadata**:
-Opaque protocol-shaped data attached to assistant content and required to continue that content natively with a compatible model, such as a reasoning signature or provider-hosted item identifier.
-
 **PTY Environment**:
 The host-supplied environment overlay applied by the server when creating a PTY, observed for the request Location and resolved PTY working directory.
 
 **OpenCode Client**:
-The generated Promise and Effect APIs derived from the public `HttpApi`; **Embedded OpenCode** shares the Effect API through an in-memory `HttpClient` against the same router and handlers.
+The generated Effect API shared by networked and in-process consumers, executed through an `HttpClient` against the same `HttpApi` router and handlers.
 _Avoid_: Remote client
 
 **SDK Contract IR**:
@@ -132,9 +122,6 @@ _Avoid_: Response envelope
 - 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.
-- **Native Continuation Metadata** remains in durable history. Provider-turn projection includes it only for a successful exact originating provider/model match; failed turns and incompatible models omit opaque metadata, while non-empty visible reasoning lowers to ordinary assistant text after a model switch. This conservative relation may widen only when recorded provider tests establish compatibility.
-- **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`.
 - Networked and **Embedded OpenCode** use the same **OpenCode Client** and preserve the full HTTP encoding, routing, middleware, and decoding boundary; only the `HttpClient` transport differs.
 - The Effect-native network constructor obtains `HttpClient.HttpClient` from its environment so callers own transport selection, recording, tracing, retries, and tests. Convenience runtimes may provide a fetch transport separately.
@@ -172,9 +159,8 @@ _Avoid_: Response envelope
 - Session list cursors are opaque branded values carrying continuation query and ordering state. Consumers pass them back unchanged and do not inspect storage anchors or encoded filter fields.
 - A Session list continuation accepts only its opaque cursor. Scope, filters, ordering, and page size are fixed by the initial query and carried by that cursor.
 - `sessions.messages(...)` returns a **Page** and uses the same cursor discipline as `sessions.list(...)`: the initial request supplies `sessionID`, ordering, and page size; continuation supplies `sessionID` plus only an opaque branded message cursor carrying ordering, page size, direction, and message anchor. Using a cursor with another Session is invalid.
-- `sessions.message({ sessionID, messageID })` is a required resource lookup. An unknown Session fails with `SessionNotFoundError`; a known Session with an absent or differently owned message fails with `MessageNotFoundError` without disclosing cross-Session ownership. Absence is not represented as `undefined` across the public HTTP boundary.
+- `sessions.message({ sessionID, messageID })` is a required resource lookup. An unknown Session fails with `SessionNotFoundError`; a known Session with an absent or differently owned message fails with `SessionMessageNotFoundError` without disclosing cross-Session ownership. Absence is not represented as `undefined` across the public HTTP boundary.
 - `sessions.interrupt({ sessionID })` first verifies that the durable Session exists, failing with `SessionNotFoundError` otherwise. For a known Session, interruption is idempotent: idle, already-settled, or locally unowned execution is a no-op.
-- `sessions.active()` snapshots the current process's foreground Session drain registry as a record of Session IDs to `{ type: "running" }`. Missing IDs are inactive; background subagents and tasks do not make their parent Session active, and process restart clears the registry.
 - `sessions.context({ sessionID })` preserves the existing message-only operation. It returns projected conversational messages selected as Session context; it does not include or represent the complete provider request context, whose baseline system context and other contributions remain separate.
 - **Open question**: Should a future, separately named operation expose the complete provider request context, including baseline system context, selected source contributions, and context-epoch metadata?
 - `sessions.prompt(...)` exposes `resume?: boolean`. Omitting it preserves durable admission followed by an advisory execution wake; `resume: false` requests durable admit-only behavior.

packages/app/e2e/regression/terminal-hidden.spec.ts

@@ -1,79 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/HiddenTerminalRegression"
-const projectID = "proj_hidden_terminal_regression"
-const sessionID = "ses_hidden_terminal_regression"
-const title = "Hidden terminal regression"
-
-test("unmounts the terminal renderer while the pane is hidden", async ({ page }) => {
-  await page.setViewportSize({ width: 1400, height: 900 })
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: projectID,
-      worktree: directory,
-      vcs: "git",
-      name: "hidden-terminal-regression",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: {
-      all: [
-        {
-          id: "opencode",
-          name: "OpenCode",
-          models: { test: { id: "test", name: "Test", limit: { context: 200_000 } } },
-        },
-      ],
-      connected: ["opencode"],
-      default: { providerID: "opencode", modelID: "test" },
-    },
-    sessions: [
-      {
-        id: sessionID,
-        slug: "hidden-terminal-regression",
-        projectID,
-        directory,
-        title,
-        version: "dev",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-    ],
-    pageMessages: () => ({ items: [] }),
-  })
-  await page.route("**/pty", (route) =>
-    route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({ id: "pty_hidden_terminal", title: "Terminal 1" }),
-    }),
-  )
-  await page.route("**/pty/pty_hidden_terminal", (route) =>
-    route.fulfill({ status: 200, contentType: "application/json", body: "{}" }),
-  )
-  await page.routeWebSocket("**/pty/pty_hidden_terminal/connect", () => undefined)
-
-  await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-  await expectSessionTitle(page, title)
-
-  await page.keyboard.press("Control+Backquote")
-  const panel = page.locator("#terminal-panel")
-  await expect(panel).toHaveAttribute("aria-hidden", "false")
-  await expect(page.locator('[data-component="terminal"]')).toBeVisible()
-
-  await page.keyboard.press("Control+Backquote")
-  await expect(panel).toHaveAttribute("aria-hidden", "true")
-  await expect(page.locator('[data-component="terminal"]')).toHaveCount(0)
-
-  await page.setViewportSize({ width: 1200, height: 700 })
-  await expect(page.locator('[data-component="terminal"]')).toHaveCount(0)
-
-  await page.keyboard.press("Control+Backquote")
-  await expect(page.locator('[data-component="terminal"]')).toBeVisible()
-})
-
-function base64Encode(value: string) {
-  return Buffer.from(value, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
-}

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

@@ -222,7 +222,10 @@ function turn(index: number): Message[] {
   return [user, assistantMessage(targetID, index, user.info.id, parts)]
 }
 
-const targetMessages = Array.from({ length: 72 }, (_, index) => turn(index)).flat()
+export const timelineMessages = (count: number, start = 0) =>
+  Array.from({ length: count }, (_, index) => turn(start + index)).flat()
+
+const targetMessages = timelineMessages(72)
 const sourceMessages = Array.from({ length: 12 }, (_, index) => [
   userMessage(sourceID, index + 1000, 120),
   assistantMessage(sourceID, index + 1000, id("msg_user", index + 1000), [textPart(index + 1000, 0, 240)]),
@@ -301,6 +304,10 @@ export const fixture = {
 
 export function pageMessages(sessionID: string, limit: number, before?: string) {
   const messages = fixture.messages[sessionID as keyof typeof fixture.messages] ?? []
+  return pageMessageList(messages, limit, before)
+}
+
+export function pageMessageList(messages: Message[], limit: number, before?: string) {
   const end = before
     ? Math.max(
         0,

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

@@ -1,6 +1,6 @@
 import { expect, test, type Page } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/core/util/encode"
-import { fixture, pageMessages } from "./session-timeline.fixture"
+import { fixture, pageMessageList, pageMessages, timelineMessages } from "./session-timeline.fixture"
 import { trackPageErrors, expectNoSmokeErrors } from "../utils/errors"
 import { mockOpenCodeServer } from "../utils/mock-server"
 import { APP_READY_TIMEOUT, expectAppVisible, expectSessionTitle } from "../utils/waits"
@@ -115,6 +115,73 @@ test.describe("smoke: session timeline", () => {
       .toBeLessThanOrEqual(1)
   })
 
+  test("restores the persisted timeline position across tabs and reload", async ({ page }) => {
+    let messages = timelineMessages(140)
+    await mockOpenCodeServer(page, {
+      sessions: fixture.sessions,
+      provider: fixture.provider,
+      directory: fixture.directory,
+      project: fixture.project,
+      pageMessages: (sessionID, limit, before) =>
+        sessionID === fixture.targetID ? pageMessageList(messages, limit, before) : pageMessages(sessionID, limit, before),
+    })
+    await configureSmokePage(page, fixture.directory)
+    await page.addInitScript(
+      ({ dirBase64, sourceID, targetID }) => {
+        localStorage.setItem(
+          "opencode.global.dat:tabs",
+          JSON.stringify(
+            [sourceID, targetID].map((sessionId) => ({
+              type: "session",
+              server: "http://127.0.0.1:4096",
+              dirBase64,
+              sessionId,
+            })),
+          ),
+        )
+      },
+      { dirBase64: base64Encode(fixture.directory), sourceID: fixture.sourceID, targetID: fixture.targetID },
+    )
+
+    await navigateToSession(page, fixture.directory, fixture.sourceID, fixture.expected.sourceTitle)
+    await switchTitlebarSession(page, fixture.targetID, fixture.expected.targetTitle)
+    await waitForTimelineStable(page)
+    await pointAtTimeline(page)
+    await page.mouse.wheel(0, -1_000)
+    await expect
+      .poll(() =>
+        timelineScroller(page).evaluate(
+          (element) => element.scrollHeight - element.clientHeight - element.scrollTop,
+        ),
+      )
+      .toBeGreaterThan(100)
+    await page.waitForTimeout(500)
+    expect(await timelineScroller(page).evaluate((element) => element.scrollTop)).toBeGreaterThan(100)
+    expect(
+      await timelineScroller(page).evaluate(
+        (element) => element.scrollHeight - element.clientHeight - element.scrollTop,
+      ),
+    ).toBeGreaterThan(100)
+    const anchor = await firstVisibleTimelineRow(page)
+    expect(anchor?.id).toBeTruthy()
+    expect(anchor?.key).toBeTruthy()
+    await switchTitlebarSession(page, fixture.sourceID, fixture.expected.sourceTitle)
+    await switchTitlebarSession(page, fixture.targetID, fixture.expected.targetTitle)
+    await expect.poll(() => firstVisibleTimelineRow(page)).toEqual(anchor)
+    messages = [...messages, ...timelineMessages(120, 140)]
+    await page.reload()
+    await waitForTimelineStable(page)
+    await expect.poll(() => timelineScroller(page).evaluate((element) => element.scrollTop)).toBeGreaterThan(100)
+    await expect
+      .poll(() =>
+        timelineScroller(page).evaluate(
+          (element) => element.scrollHeight - element.clientHeight - element.scrollTop,
+        ),
+      )
+      .toBeGreaterThan(100)
+    await expect.poll(() => firstVisibleTimelineRow(page)).toEqual(anchor)
+  })
+
   test("paints cached session tabs at the latest message", async ({ page }) => {
     await mockOpenCodeServer(page, {
       sessions: fixture.sessions,
@@ -557,6 +624,23 @@ function timelineScroller(page: Page) {
   return page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
 }
 
+function firstVisibleTimelineRow(page: Page) {
+  return timelineScroller(page).evaluate((element) => {
+    const box = element.getBoundingClientRect()
+    const row = [...element.querySelectorAll<HTMLElement>("[data-timeline-key]")]
+      .map((row) => ({
+        id: row.querySelector<HTMLElement>("[data-message-id]")?.dataset.messageId,
+        key: row.dataset.timelineKey,
+        offset: Math.round(row.getBoundingClientRect().top - box.top),
+        rect: row.getBoundingClientRect(),
+      }))
+      .filter((row) => row.rect.bottom > box.top && row.rect.top < box.bottom)
+      .sort((a, b) => a.rect.top - b.rect.top)[0]
+    if (!row) return
+    return { id: row.id, key: row.key, offset: row.offset }
+  })
+}
+
 async function pointAtTimeline(page: Page) {
   const box = await timelineScroller(page).boundingBox()
   if (!box) throw new Error("Timeline scroller is not visible")

packages/app/src/app.tsx

@@ -32,7 +32,7 @@ import { CommentsProvider } from "@/context/comments"
 import { FileProvider } from "@/context/file"
 import { ServerSDKProvider, useServerSDK } from "@/context/server-sdk"
 import { ServerSyncProvider, useServerSync } from "@/context/server-sync"
-import { GlobalProvider, useGlobal } from "@/context/global"
+import { GlobalProvider } from "@/context/global"
 import { HighlightsProvider } from "@/context/highlights"
 import { LanguageProvider, type Locale, useLanguage } from "@/context/language"
 import { LayoutProvider } from "@/context/layout"
@@ -103,10 +103,10 @@ const SessionRoute = () => {
 
 const TargetSessionRoute = () => {
   const params = useParams<{ serverKey: string; id: string }>()
-  const global = useGlobal()
+  const server = useServer()
   const conn = createMemo(() => {
     const key = requireServerKey(params.serverKey)
-    return global.servers.list().find((item) => ServerConnection.key(item) === key)
+    return server.list.find((item) => ServerConnection.key(item) === key)
   })
 
   return (
@@ -221,27 +221,25 @@ function DraftRoute() {
 }
 
 function ResolvedDraftRoute(props: { draft: DraftTab }) {
-  const global = useGlobal()
-  const conn = createMemo(() => global.servers.list().find((item) => ServerConnection.key(item) === props.draft.server))
+  const server = useServer()
+  const conn = createMemo(() => server.list.find((item) => ServerConnection.key(item) === props.draft.server))
   const directory = () => props.draft.directory
   const serverKey = () => props.draft.server
 
   return (
-    <Show when={`${props.draft.server}\0${props.draft.directory}`} keyed>
-      <ServerSDKProvider server={conn}>
-        <ServerSyncProvider server={conn}>
-          <TargetServerScopedProviders directory={directory}>
-            <SDKProvider directory={directory}>
-              <DirectoryDataProvider directory={directory} server={serverKey}>
-                <DraftProviders>
-                  <NewSession />
-                </DraftProviders>
-              </DirectoryDataProvider>
-            </SDKProvider>
-          </TargetServerScopedProviders>
-        </ServerSyncProvider>
-      </ServerSDKProvider>
-    </Show>
+    <ServerSDKProvider server={conn}>
+      <ServerSyncProvider server={conn}>
+        <TargetServerScopedProviders directory={directory}>
+          <SDKProvider directory={directory}>
+            <DirectoryDataProvider directory={directory} server={serverKey}>
+              <DraftProviders>
+                <NewSession />
+              </DraftProviders>
+            </DirectoryDataProvider>
+          </SDKProvider>
+        </TargetServerScopedProviders>
+      </ServerSyncProvider>
+    </ServerSDKProvider>
   )
 }
 
@@ -590,31 +588,18 @@ function Routes() {
       </Route>
       <Show when={settings.general.newLayoutDesigns()}>
         <Route path="/" component={NewHome} />
-        <Route path="/:dir/session/:id" component={LegacyTargetSessionRoute} />
+        <Route
+          path="/:dir/session/:id"
+          component={() => {
+            const server = useServer()
+            const { id } = useParams()
+
+            return <Navigate href={`/server/${server.key}/session/${id}`} />
+          }}
+        />
       </Show>
       <Route path="/new-session" component={DraftRoute} />
       <Route path="/server/:serverKey/session/:id" component={TargetSessionRoute} />
     </>
   )
 }
-
-function LegacyTargetSessionRoute() {
-  const server = useServer()
-  const tabs = useTabs()
-  const params = useParams<{ id: string }>()
-
-  return (
-    <Show when={tabs.ready()}>
-      <Navigate
-        href={sessionHref(
-          legacySessionServer(
-            tabs.store.filter((item) => item.type === "session"),
-            params.id,
-            server.key,
-          ),
-          params.id,
-        )}
-      />
-    </Show>
-  )
-}

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

@@ -15,6 +15,7 @@ import { useLayout } from "@/context/layout"
 import { useFile } from "@/context/file"
 import { useLanguage } from "@/context/language"
 import { usePlatform } from "@/context/platform"
+import { useServer } from "@/context/server"
 import { useSettings } from "@/context/settings"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { createSessionTabs } from "@/pages/session/helpers"
@@ -271,6 +272,7 @@ export function DialogSelectFile(props: { mode?: DialogSelectFileMode; onOpenFil
   const command = useCommand()
   const language = useLanguage()
   const platform = usePlatform()
+  const server = useServer()
   const settings = useSettings()
   const layout = useLayout()
   const file = useFile()
@@ -391,10 +393,10 @@ export function DialogSelectFile(props: { mode?: DialogSelectFileMode; onOpenFil
     state.cleanup?.()
   })
 
-  if (filesOnly() && platform.platform === "desktop" && settings.general.newLayoutDesigns()) {
+  if (filesOnly() && platform.platform === "desktop" && settings.general.newLayoutDesigns() && server.current) {
     return (
       <DialogSelectFileV2
-        server={serverSDK().server}
+        server={server.current}
         mode="file"
         start={projectDirectory()}
         title={language.t("session.header.searchFiles")}

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

@@ -2,7 +2,7 @@
 import { createStore } from "solid-js/store"
 import type { Todo } from "@opencode-ai/sdk/v2"
 import { createPromptState } from "@/context/prompt"
-import { SessionComposerRegion, createSessionComposerRegionController } from "@/pages/session/composer"
+import { SessionComposerRegion } from "@/pages/session/composer"
 import { createPromptInputHistory, PromptInput } from "./prompt-input"
 
 function createPromptInputStoryRuntime() {
@@ -54,6 +54,12 @@ function PromptInputExample() {
       paid: true,
       loading: false,
     },
+    projects: {
+      available: [{ name: "Story project", worktree: "/tmp/story", sandboxes: [] }],
+      directory: "/tmp/story",
+      select() {},
+      add() {},
+    },
     session: {
       id: "story-session",
       tabs: {
@@ -136,6 +142,7 @@ function PromptInputWithOpenDock() {
       paid: true,
       loading: false,
     },
+    projects: { available: [], directory: "/tmp/story", select: () => {}, add: () => {} },
     session: {
       id: "story-session",
       tabs: {
@@ -159,35 +166,22 @@ function PromptInputWithOpenDock() {
     closing: () => false,
     opening: () => false,
   }
+
   return (
     <SessionComposerRegion
-      controller={createSessionComposerRegionController({
-        state,
-        sessionKey: () => "story-session",
-        sessionID: () => "story-session",
-        prompt: input.state,
-        ready: () => true,
-        centered: () => false,
-        todo: {
-          collapsed: () => controls.todoCollapsed,
-          onToggle: () => setControls("todoCollapsed", (collapsed) => !collapsed),
-        },
-        followup: () => undefined,
-        revert: () => undefined,
-        onResponseSubmit: () => {},
-        openParent: () => {},
-        setPromptRef: () => {},
-        setDockRef: () => {},
-      })}
-      promptInput={
-        <PromptInput
-          controls={inputControls}
-          {...input}
-          ref={() => {}}
-          newSessionWorktree=""
-          onNewSessionWorktreeReset={() => {}}
-        />
-      }
+      state={state}
+      sessionKey="story-session"
+      sessionID="story-session"
+      controls={inputControls}
+      promptInput={{ ...input, ref: () => {}, newSessionWorktree: "", onNewSessionWorktreeReset: () => {} }}
+      todo={{
+        collapsed: controls.todoCollapsed,
+        onToggle: () => setControls("todoCollapsed", (collapsed) => !collapsed),
+      }}
+      ready
+      centered={false}
+      onResponseSubmit={() => {}}
+      setPromptDockRef={() => {}}
     />
   )
 }

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

@@ -4,6 +4,8 @@ import {
   createEffect,
   on,
   Component,
+  splitProps,
+  For,
   Show,
   onCleanup,
   createMemo,
@@ -11,8 +13,10 @@ import {
   createResource,
   Switch,
   Match,
+  type ComponentProps,
   type JSX,
 } from "solid-js"
+import { Popover as KobaltePopover } from "@kobalte/core/popover"
 import { createStore, type SetStoreFunction, type Store } from "solid-js/store"
 import type { useLocal } from "@/context/local"
 import { selectionFromLines, type SelectedLineRange, useFile } from "@/context/file"
@@ -32,7 +36,7 @@ import { useSync } from "@/context/sync"
 import { useComments } from "@/context/comments"
 import { Button } from "@opencode-ai/ui/button"
 import { DockShellForm, DockTray } from "@opencode-ai/ui/dock-surface"
-import { Icon } from "@opencode-ai/ui/icon"
+import { Icon, type IconProps } from "@opencode-ai/ui/icon"
 import { ProviderIcon } from "@opencode-ai/ui/provider-icon"
 import { Tooltip, TooltipKeybind } from "@opencode-ai/ui/tooltip"
 import { IconButton } from "@opencode-ai/ui/icon-button"
@@ -66,6 +70,8 @@ import { promptPlaceholder } from "./prompt-input/placeholder"
 import { createPromptInputTransientState } from "./prompt-input/transient-state"
 import { showToast } from "@/utils/toast"
 import { ImagePreview } from "@opencode-ai/ui/image-preview"
+import { pathKey } from "@/utils/path-key"
+import { displayName } from "@/pages/layout/helpers"
 
 export type PromptInputState = ReturnType<typeof usePrompt>
 
@@ -93,6 +99,12 @@ export type PromptInputControls = {
     paid: boolean
     loading: boolean
   }
+  projects: {
+    available: { name?: string; worktree: string; sandboxes?: string[] }[]
+    directory: string
+    select: (worktree: string) => void
+    add: (title: string) => void
+  }
   session: {
     id?: string
     tabs: {
@@ -163,7 +175,6 @@ export interface PromptInputProps {
   onQueue?: (draft: FollowupDraft) => void
   onAbort?: () => void
   onSubmit?: () => void
-  toolbar?: JSX.Element
 }
 
 const EXAMPLES = [
@@ -212,6 +223,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
   let fileInputRef: HTMLInputElement | undefined
   let scrollRef!: HTMLDivElement
   let slashPopoverRef!: HTMLDivElement
+  let projectSearchRef: HTMLInputElement | undefined
 
   const mirror = { input: false }
   const inset = 56
@@ -339,6 +351,11 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     () => prompt.capture(),
     Math.floor(Math.random() * EXAMPLES.length),
   )
+  const [picker, setPicker] = createStore({
+    projectOpen: false,
+    projectSearch: "",
+  })
+
   const buttonsSpring = useSpring(() => (store.mode === "normal" ? 1 : 0), { visualDuration: 0.2, bounce: 0 })
   const motion = (value: number) => ({
     opacity: value,
@@ -1375,7 +1392,72 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
   }))
 
   const newSession = () => props.variant === "new-session"
+  const projects = createMemo(() => props.controls.projects.available)
+  const projectForDirectory = (directory: string | undefined) => {
+    if (!directory) return
+    const key = pathKey(directory)
+    return projects().find(
+      (project) => pathKey(project.worktree) === key || project.sandboxes?.some((sandbox) => pathKey(sandbox) === key),
+    )
+  }
+  const selectedProject = createMemo(() => projectForDirectory(props.controls.projects.directory))
+  const projectResults = createMemo(() => {
+    const search = picker.projectSearch.trim().toLowerCase()
+    if (!search) return projects()
+    return projects().filter((project) => displayName(project).toLowerCase().includes(search))
+  })
   const showAgentControl = createMemo(() => props.controls.agents.visible && props.controls.agents.options.length > 0)
+  const selectProject = (worktree: string) => {
+    setPicker({
+      projectOpen: false,
+      projectSearch: "",
+    })
+    if (pathKey(worktree) === pathKey(selectedProject()?.worktree ?? "")) {
+      restoreFocus()
+      return
+    }
+    props.controls.projects.select(worktree)
+    restoreFocus()
+  }
+  const addProject = () => {
+    props.controls.projects.add(language.t("command.project.open"))
+  }
+
+  const projectPickerState = createMemo<ComposerPickerState>(() => ({
+    open: picker.projectOpen,
+    trigger: {
+      action: "prompt-project",
+      icon: "folder",
+      label: selectedProject() ? displayName(selectedProject()!) : language.t("session.new.project.new"),
+      class: "max-w-[203px]",
+      style: control(),
+      onPress: () => setPicker("projectOpen", true),
+    },
+    search: picker.projectSearch,
+    searchPlaceholder: language.t("session.new.project.search"),
+    clearLabel: language.t("common.clear"),
+    items: projectResults().map((project) => ({
+      icon: "folder",
+      label: displayName(project),
+      selected: selectedProject()?.worktree === project.worktree,
+      onSelect: () => selectProject(project.worktree),
+    })),
+    action: {
+      icon: "plus",
+      label: language.t("session.new.project.add"),
+      onSelect: () => {
+        setPicker("projectOpen", false)
+        void addProject()
+      },
+    },
+    onOpenChange: (open) => {
+      setPicker("projectOpen", open)
+      if (open) requestAnimationFrame(() => projectSearchRef?.focus())
+    },
+    onSearchInput: (value) => setPicker("projectSearch", value),
+    onSearchClear: () => setPicker("projectSearch", ""),
+    searchRef: (el) => (projectSearchRef = el),
+  }))
   const agentControlState = createMemo<ComposerAgentControlState>(() => ({
     title: language.t("command.agent.cycle"),
     keybind: command.keybind("agent.cycle"),
@@ -1387,6 +1469,15 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
       restoreFocus()
     },
   }))
+  const newProjectTriggerState = createMemo<ComposerPickerTriggerState>(() => ({
+    action: "prompt-project",
+    icon: "folder-add-left",
+    label: language.t("session.new.project.new"),
+    class: "max-w-[160px]",
+    style: control(),
+    onPress: () => void addProject(),
+  }))
+
   return (
     <div class="relative size-full flex flex-col gap-0">
       {(promptReady(), null)}
@@ -1517,7 +1608,9 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                   <Show when={showAgentControl()}>
                     <ComposerAgentControl state={agentControlState()} />
                   </Show>
-                  {props.toolbar}
+                  <Show when={newSession() && !selectedProject()}>
+                    <ComposerPickerTrigger state={newProjectTriggerState()} />
+                  </Show>
                   <ComposerModelControl state={modelControlState()} />
                   <Show when={store.mode !== "shell" && showVariantControl()}>
                     <div
@@ -1571,6 +1664,11 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                 </Tooltip>
               </div>
             </DockShellForm>
+            <Show when={newSession() && selectedProject()}>
+              <div class="flex h-7 min-w-0 items-center gap-0 px-2">
+                <ComposerPicker state={projectPickerState()} />
+              </div>
+            </Show>
           </div>
         </Match>
         <Match when>
@@ -1912,6 +2010,37 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
   )
 }
 
+type ComposerPickerItemState = {
+  icon: IconProps["name"]
+  label: string
+  selected?: boolean
+  onSelect: () => void
+}
+
+type ComposerPickerTriggerState = {
+  action: string
+  icon?: IconProps["name"]
+  label: string
+  class?: string
+  style: JSX.CSSProperties | undefined
+  onPress: () => void
+}
+
+type ComposerPickerState = {
+  open: boolean
+  trigger: ComposerPickerTriggerState
+  search: string
+  searchPlaceholder: string
+  clearLabel: string
+  items: ComposerPickerItemState[]
+  action: ComposerPickerItemState
+  listClass?: string
+  searchRef: (el: HTMLInputElement) => void
+  onOpenChange: (open: boolean) => void
+  onSearchInput: (value: string) => void
+  onSearchClear: () => void
+}
+
 type ComposerAgentControlState = {
   title: string
   keybind: string
@@ -1934,6 +2063,90 @@ type ComposerModelControlState = {
   onUnpaidClick: () => void
 }
 
+function ComposerPickerTrigger(props: ComponentProps<"button"> & { state: ComposerPickerTriggerState }) {
+  const [local, rest] = splitProps(props, ["state", "class", "style", "onClick"])
+  return (
+    <button
+      {...rest}
+      data-action={local.state.action}
+      type="button"
+      class={`flex h-7 min-w-0 items-center gap-1.5 rounded px-2 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint transition-colors hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none ${local.state.class ?? ""}`}
+      style={local.state.style}
+      onClick={() => local.state.onPress()}
+    >
+      <Show when={local.state.icon}>
+        {(icon) => <Icon name={icon()} size="small" class="shrink-0 text-v2-icon-icon-muted" />}
+      </Show>
+      <span class="min-w-0 truncate leading-5">{local.state.label}</span>
+      <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
+    </button>
+  )
+}
+
+function ComposerPickerMenuItem(props: { state: ComposerPickerItemState }) {
+  return (
+    <button
+      type="button"
+      class="flex h-7 w-full items-center gap-2 rounded px-3 text-left text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none"
+      onClick={props.state.onSelect}
+    >
+      <Icon name={props.state.icon} size="small" class="shrink-0 text-v2-icon-icon-base" />
+      <span class="min-w-0 flex-1 truncate leading-5">{props.state.label}</span>
+      <Show when={props.state.selected}>
+        <Icon name="check-small" size="small" class="shrink-0 text-v2-icon-icon-base" />
+      </Show>
+    </button>
+  )
+}
+
+function ComposerPicker(props: { state: ComposerPickerState }) {
+  return (
+    <KobaltePopover
+      open={props.state.open}
+      placement="bottom-start"
+      gutter={4}
+      modal={false}
+      onOpenChange={props.state.onOpenChange}
+    >
+      <KobaltePopover.Trigger as={ComposerPickerTrigger} state={props.state.trigger} />
+      <KobaltePopover.Portal>
+        <KobaltePopover.Content
+          class="w-[243px] overflow-hidden rounded-md bg-v2-background-bg-layer-01 shadow-[var(--v2-elevation-floating)] focus:outline-none"
+          onOpenAutoFocus={(event) => event.preventDefault()}
+        >
+          <div class={`flex flex-col p-0.5 ${props.state.listClass ?? ""}`}>
+            <div class="flex h-7 items-center gap-2 rounded px-3 text-v2-icon-icon-muted">
+              <Icon name="magnifying-glass" size="small" class="shrink-0" />
+              <input
+                ref={props.state.searchRef}
+                value={props.state.search}
+                placeholder={props.state.searchPlaceholder}
+                class="h-7 min-w-0 flex-1 border-0 bg-transparent text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base outline-none placeholder:text-v2-text-text-faint"
+                onInput={(event) => props.state.onSearchInput(event.currentTarget.value)}
+              />
+              <Show when={props.state.search.trim()}>
+                <button
+                  type="button"
+                  class="flex size-5 items-center justify-center rounded text-v2-icon-icon-muted hover:bg-v2-overlay-simple-overlay-hover"
+                  onClick={props.state.onSearchClear}
+                  aria-label={props.state.clearLabel}
+                >
+                  <Icon name="close-small" size="small" />
+                </button>
+              </Show>
+            </div>
+            <For each={props.state.items}>{(item) => <ComposerPickerMenuItem state={item} />}</For>
+          </div>
+          <div class="h-px bg-v2-border-border-muted" />
+          <div class="flex flex-col p-0.5">
+            <ComposerPickerMenuItem state={props.state.action} />
+          </div>
+        </KobaltePopover.Content>
+      </KobaltePopover.Portal>
+    </KobaltePopover>
+  )
+}
+
 function ComposerAgentControl(props: { state: ComposerAgentControlState }) {
   return (
     <div class="relative">

packages/app/src/components/prompt-project-selector.tsx

@@ -1,278 +0,0 @@
-import { Popover } from "@kobalte/core/popover"
-import { For, Show, splitProps, type Accessor, type ComponentProps } from "solid-js"
-import { createStore } from "solid-js/store"
-import { Icon } from "@opencode-ai/ui/icon"
-import { ProjectAvatar } from "@opencode-ai/ui/v2/project-avatar-v2"
-import { getProjectAvatarVariant } from "@/context/layout"
-import { useLanguage } from "@/context/language"
-import { displayName, getProjectAvatarSource } from "@/pages/layout/helpers"
-import { pathKey } from "@/utils/path-key"
-
-export type PromptProject = {
-  name?: string
-  id?: string
-  worktree: string
-  sandboxes?: string[]
-  icon?: { color?: string; url?: string; override?: string }
-  server?: { key: string; name: string }
-}
-
-export type PromptProjectControls = {
-  available: PromptProject[]
-  directory: string
-  server?: string
-  select: (worktree: string, server?: string) => void
-  add: (title: string, server?: string) => void
-}
-
-export function createPromptProjectController(input: {
-  controls: Accessor<PromptProjectControls>
-  onDone: () => void
-}) {
-  const language = useLanguage()
-  const [store, setStore] = createStore({ open: false, search: "" })
-  let searchRef: HTMLInputElement | undefined
-
-  const selected = () => {
-    const key = pathKey(input.controls().directory)
-    return input
-      .controls()
-      .available.find(
-        (project) =>
-          (!project.server || project.server.key === input.controls().server) &&
-          (pathKey(project.worktree) === key || project.sandboxes?.some((sandbox) => pathKey(sandbox) === key)),
-      )
-  }
-  const projects = () => {
-    const search = store.search.trim().toLowerCase()
-    if (!search) return input.controls().available
-    return input.controls().available.filter((project) => displayName(project).toLowerCase().includes(search))
-  }
-  const servers = () =>
-    input
-      .controls()
-      .available.map((project) => project.server)
-      .filter((server, index, all) => server && all.findIndex((item) => item?.key === server.key) === index)
-  const close = () => {
-    setStore({ open: false, search: "" })
-    input.onDone()
-  }
-  const select = (project: PromptProject) => {
-    if (
-      pathKey(project.worktree) !== pathKey(selected()?.worktree ?? "") ||
-      project.server?.key !== selected()?.server?.key
-    ) {
-      input.controls().select(project.worktree, project.server?.key)
-    }
-    close()
-  }
-  const add = (server?: string) => {
-    setStore("open", false)
-    input.controls().add(language.t("command.project.open"), server)
-  }
-
-  return {
-    selected,
-    projects,
-    servers,
-    open: () => store.open,
-    search: () => store.search,
-    labels: {
-      add: () => language.t("session.new.project.add"),
-      clear: () => language.t("common.clear"),
-      new: () => language.t("session.new.project.new"),
-      search: () => language.t("session.new.project.search"),
-    },
-    add,
-    select,
-    setOpen(open: boolean) {
-      setStore("open", open)
-      if (open) requestAnimationFrame(() => searchRef?.focus())
-    },
-    setSearch(value: string) {
-      setStore("search", value)
-    },
-    setSearchRef(el: HTMLInputElement) {
-      searchRef = el
-    },
-  }
-}
-
-export type PromptProjectController = ReturnType<typeof createPromptProjectController>
-
-export function PromptProjectSelector(props: { controller: PromptProjectController }) {
-  return (
-    <Popover
-      open={props.controller.open()}
-      placement="bottom-start"
-      gutter={4}
-      modal={false}
-      onOpenChange={(open) => props.controller.setOpen(open)}
-    >
-      <Popover.Trigger as={ProjectTrigger} controller={props.controller} />
-      <Popover.Portal>
-        <Popover.Content
-          class="w-[243px] overflow-hidden rounded-md bg-v2-background-bg-layer-01 shadow-[var(--v2-elevation-floating)] focus:outline-none"
-          onOpenAutoFocus={(event) => event.preventDefault()}
-        >
-          <div class="flex flex-col p-0.5">
-            <div class="flex h-7 items-center gap-2 rounded px-3 text-v2-icon-icon-muted">
-              <Icon name="magnifying-glass" size="small" class="shrink-0" />
-              <input
-                ref={(el) => props.controller.setSearchRef(el)}
-                value={props.controller.search()}
-                placeholder={props.controller.labels.search()}
-                class="h-7 min-w-0 flex-1 border-0 bg-transparent text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base outline-none placeholder:text-v2-text-text-faint"
-                onInput={(event) => props.controller.setSearch(event.currentTarget.value)}
-              />
-              <Show when={props.controller.search().trim()}>
-                <button
-                  type="button"
-                  class="flex size-5 items-center justify-center rounded text-v2-icon-icon-muted hover:bg-v2-overlay-simple-overlay-hover"
-                  onClick={() => props.controller.setSearch("")}
-                  aria-label={props.controller.labels.clear()}
-                >
-                  <Icon name="close-small" size="small" />
-                </button>
-              </Show>
-            </div>
-            <Show
-              when={props.controller.servers().length > 1}
-              fallback={
-                <For each={props.controller.projects()}>
-                  {(project) => (
-                    <ProjectItem
-                      project={project}
-                      selected={props.controller.selected()}
-                      onSelect={props.controller.select}
-                    />
-                  )}
-                </For>
-              }
-            >
-              <For each={props.controller.servers()}>
-                {(server) => (
-                  <div>
-                    <div class="flex h-7 select-none items-center pl-1.5 pr-3 text-[11px] font-[530] leading-none tracking-[0.05px] text-v2-text-text-faint">
-                      {server!.name}
-                    </div>
-                    <For each={props.controller.projects().filter((project) => project.server?.key === server!.key)}>
-                      {(project) => (
-                        <ProjectItem
-                          project={project}
-                          selected={props.controller.selected()}
-                          onSelect={props.controller.select}
-                        />
-                      )}
-                    </For>
-                    <ProjectAction
-                      label={props.controller.labels.add()}
-                      onSelect={() => props.controller.add(server!.key)}
-                    />
-                  </div>
-                )}
-              </For>
-            </Show>
-          </div>
-          <Show when={props.controller.servers().length <= 1}>
-            <div class="h-px bg-v2-border-border-muted" />
-            <div class="flex flex-col p-0.5">
-              <ProjectAction
-                label={props.controller.labels.add()}
-                onSelect={() => props.controller.add(props.controller.servers()[0]?.key)}
-              />
-            </div>
-          </Show>
-        </Popover.Content>
-      </Popover.Portal>
-    </Popover>
-  )
-}
-
-export function PromptProjectAddButton(props: { controller: PromptProjectController }) {
-  return (
-    <button
-      data-action="prompt-project"
-      type="button"
-      class="flex h-7 min-w-0 max-w-[160px] items-center gap-1.5 rounded-sm px-2 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint transition-colors hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none"
-      onClick={() => props.controller.add()}
-    >
-      <Icon name="folder-add-left" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-      <span class="min-w-0 truncate leading-5">{props.controller.labels.new()}</span>
-      <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-    </button>
-  )
-}
-
-function ProjectTrigger(props: ComponentProps<"button"> & { controller: PromptProjectController }) {
-  const [local, rest] = splitProps(props, ["controller", "class", "onClick"])
-  const project = () => local.controller.selected()
-  return (
-    <button
-      {...rest}
-      data-action="prompt-project"
-      type="button"
-      class="flex h-7 min-w-0 max-w-[203px] items-center gap-1.5 rounded-sm px-2 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint transition-colors hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none"
-      onClick={() => local.controller.setOpen(true)}
-    >
-      <Show
-        when={project()}
-        fallback={<Icon name="folder-add-left" size="small" class="shrink-0 text-v2-icon-icon-muted" />}
-      >
-        {(item) => (
-          <ProjectAvatar
-            fallback={displayName(item())}
-            src={getProjectAvatarSource(item().id, item().icon)}
-            variant={getProjectAvatarVariant(item().icon?.color)}
-          />
-        )}
-      </Show>
-      <span class="min-w-0 truncate leading-5">
-        {project() ? displayName(project()!) : local.controller.labels.new()}
-      </span>
-      <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-    </button>
-  )
-}
-
-function ProjectItem(props: {
-  project: PromptProject
-  selected?: PromptProject
-  onSelect: (project: PromptProject) => void
-}) {
-  return (
-    <button
-      type="button"
-      class="flex h-7 w-full items-center gap-2 rounded-sm px-3 text-left text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none"
-      onClick={() => props.onSelect(props.project)}
-    >
-      <ProjectAvatar
-        fallback={displayName(props.project)}
-        src={getProjectAvatarSource(props.project.id, props.project.icon)}
-        variant={getProjectAvatarVariant(props.project.icon?.color)}
-      />
-      <span class="min-w-0 flex-1 truncate leading-5">{displayName(props.project)}</span>
-      <Show
-        when={
-          props.selected?.worktree === props.project.worktree &&
-          props.selected?.server?.key === props.project.server?.key
-        }
-      >
-        <Icon name="check-small" size="small" class="shrink-0 text-v2-icon-icon-base" />
-      </Show>
-    </button>
-  )
-}
-
-function ProjectAction(props: { label: string; onSelect: () => void }) {
-  return (
-    <button
-      type="button"
-      class="flex h-7 w-full items-center gap-2 rounded-sm px-3 text-left text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none"
-      onClick={props.onSelect}
-    >
-      <Icon name="plus" size="small" />
-      <span class="min-w-0 flex-1 truncate leading-5">{props.label}</span>
-    </button>
-  )
-}

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

@@ -1,43 +0,0 @@
-import { useParams } from "@solidjs/router"
-import { onCleanup } from "solid-js"
-import { useCommand } from "@/context/command"
-import { useLanguage } from "@/context/language"
-import { useDialog } from "@opencode-ai/ui/context/dialog"
-
-export function useSettingsDialog() {
-  const dialog = useDialog()
-  const params = useParams<{ id?: string }>()
-  let run = 0
-  let dead = false
-
-  onCleanup(() => {
-    dead = true
-  })
-
-  return () => {
-    const current = ++run
-    const sessionID = params.id
-    void import("@/components/settings-v2").then((module) => {
-      if (dead || run !== current) return
-      void dialog.show(() => <module.DialogSettings sessionID={sessionID} />)
-    })
-  }
-}
-
-export function useSettingsCommand() {
-  const command = useCommand()
-  const language = useLanguage()
-  const show = useSettingsDialog()
-
-  command.register("settings", () => [
-    {
-      id: "settings.open",
-      title: language.t("command.settings.open"),
-      category: language.t("command.category.settings"),
-      keybind: "mod+comma",
-      onSelect: show,
-    },
-  ])
-
-  return show
-}

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

@@ -11,9 +11,7 @@ import { SettingsModelsV2 } from "./models"
 import "./settings-v2.css"
 import { SettingsServersV2 } from "./servers"
 
-export const DialogSettings: Component<{
-  sessionID?: string
-}> = (props) => {
+export const DialogSettings: Component = () => {
   const language = useLanguage()
   const platform = usePlatform()
 
@@ -64,7 +62,7 @@ export const DialogSettings: Component<{
           </div>
         </TabsV2.List>
         <TabsV2.Content value="general" class="settings-v2-panel">
-          <SettingsGeneralV2 sessionID={props.sessionID} />
+          <SettingsGeneralV2 />
         </TabsV2.Content>
         <TabsV2.Content value="shortcuts" class="settings-v2-panel">
           <SettingsKeybinds v2 />

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

@@ -6,6 +6,7 @@ import { Switch } from "@opencode-ai/ui/v2/switch-v2"
 import { TextInputV2 } from "@opencode-ai/ui/v2/text-input-v2"
 import { useTheme, type ColorScheme } from "@opencode-ai/ui/theme/context"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { useParams } from "@solidjs/router"
 import { useLanguage } from "@/context/language"
 import { usePermission } from "@/context/permission"
 import { usePlatform } from "@/context/platform"
@@ -24,6 +25,7 @@ import {
   terminalInput,
   useSettings,
 } from "@/context/settings"
+import { decode64 } from "@/utils/base64"
 import { playSoundById, SOUND_OPTIONS } from "@/utils/sound"
 import { Link } from "../link"
 import { SettingsListV2 } from "./parts/list"
@@ -80,46 +82,50 @@ const playDemoSound = (id: string | undefined) => {
   }, 100)
 }
 
-export const SettingsGeneralV2: Component<{
-  sessionID?: string
-}> = (props) => {
+export const SettingsGeneralV2: Component = () => {
   const theme = useTheme()
   const language = useLanguage()
   const permission = usePermission()
   const platform = usePlatform()
   const dialog = useDialog()
+  const params = useParams()
   const settings = useSettings()
-  const serverSync = useServerSync()
-  const serverSdk = useServerSDK()
   const mobile = createMediaQuery("(max-width: 767px)")
 
   const updater = useUpdaterAction()
 
-  const dir = createMemo(() => {
-    if (!props.sessionID) return undefined
-    return serverSync().session.lineage.peek(props.sessionID)?.session.directory
-  })
+  const dir = createMemo(() => decode64(params.dir))
   const accepting = createMemo(() => {
     const value = dir()
-    if (!value || !props.sessionID) return false
-    return permission.isAutoAccepting(props.sessionID, value)
+    if (!value) return false
+    if (!params.id) return permission.isAutoAcceptingDirectory(value)
+    return permission.isAutoAccepting(params.id, value)
   })
 
   const toggleAccept = (checked: boolean) => {
     const value = dir()
-    if (!value || !props.sessionID) return
+    if (!value) return
 
-    if (checked) {
-      permission.enableAutoAccept(props.sessionID, value)
+    if (!params.id) {
+      if (permission.isAutoAcceptingDirectory(value) === checked) return
+      permission.toggleAutoAcceptDirectory(value)
       return
     }
 
-    permission.disableAutoAccept(props.sessionID, value)
+    if (checked) {
+      permission.enableAutoAccept(params.id, value)
+      return
+    }
+
+    permission.disableAutoAccept(params.id, value)
   }
   const desktop = createMemo(() => platform.platform === "desktop")
 
   const themeOptions = createMemo<ThemeOption[]>(() => theme.ids().map((id) => ({ id, name: theme.name(id) })))
 
+  const serverSync = useServerSync()
+  const serverSdk = useServerSDK()
+
   const [shells] = createResource(
     () =>
       serverSdk()

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

@@ -5,8 +5,7 @@ import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { Popover } from "@opencode-ai/ui/popover"
 import { Suspense, createMemo, createSignal, lazy, Show, type JSX } from "solid-js"
 import { useLanguage } from "@/context/language"
-import { ServerConnection, useServer } from "@/context/server"
-import { useServerSDK } from "@/context/server-sdk"
+import { useServer } from "@/context/server"
 import { useSync } from "@/context/sync"
 import { useGlobal } from "@/context/global"
 
@@ -82,11 +81,11 @@ export function StatusPopoverV2(props: { scope?: "server" }) {
 
 function DirectoryStatusPopover() {
   const language = useLanguage()
-  const server = useServerSDK()
+  const server = useServer()
   const global = useGlobal()
   const sync = useSync()
   const [shown, setShown] = createSignal(false)
-  const serverHealth = () => global.servers.health[ServerConnection.key(server().server)]?.healthy
+  const serverHealth = () => global.servers.health[server.key]?.healthy
   const ready = createMemo(() => serverHealth() === false || sync().data.mcp_ready)
   const mcpIssue = createMemo(() => {
     const mcp = Object.values(sync().data.mcp ?? {})

packages/app/src/components/terminal.tsx

@@ -10,7 +10,7 @@ import { matchKeybind, parseKeybind } from "@/context/command"
 import { useLanguage } from "@/context/language"
 import { usePlatform } from "@/context/platform"
 import { useSDK } from "@/context/sdk"
-import { useServerSDK } from "@/context/server-sdk"
+import { useServer } from "@/context/server"
 import { terminalFontFamily, useSettings } from "@/context/settings"
 import type { LocalPTY } from "@/context/terminal"
 import { disposeIfDisposable, getHoveredLinkText, setOptionIfSupported } from "@/utils/runtime-adapters"
@@ -160,15 +160,13 @@ export const Terminal = (props: TerminalProps) => {
   const settings = useSettings()
   const theme = useTheme()
   const language = useLanguage()
-  // Terminal captures its connection for the PTY lifetime, so callers must key it per server/session.
-  const connection = useServerSDK()().server
+  const server = useServer()
   const directory = sdk().directory
   const client = sdk().client
   const url = sdk().url
-  const auth = connection.http
+  const auth = server.current?.http
   const username = auth?.username ?? "opencode"
   const password = auth?.password ?? ""
-  const authToken = connection.type === "http" ? connection.authToken : false
   const sameOrigin = new URL(url, location.href).origin === location.origin
   let container!: HTMLDivElement
   const [local, others] = splitProps(props, ["pty", "class", "classList", "autoFocus", "onConnect", "onConnectError"])
@@ -542,7 +540,7 @@ export const Terminal = (props: TerminalProps) => {
             sameOrigin,
             username,
             password,
-            authToken,
+            authToken: server.current?.type === "http" ? server.current.authToken : false,
           }),
         )
         socket.binaryType = "arraybuffer"

packages/app/src/components/titlebar.tsx

@@ -319,12 +319,6 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                 return
               }
 
-              const activeTab = currentTab()
-              if (activeTab?.type === "draft") {
-                tabs.newDraft({ server: activeTab.server, directory: activeTab.directory }, "")
-                return
-              }
-
               const current = layout.projects.list()[0]
               if (current) {
                 tabs.newDraft({ server: server.key, directory: current.worktree }, "")

packages/app/src/context/layout-scroll.test.ts

@@ -61,4 +61,34 @@ describe("createScrollPersistence", () => {
     expect(scroll.scroll("session", "review")).toEqual({ x: 12, y: 34 })
     scroll.dispose()
   })
+
+  test("persists semantic scroll anchors", () => {
+    vi.useFakeTimers()
+    try {
+      let snapshot: Record<string, { x: number; y: number; anchor?: { id: string; key?: string; offset: number } }> = {}
+      const scroll = createScrollPersistence({
+        debounceMs: 10,
+        getSnapshot: () => snapshot,
+        onFlush: (_sessionKey, next) => {
+          snapshot = next
+        },
+      })
+
+      scroll.setScroll("session", "timeline", {
+        x: 1_000,
+        y: 400,
+        anchor: { id: "message-1", key: "assistant-part:message-1:part-2", offset: 24 },
+      })
+      vi.advanceTimersByTime(10)
+
+      expect(snapshot.timeline).toEqual({
+        x: 1_000,
+        y: 400,
+        anchor: { id: "message-1", key: "assistant-part:message-1:part-2", offset: 24 },
+      })
+      scroll.dispose()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
 })

packages/app/src/context/layout-scroll.ts

@@ -3,6 +3,11 @@ import { createStore, produce } from "solid-js/store"
 export type SessionScroll = {
   x: number
   y: number
+  anchor?: {
+    id: string
+    key?: string
+    offset: number
+  }
 }
 
 type ScrollMap = Record<string, SessionScroll>
@@ -26,7 +31,11 @@ export function createScrollPersistence(opts: Options) {
     for (const key of Object.keys(input)) {
       const pos = input[key]
       if (!pos) continue
-      out[key] = { x: pos.x, y: pos.y }
+      out[key] = {
+        x: pos.x,
+        y: pos.y,
+        anchor: pos.anchor ? { id: pos.anchor.id, key: pos.anchor.key, offset: pos.anchor.offset } : undefined,
+      }
     }
 
     return out
@@ -63,9 +72,20 @@ export function createScrollPersistence(opts: Options) {
     seed(sessionKey)
 
     const prev = cache[sessionKey]?.[tab]
-    if (prev?.x === pos.x && prev?.y === pos.y) return
+    if (
+      prev?.x === pos.x &&
+      prev?.y === pos.y &&
+      prev?.anchor?.id === pos.anchor?.id &&
+      prev?.anchor?.key === pos.anchor?.key &&
+      prev?.anchor?.offset === pos.anchor?.offset
+    )
+      return
 
-    setCache(sessionKey, tab, { x: pos.x, y: pos.y })
+    setCache(sessionKey, tab, {
+      x: pos.x,
+      y: pos.y,
+      anchor: pos.anchor ? { id: pos.anchor.id, key: pos.anchor.key, offset: pos.anchor.offset } : undefined,
+    })
     dirty.add(sessionKey)
     schedule(sessionKey)
   }

packages/app/src/context/layout.tsx

@@ -17,7 +17,6 @@ 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"
-import { type DraftTab, useTabs } from "./tabs"
 
 export { createSessionKeyReader, ensureSessionKey, pruneSessionKeys }
 
@@ -160,17 +159,12 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
     const serverSdk = useServerSDK()
     const serverSync = useServerSync()
     const server = useServer()
-    const tabs = useTabs()
     const platform = usePlatform()
     const location = useLocation()
     const route = createMemo(() => {
       const value = currentRoute(location.pathname, location.search)
       if (value.type === "home") return value
       if (value.server) return value
-      if (value.type === "draft") {
-        const draft = tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === value.draftID)
-        if (draft) return { ...value, server: draft.server }
-      }
       return { ...value, server: server.key }
     })
 

packages/app/src/context/prompt.tsx

@@ -9,7 +9,7 @@ import { useServerSDK } from "./server-sdk"
 import type { ServerScope } from "@/utils/server-scope"
 import { useSDK } from "./sdk"
 import { useTabs, type Tab } from "./tabs"
-import { ServerConnection } from "./server"
+import { ServerConnection, useServer } from "./server"
 import { requireServerKey } from "@/utils/session-route"
 import { useSettings } from "./settings"
 
@@ -287,6 +287,7 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
     const sdk = useSDK()
     const [search] = useSearchParams<{ draftId?: string }>()
     const serverSDK = useServerSDK()
+    const server = useServer()
     const tabs = useTabs()
     const settings = useSettings()
     const cache = new Map<string, PromptCacheEntry>()
@@ -311,8 +312,7 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
     }
 
     const owner = getOwner()
-    const serverKey = () =>
-      params.serverKey ? requireServerKey(params.serverKey) : ServerConnection.key(serverSDK().server)
+    const serverKey = () => (params.serverKey ? requireServerKey(params.serverKey) : server.key)
     const scope = () =>
       search.draftId ? { draftID: search.draftId } : { dir: base64Encode(sdk().directory), id: params.id }
     const load = (scope: Scope) => {

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

@@ -269,7 +269,6 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
   })
 
   return {
-    server,
     scope,
     url: server.http.url,
     client: sdk,

packages/app/src/pages/home.tsx

@@ -33,7 +33,6 @@ import { usePlatform } from "@/context/platform"
 import { DateTime } from "luxon"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { useDirectoryPicker } from "@/components/directory-picker"
-import { useSettingsCommand } from "@/components/settings-dialog"
 import { DialogSelectServer, useServerManagementController } from "@/components/dialog-select-server"
 import { DialogServerV2 } from "@/components/settings-v2/dialog-server-v2"
 import { ServerConnection, serverName, useServer } from "@/context/server"
@@ -145,7 +144,6 @@ export function NewHome() {
   const command = useCommand()
   const notification = useNotification()
   const marked = useMarked()
-  const openSettings = useSettingsCommand()
   let focusSessionSearch: (() => void) | undefined
   const [state, setState] = createStore({
     search: "",
@@ -404,6 +402,12 @@ export function NewHome() {
     })
   }
 
+  function openSettings() {
+    void import("@/components/settings-v2").then((x) => {
+      dialog.show(() => <x.DialogSettings />)
+    })
+  }
+
   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">

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

@@ -3,12 +3,18 @@ import { useNavigate, useParams } from "@solidjs/router"
 import { DebugBar } from "@/components/debug-bar"
 import { HelpButton } from "@/components/help-button"
 import { Titlebar, type TitlebarUpdate } from "@/components/titlebar"
+import { useCommand } from "@/context/command"
+import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { useLanguage } from "@/context/language"
 import { useNotification } from "@/context/notification"
 import { usePlatform } from "@/context/platform"
 import { setNavigate } from "@/utils/notification-click"
 import { setV2Toast, ToastRegion } from "@/utils/toast"
 
 export default function NewLayout(props: ParentProps) {
+  const command = useCommand()
+  const dialog = useDialog()
+  const language = useLanguage()
   const platform = usePlatform()
   const notification = useNotification()
   const navigate = useNavigate()
@@ -22,6 +28,20 @@ export default function NewLayout(props: ParentProps) {
     notification.session.markViewed(params.id)
   })
 
+  command.register("layout", () => [
+    {
+      id: "settings.open",
+      title: language.t("command.settings.open"),
+      category: language.t("command.category.settings"),
+      keybind: "mod+comma",
+      onSelect: () => {
+        void import("@/components/settings-v2").then((x) => {
+          dialog.show(() => <x.DialogSettings />)
+        })
+      },
+    },
+  ])
+
   const update: TitlebarUpdate = {
     version: () => {
       const state = platform.updater?.state()

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

@@ -1,24 +1,18 @@
-import { Show, createEffect, createMemo, createResource, untrack } from "solid-js"
+import { createEffect, createMemo, onMount, untrack } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useSearchParams } from "@solidjs/router"
 import { NewSessionDesignView } from "@/components/session"
-import { PromptInput } from "@/components/prompt-input"
-import { useSettingsCommand } from "@/components/settings-dialog"
-import {
-  PromptProjectAddButton,
-  PromptProjectSelector,
-  createPromptProjectController,
-} from "@/components/prompt-project-selector"
 import { useComments } from "@/context/comments"
 import { usePrompt } from "@/context/prompt"
 import { useSDK } from "@/context/sdk"
 import { useSync } from "@/context/sync"
 import { useServerSync } from "@/context/server-sync"
-import { useLanguage } from "@/context/language"
-import { createPromptInputController, createPromptProjectControls } from "@/pages/session/composer"
+import {
+  createSessionComposerControls,
+  createSessionComposerState,
+  SessionComposerRegion,
+} from "@/pages/session/composer"
 import { useSessionKey } from "@/pages/session/session-layout"
-import { useComposerCommands } from "@/pages/session/use-composer-commands"
-import { NEW_SESSION_CONTENT_WIDTH } from "@/pages/session/new-session-layout"
 
 /**
  * The `/new-session` draft page. Unlike `session.tsx`, this only renders the prompt
@@ -31,25 +25,17 @@ export default function NewSessionPage() {
   const sync = useSync()
   const serverSync = useServerSync()
   const comments = useComments()
-  const language = useLanguage()
   const route = useSessionKey()
   const [searchParams, setSearchParams] = useSearchParams<{ draftId?: string; prompt?: string }>()
 
-  useComposerCommands()
-  useSettingsCommand()
-
   let inputRef: HTMLDivElement | undefined
 
-  const inputController = createPromptInputController({
+  const composer = createSessionComposerState()
+  const composerControls = createSessionComposerControls({
     sessionKey: route.sessionKey,
     sessionID: () => route.params.id,
     queryOptions: serverSync().queryOptions,
   })
-  const projectControls = createPromptProjectControls()
-  const projectController = createPromptProjectController({
-    controls: projectControls,
-    onDone: () => inputRef?.focus(),
-  })
 
   const [store, setStore] = createStore({
     worktree: "main",
@@ -72,15 +58,9 @@ export default function NewSessionPage() {
     })
   })
 
-  createEffect(() => {
-    if (!prompt.ready()) return
+  onMount(() => {
     requestAnimationFrame(() => inputRef?.focus())
   })
-  const ready = Promise.resolve()
-  const [promptReady] = createResource(
-    () => prompt.ready.promise ?? ready,
-    (promise) => promise.then(() => true),
-  )
 
   return (
     <div class="relative size-full overflow-hidden flex flex-col">
@@ -88,39 +68,26 @@ export default function NewSessionPage() {
         <div class="@container relative flex flex-col min-h-0 h-full bg-background-stronger flex-1">
           <div class="flex-1 min-h-0 overflow-hidden rounded-[10px]">
             <NewSessionDesignView>
-              <div class={NEW_SESSION_CONTENT_WIDTH}>
-                <Show
-                  when={prompt.ready() || promptReady()}
-                  fallback={
-                    <div class="w-full min-h-32 md:min-h-40 rounded-md border border-border-weak-base bg-background-base/50 px-4 py-3 text-text-weak pointer-events-none">
-                      {language.t("prompt.loading")}
-                    </div>
-                  }
-                >
-                  <div class="flex flex-col gap-3">
-                    <PromptInput
-                      controls={inputController()}
-                      variant="new-session"
-                      ref={(el) => {
-                        inputRef = el
-                      }}
-                      newSessionWorktree={newSessionWorktree()}
-                      onNewSessionWorktreeReset={() => setStore("worktree", "main")}
-                      onSubmit={() => comments.clear()}
-                      toolbar={
-                        <Show when={!projectController.selected()}>
-                          <PromptProjectAddButton controller={projectController} />
-                        </Show>
-                      }
-                    />
-                    <Show when={projectController.selected()}>
-                      <div class="flex h-7 min-w-0 items-center gap-0 px-2">
-                        <PromptProjectSelector controller={projectController} />
-                      </div>
-                    </Show>
-                  </div>
-                </Show>
-              </div>
+              <SessionComposerRegion
+                state={composer}
+                sessionKey={route.sessionKey()}
+                sessionID={route.params.id}
+                controls={composerControls()}
+                promptInput={{
+                  ref: (el) => {
+                    inputRef = el
+                  },
+                  newSessionWorktree: newSessionWorktree(),
+                  onNewSessionWorktreeReset: () => setStore("worktree", "main"),
+                  onSubmit: () => comments.clear(),
+                }}
+                todo={{ collapsed: false, onToggle: () => {} }}
+                ready
+                centered={false}
+                placement="inline"
+                onResponseSubmit={() => {}}
+                setPromptDockRef={() => {}}
+              />
             </NewSessionDesignView>
           </div>
         </div>

packages/app/src/pages/session.tsx

@@ -35,6 +35,7 @@ import { useComments } from "@/context/comments"
 import { useServerSync } from "@/context/server-sync"
 import { useLanguage } from "@/context/language"
 import { useLayout } from "@/context/layout"
+import type { SessionScroll } from "@/context/layout-scroll"
 import { usePrompt } from "@/context/prompt"
 import { usePlatform } from "@/context/platform"
 import { useSDK } from "@/context/sdk"
@@ -42,13 +43,10 @@ import { useServerSDK } from "@/context/server-sdk"
 import { useSettings } from "@/context/settings"
 import { useSync } from "@/context/sync"
 import { useTerminal } from "@/context/terminal"
-import { PromptInput } from "@/components/prompt-input"
-import { useSettingsCommand } from "@/components/settings-dialog"
 import { type FollowupDraft, sendFollowupDraft } from "@/components/prompt-input/submit"
 import {
-  createPromptInputController,
-  createSessionComposerController,
-  createSessionComposerRegionController,
+  createSessionComposerControls,
+  createSessionComposerState,
   SessionComposerRegion,
 } from "@/pages/session/composer"
 import {
@@ -66,7 +64,6 @@ import { useSessionLayout } from "@/pages/session/session-layout"
 import { syncSessionModel } from "@/pages/session/session-model-helpers"
 import { SessionSidePanel } from "@/pages/session/session-side-panel"
 import { TerminalPanel } from "@/pages/session/terminal-panel"
-import { useComposerCommands } from "@/pages/session/use-composer-commands"
 import { useSessionCommands } from "@/pages/session/use-session-commands"
 import { useSessionHashScroll } from "@/pages/session/use-session-hash-scroll"
 import { Identifier } from "@/utils/id"
@@ -159,8 +156,8 @@ export default function Page() {
     },
   })
 
-  const composer = createSessionComposerController()
-  const inputController = createPromptInputController({
+  const composer = createSessionComposerState()
+  const composerControls = createSessionComposerControls({
     sessionKey,
     sessionID: () => params.id,
     queryOptions: serverSync().queryOptions,
@@ -787,8 +784,6 @@ export default function Page() {
     inputRef?.focus()
   }
 
-  useComposerCommands()
-  useSettingsCommand()
   useSessionCommands({
     navigateMessageByOffset,
     setActiveMessage,
@@ -1082,6 +1077,15 @@ export default function Page() {
     working: () => true,
     overflowAnchor: "none",
   })
+  const timelineScroll = () => view().scroll("timeline")
+  const hasTimelineScroll = createMemo(() => layout.ready() && !!timelineScroll())
+  let timelineScrollSession = ""
+  let timelineRestoreGeneration = 0
+  const timelineScrollTop = () => {
+    const y = timelineScroll()?.y
+    if (y === Number.MAX_SAFE_INTEGER) return
+    return y
+  }
   createEffect(
     on(
       () => params.id,
@@ -1122,9 +1126,41 @@ export default function Page() {
       if (!target) return
 
       updateScrollState(target)
+      persistTimelineScroll(target)
     })
   }
 
+  const persistTimelineScroll = (el: HTMLDivElement) => {
+    if (!layout.ready() || timelineScrollSession !== sessionKey()) return
+    const max = el.scrollHeight - el.clientHeight
+    const box = el.getBoundingClientRect()
+    const anchor = [...el.querySelectorAll<HTMLElement>("[data-timeline-key]")]
+      .map((element) => ({
+        element,
+        message: element.querySelector<HTMLElement>("[data-message-id]"),
+        rect: element.getBoundingClientRect(),
+      }))
+      .filter((item) => item.rect.bottom > box.top && item.rect.top < box.bottom)
+      .sort((a, b) => a.rect.top - b.rect.top)[0]
+    view().setScroll("timeline", {
+      x: max,
+      y: max <= 1 || max - el.scrollTop <= 2 ? Number.MAX_SAFE_INTEGER : el.scrollTop,
+      anchor:
+        max > 1 && max - el.scrollTop > 2 && anchor?.message?.dataset.messageId && anchor.element.dataset.timelineKey
+          ? {
+              id: anchor.message.dataset.messageId,
+              key: anchor.element.dataset.timelineKey,
+              offset: anchor.rect.top - box.top,
+            }
+          : undefined,
+    })
+  }
+
+  const cancelTimelineScrollRestore = () => {
+    timelineRestoreGeneration += 1
+    timelineScrollSession = sessionKey()
+  }
+
   const resumeScroll = () => {
     setStore("messageId", undefined)
     autoScroll.resume()
@@ -1522,6 +1558,78 @@ export default function Page() {
     },
   )
 
+  const restoreTimelineScroll = (saved: SessionScroll) => {
+    const id = params.id
+    const owner = sessionOwnership.capture()
+    const key = sessionKey()
+    const generation = ++timelineRestoreGeneration
+    if (!id) return
+
+    const current = () => owner.current() && timelineRestoreGeneration === generation
+
+    const apply = () =>
+      owner.run(() => {
+        if (!scroller || !current()) return
+        autoScroll.pause()
+        const max = scroller.scrollHeight - scroller.clientHeight
+        const target = saved.anchor?.key
+          ? scroller.querySelector<HTMLElement>(`[data-timeline-key="${CSS.escape(saved.anchor.key)}"]`)
+          : saved.anchor
+            ? scroller.querySelector<HTMLElement>(`[data-message-id="${CSS.escape(saved.anchor.id)}"]`)
+            : undefined
+        if (saved.anchor && !target) {
+          revealMessage(saved.anchor.id)
+          return false
+        }
+        const top = target
+          ? scroller.scrollTop + target.getBoundingClientRect().top - scroller.getBoundingClientRect().top - saved.anchor!.offset
+          : max < saved.y + 100 && !historyMore() && saved.x > 0
+            ? (saved.y / saved.x) * max
+            : saved.y
+        const stable = Math.abs(scroller.scrollTop - top) < 1
+        scroller.scrollTop = top
+        scheduleScrollState(scroller)
+        return stable
+      })
+    apply()
+
+    const load = async () => {
+      try {
+        while (current()) {
+          const found = !saved.anchor || visibleUserMessages().some((message) => message.id === saved.anchor?.id)
+          const tall = !!scroller && scroller.scrollHeight - scroller.clientHeight >= saved.y + 100
+          if ((found && tall) || !historyMore()) break
+          const before = timeline.messages().length
+          await sync().session.history.loadMore(id)
+          if (!current() || timeline.messages().length <= before) break
+          await new Promise<void>((resolve) => requestAnimationFrame(() => requestAnimationFrame(() => resolve())))
+          apply()
+        }
+      } catch (error) {
+        if (current()) {
+          timelineScrollSession = key
+          console.error("[session] failed to restore timeline scroll", error)
+        }
+        return
+      }
+      apply()
+      let frames = 0
+      let stable = 0
+      const settle = () => {
+        if (!current()) return
+        stable = apply() ? stable + 1 : 0
+        frames += 1
+        if (stable >= 10 || frames >= 180) {
+          timelineScrollSession = key
+          return
+        }
+        requestAnimationFrame(settle)
+      }
+      requestAnimationFrame(settle)
+    }
+    void load()
+  }
+
   const { clearMessageHash, scrollToMessage } = useSessionHashScroll({
     sessionKey,
     sessionID: () => params.id,
@@ -1544,6 +1652,18 @@ export default function Page() {
     scroller: () => scroller,
     anchor,
     revealMessage: (id) => revealMessage(id),
+    scrollReady: layout.ready,
+    hasSavedScroll: hasTimelineScroll,
+    restoreScroll: () => {
+      const saved = timelineScroll()
+      const el = scroller
+      if (!saved || saved.y === Number.MAX_SAFE_INTEGER || !el) return false
+      restoreTimelineScroll(saved)
+      return true
+    },
+    onApplyScroll: () => {
+      timelineScrollSession = sessionKey()
+    },
     scheduleScrollState,
     consumePendingMessage: layout.pendingMessage.consume,
   })
@@ -1573,38 +1693,31 @@ export default function Page() {
 
   useUsageExceededDialogs()
 
-  const composerRegion = () => {
-    const controller = createSessionComposerRegionController({
-      state: composer,
-      sessionKey,
-      sessionID: () => params.id,
-      prompt,
-      ready: () => !store.deferRender && messagesReady(),
-      centered,
-      todo: {
-        collapsed: () => view().todoCollapsed.get(),
+  const composerRegion = (placement: "dock" | "inline") => (
+    <SessionComposerRegion
+      state={composer}
+      sessionKey={sessionKey()}
+      sessionID={params.id}
+      controls={composerControls()}
+      promptInput={{
+        ref: (el) => {
+          inputRef = el
+        },
+        newSessionWorktree: newSessionWorktree(),
+        onNewSessionWorktreeReset: () => setStore("newSessionWorktree", "main"),
+        onSubmit: () => {
+          comments.clear()
+          resumeScroll()
+        },
+      }}
+      todo={{
+        collapsed: view().todoCollapsed.get(),
         onToggle: () => view().todoCollapsed.set(!view().todoCollapsed.get()),
-      },
-      followup: () =>
-        params.id && !isChildSession()
-          ? {
-              items: followupDock(),
-              sending: sendingFollowup(),
-              onSend: (id) => void sendFollowup(params.id!, id, { manual: true }),
-              onEdit: editFollowup,
-            }
-          : undefined,
-      revert: () =>
-        rolled().length > 0
-          ? {
-              items: rolled(),
-              restoring: restoring(),
-              disabled: reverting(),
-              onRestore: restore,
-            }
-          : undefined,
-      onResponseSubmit: resumeScroll,
-      openParent: () => {
+      }}
+      ready={!store.deferRender && messagesReady()}
+      centered={placement === "dock" && centered()}
+      placement={placement}
+      openParent={() => {
         const id = info()?.parentID
         if (!id) return
         navigate(
@@ -1612,43 +1725,44 @@ export default function Page() {
             ? sessionHref(requireServerKey(params.serverKey), id)
             : legacySessionHref(sdk().directory, id),
         )
-      },
-      setPromptRef: (el) => {
-        inputRef = el
-      },
-      setDockRef: (el) => {
+      }}
+      onResponseSubmit={resumeScroll}
+      followup={
+        params.id && !isChildSession()
+          ? {
+              queue: queueEnabled,
+              items: followupDock(),
+              sending: sendingFollowup(),
+              edit: editingFollowup(),
+              onQueue: queueFollowup,
+              onAbort: () => {
+                const id = params.id
+                if (!id) return
+                setFollowup("paused", id, true)
+              },
+              onSend: (id) => {
+                void sendFollowup(params.id!, id, { manual: true })
+              },
+              onEdit: editFollowup,
+              onEditLoaded: clearFollowupEdit,
+            }
+          : undefined
+      }
+      revert={
+        rolled().length > 0
+          ? {
+              items: rolled(),
+              restoring: restoring(),
+              disabled: reverting(),
+              onRestore: restore,
+            }
+          : undefined
+      }
+      setPromptDockRef={(el) => {
         promptDock = el
-      },
-    })
-    return (
-      <SessionComposerRegion
-        controller={controller}
-        promptInput={
-          <PromptInput
-            controls={inputController()}
-            ref={(el) => {
-              inputRef = el
-            }}
-            newSessionWorktree={newSessionWorktree()}
-            onNewSessionWorktreeReset={() => setStore("newSessionWorktree", "main")}
-            onSubmit={() => {
-              comments.clear()
-              resumeScroll()
-            }}
-            edit={editingFollowup()}
-            onEditLoaded={clearFollowupEdit}
-            shouldQueue={queueEnabled}
-            onQueue={queueFollowup}
-            onAbort={() => {
-              const id = params.id
-              if (!id) return
-              setFollowup("paused", id, true)
-            }}
-          />
-        }
-      />
-    )
-  }
+      }}
+    />
+  )
 
   const mobileTabs = (compact = false, bottom = false) => (
     <Tabs value={store.mobileTab} class="h-auto">
@@ -1746,6 +1860,7 @@ export default function Page() {
                         onResumeScroll={resumeScroll}
                         setScrollRef={setScrollRef}
                         onScheduleScrollState={scheduleScrollState}
+                        onCancelScrollRestore={cancelTimelineScrollRestore}
                         onAutoScrollHandleScroll={autoScroll.handleScroll}
                         onMarkScrollGesture={markScrollGesture}
                         hasScrollGesture={hasScrollGesture}
@@ -1753,8 +1868,13 @@ export default function Page() {
                         onHistoryScroll={onHistoryScroll}
                         onAutoScrollInteraction={autoScroll.handleInteraction}
                         shouldAnchorBottom={() =>
-                          !location.hash && !store.messageId && !ui.pendingMessage && !autoScroll.userScrolled()
+                          !location.hash &&
+                          !store.messageId &&
+                          !ui.pendingMessage &&
+                          !autoScroll.userScrolled() &&
+                          timelineScrollTop() === undefined
                         }
+                        initialScrollTop={timelineScrollTop}
                         centered={centered()}
                         setContentRef={(el) => {
                           content = el
@@ -1785,7 +1905,7 @@ export default function Page() {
               </Switch>
             </div>
 
-            <Show when={(params.id || !newSessionDesign()) && !mobileChanges()}>{(_) => composerRegion()}</Show>
+            <Show when={(params.id || !newSessionDesign()) && !mobileChanges()}>{composerRegion("dock")}</Show>
             <Show when={!!params.id && mobileTabsBottom()}>{mobileTabs(true, true)}</Show>
           </div>
 

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

@@ -1,4 +1,3 @@
 export { SessionComposerRegion } from "./session-composer-region"
-export { createPromptInputController, createPromptProjectControls } from "./session-composer-controls"
-export { createSessionComposerController } from "./session-composer-state"
-export { createSessionComposerRegionController } from "./session-composer-region-controller"
+export { createSessionComposerControls } from "./session-composer-controls"
+export { createSessionComposerState } from "./session-composer-state"

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

@@ -3,37 +3,88 @@ import { createQuery } from "@tanstack/solid-query"
 import { useNavigate, useSearchParams } from "@solidjs/router"
 import { type Accessor, createMemo } from "solid-js"
 import type { PromptInputControls } from "@/components/prompt-input"
-import type { PromptProjectControls } from "@/components/prompt-project-selector"
 import { useDirectoryPicker } from "@/components/directory-picker"
 import { useGlobal } from "@/context/global"
 import { useLayout } from "@/context/layout"
 import { useLocal } from "@/context/local"
 import type { QueryOptionsApi } from "@/context/server-sync"
-import { useServerSDK } from "@/context/server-sdk"
-import { serverName, ServerConnection, useServer } from "@/context/server"
+import { ServerConnection, useServer } from "@/context/server"
 import { useSDK } from "@/context/sdk"
 import { useSettings } from "@/context/settings"
 import { useSync } from "@/context/sync"
-import { useTabs } from "@/context/tabs"
+import { type DraftTab, useTabs } from "@/context/tabs"
 import { useProviders } from "@/hooks/use-providers"
 import { pathKey } from "@/utils/path-key"
 
-export function createPromptInputController(input: {
+export function createSessionComposerControls(input: {
   sessionKey: Accessor<string>
   sessionID: Accessor<string | undefined>
   queryOptions: Pick<QueryOptionsApi, "agents" | "providers">
 }) {
+  const navigate = useNavigate()
   const layout = useLayout()
   const local = useLocal()
   const providers = useProviders()
   const settings = useSettings()
+  const server = useServer()
   const sync = useSync()
   const sdk = useSDK()
+  const tabs = useTabs()
+  const global = useGlobal()
+  const pickDirectory = useDirectoryPicker()
+  const [search] = useSearchParams<{ draftId?: string }>()
   const view = layout.view(input.sessionKey)
+
+  const draft = createMemo(() => {
+    if (!search.draftId) return
+    return tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)
+  })
+  const projectServer = createMemo(() => {
+    if (!search.draftId) return server.current
+    const target = draft()?.server
+    if (!target) return
+    return server.list.find((conn) => ServerConnection.key(conn) === target)
+  })
+  const projectServerCtx = createMemo(() => {
+    const conn = projectServer()
+    if (conn) return global.ensureServerCtx(conn)
+  })
+  const projects = createMemo(() =>
+    search.draftId ? (projectServerCtx()?.projects.list() ?? []) : layout.projects.list(),
+  )
   const agentsQuery = createQuery(() => input.queryOptions.agents(pathKey(sdk().directory)))
   const globalProvidersQuery = createQuery(() => input.queryOptions.providers(null))
   const providersQuery = createQuery(() => input.queryOptions.providers(pathKey(sdk().directory)))
 
+  const selectProject = (worktree: string) => {
+    const conn = projectServer()
+    const target = projectServerCtx()
+    if (search.draftId) {
+      if (!conn || !target) return
+      target.projects.open(worktree)
+      target.projects.touch(worktree)
+      tabs.updateDraft(search.draftId, { server: ServerConnection.key(conn), directory: worktree })
+      return
+    }
+
+    layout.projects.open(worktree)
+    server.projects.touch(worktree)
+    navigate(`/${base64Encode(worktree)}/session`)
+  }
+
+  const addProject = (title: string) => {
+    const conn = projectServer()
+    if (!conn) return
+    pickDirectory({
+      server: conn,
+      title,
+      onSelect: (result) => {
+        const directory = Array.isArray(result) ? result[0] : result
+        if (directory) selectProject(directory)
+      },
+    })
+  }
+
   return createMemo<PromptInputControls>(() => ({
     agents: {
       available: sync().data.agent,
@@ -48,6 +99,12 @@ export function createPromptInputController(input: {
       paid: providers.paid().length > 0,
       loading: agentsQuery.isLoading || providersQuery.isLoading || globalProvidersQuery.isLoading,
     },
+    projects: {
+      available: projects(),
+      directory: sdk().directory,
+      select: selectProject,
+      add: addProject,
+    },
     session: {
       id: input.sessionID(),
       tabs: layout.tabs(input.sessionKey),
@@ -56,75 +113,3 @@ export function createPromptInputController(input: {
     newLayoutDesigns: settings.general.newLayoutDesigns(),
   }))
 }
-
-export function createPromptProjectControls() {
-  const navigate = useNavigate()
-  const layout = useLayout()
-  const server = useServer()
-  const serverSDK = useServerSDK()
-  const sdk = useSDK()
-  const tabs = useTabs()
-  const global = useGlobal()
-  const pickDirectory = useDirectoryPicker()
-  const [search] = useSearchParams<{ draftId?: string }>()
-  const projectServer = () => serverSDK().server
-  const projectServerCtx = createMemo(() => global.ensureServerCtx(projectServer()))
-  const projects = createMemo(() => {
-    if (server.list.length <= 1) {
-      return search.draftId ? projectServerCtx().projects.list() : layout.projects.list()
-    }
-    return server.list.flatMap((conn) => {
-      const item = { key: ServerConnection.key(conn), name: serverName(conn) }
-      return global
-        .ensureServerCtx(conn)
-        .projects.list()
-        .map((project) => ({ ...project, server: item }))
-    })
-  })
-  const selectProject = (worktree: string, serverKey?: string) => {
-    const conn = serverKey ? server.list.find((conn) => ServerConnection.key(conn) === serverKey) : projectServer()
-    if (search.draftId) {
-      if (!conn) return
-      const target = global.ensureServerCtx(conn)
-      target.projects.open(worktree)
-      target.projects.touch(worktree)
-      tabs.updateDraft(search.draftId, { server: ServerConnection.key(conn), directory: worktree })
-      return
-    }
-
-    if (!serverKey) {
-      layout.projects.open(worktree)
-      server.projects.touch(worktree)
-      navigate(`/${base64Encode(worktree)}/session`)
-      return
-    }
-
-    if (!conn) return
-    const target = global.ensureServerCtx(conn)
-    target.projects.open(worktree)
-    target.projects.touch(worktree)
-    server.setActive(ServerConnection.key(conn))
-    navigate(`/${base64Encode(worktree)}/session`)
-  }
-
-  const addProject = (title: string, serverKey?: string) => {
-    const conn = serverKey ? server.list.find((conn) => ServerConnection.key(conn) === serverKey) : projectServer()
-    if (!conn) return
-    pickDirectory({
-      server: conn,
-      title,
-      onSelect: (result) => {
-        const directory = Array.isArray(result) ? result[0] : result
-        if (directory) selectProject(directory, serverKey)
-      },
-    })
-  }
-
-  return createMemo<PromptProjectControls>(() => ({
-    available: projects(),
-    directory: sdk().directory,
-    server: server.list.length > 1 ? ServerConnection.key(projectServer()) : undefined,
-    select: selectProject,
-    add: addProject,
-  }))
-}

packages/app/src/pages/session/composer/session-composer-region-controller.ts

@@ -1,145 +0,0 @@
-import { createResizeObserver } from "@solid-primitives/resize-observer"
-import { useSpring } from "@opencode-ai/ui/motion-spring"
-import { type Accessor, createEffect, createMemo, createResource, onCleanup } from "solid-js"
-import { createStore } from "solid-js/store"
-import type { PromptInputState } from "@/components/prompt-input"
-import { useSync } from "@/context/sync"
-import { getSessionHandoff, setSessionHandoff } from "@/pages/session/handoff"
-import type { SessionComposerController } from "./session-composer-state"
-
-export type SessionComposerFollowupDock = {
-  items: { id: string; text: string }[]
-  sending?: string
-  onSend: (id: string) => void
-  onEdit: (id: string) => void
-}
-
-export type SessionComposerRevertDock = {
-  items: { id: string; text: string }[]
-  restoring?: string
-  disabled?: boolean
-  onRestore: (id: string) => void
-}
-
-export function createSessionComposerRegionController(input: {
-  state: SessionComposerController
-  sessionKey: Accessor<string>
-  sessionID: Accessor<string | undefined>
-  prompt: PromptInputState
-  ready: Accessor<boolean>
-  centered: Accessor<boolean>
-  todo: {
-    collapsed: Accessor<boolean>
-    onToggle: () => void
-  }
-  followup: Accessor<SessionComposerFollowupDock | undefined>
-  revert: Accessor<SessionComposerRevertDock | undefined>
-  onResponseSubmit: () => void
-  openParent: () => void
-  setPromptRef: (el: HTMLDivElement) => void
-  setDockRef: (el: HTMLDivElement) => void
-}) {
-  const sync = useSync()
-  const [store, setStore] = createStore({
-    ready: input.ready() || input.state.dock(),
-    height: 320,
-    body: undefined as HTMLDivElement | undefined,
-  })
-  let timer: number | undefined
-  let frame: number | undefined
-
-  const clear = () => {
-    if (timer !== undefined) window.clearTimeout(timer)
-    if (frame !== undefined) cancelAnimationFrame(frame)
-    timer = undefined
-    frame = undefined
-  }
-
-  createEffect(() => {
-    input.sessionKey()
-    const ready = input.ready()
-    const dock = input.state.dock()
-
-    clear()
-    if (store.ready || (!ready && !dock)) return
-    if (dock) {
-      setStore("ready", true)
-      return
-    }
-
-    frame = requestAnimationFrame(() => {
-      frame = undefined
-      timer = window.setTimeout(() => {
-        setStore("ready", true)
-        timer = undefined
-      }, 140)
-    })
-  })
-
-  createEffect(() => {
-    if (!input.prompt.ready()) return
-    setSessionHandoff(input.sessionKey(), {
-      prompt: input.prompt
-        .current()
-        .map((part) => {
-          if (part.type === "file") return `[file:${part.path}]`
-          if (part.type === "agent") return `@${part.name}`
-          if (part.type === "image") return `[image:${part.filename}]`
-          return part.content
-        })
-        .join("")
-        .trim(),
-    })
-  })
-
-  createEffect(() => {
-    const el = store.body
-    if (!el) return
-    const update = () => setStore("height", el.getBoundingClientRect().height)
-    createResizeObserver(el, update)
-    update()
-  })
-
-  onCleanup(clear)
-
-  const parentID = createMemo(() => {
-    const id = input.sessionID()
-    return id ? sync().session.get(id)?.parentID : undefined
-  })
-  const open = createMemo(() => store.ready && input.state.dock() && !input.state.closing())
-  const progress = useSpring(
-    () => (open() ? 1 : 0),
-    { visualDuration: 0.3, bounce: 0 },
-    () => `${input.sessionKey()}\0${store.ready}`,
-  )
-  const value = createMemo(() => Math.max(0, Math.min(1, progress())))
-  const ready = Promise.resolve()
-  const [promptReady] = createResource(
-    () => input.prompt.ready.promise ?? ready,
-    (promise) => promise.then(() => true),
-  )
-
-  return {
-    state: input.state,
-    centered: input.centered,
-    todo: input.todo,
-    followup: input.followup,
-    revert: input.revert,
-    onResponseSubmit: input.onResponseSubmit,
-    openParent: input.openParent,
-    setPromptRef: input.setPromptRef,
-    setDockRef: input.setDockRef,
-    parentID,
-    child: () => !!parentID(),
-    showComposer: () => !input.state.blocked() || !!parentID(),
-    handoffPrompt: () => getSessionHandoff(input.sessionKey())?.prompt,
-    promptReady: () => input.prompt.ready() || promptReady(),
-    dock: () => (store.ready && input.state.dock()) || value() > 0.001,
-    dockProgress: value,
-    dockHeight: () => Math.max(78, store.height),
-    lift: () => (input.revert()?.items.length ? 18 : 36 * value()),
-    setDockBodyRef: (el: HTMLDivElement) => setStore("body", el),
-  }
-}
-
-export type SessionComposerRegionController = ReturnType<typeof createSessionComposerRegionController>

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

@@ -1,83 +1,216 @@
-import { Show, type JSX } from "solid-js"
+import { Show, createEffect, createMemo, createResource, onCleanup } from "solid-js"
+import { createStore } from "solid-js/store"
+import { useSpring } from "@opencode-ai/ui/motion-spring"
+import { PromptInput, type PromptInputControls, type PromptInputProps } from "@/components/prompt-input"
 import { useLanguage } from "@/context/language"
+import { usePrompt } from "@/context/prompt"
+import { useSync } from "@/context/sync"
+import { getSessionHandoff, setSessionHandoff } from "@/pages/session/handoff"
 import { SessionPermissionDock } from "@/pages/session/composer/session-permission-dock"
 import { SessionQuestionDock } from "@/pages/session/composer/session-question-dock"
 import { SessionFollowupDock } from "@/pages/session/composer/session-followup-dock"
 import { SessionRevertDock } from "@/pages/session/composer/session-revert-dock"
+import type { SessionComposerState } from "@/pages/session/composer/session-composer-state"
 import { SessionTodoDock } from "@/pages/session/composer/session-todo-dock"
-import type { SessionComposerRegionController } from "./session-composer-region-controller"
+import type { FollowupDraft } from "@/components/prompt-input/submit"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
+import { NEW_SESSION_CONTENT_WIDTH } from "@/pages/session/new-session-layout"
 
 export function SessionComposerRegion(props: {
-  controller: SessionComposerRegionController
-  promptInput: JSX.Element
-}) {
-  const language = useLanguage()
-  const controller = props.controller
-  const rolled = () => {
-    const revert = controller.revert()
-    return revert?.items.length ? revert : undefined
+  state: SessionComposerState
+  sessionKey: string
+  sessionID?: string
+  controls: PromptInputControls
+  promptInput: Omit<PromptInputProps, "controls" | "variant">
+  todo: {
+    collapsed: boolean
+    onToggle: () => void
   }
+  ready: boolean
+  centered: boolean
+  placement?: "dock" | "inline"
+  openParent?: () => void
+  onResponseSubmit: () => void
+  followup?: {
+    queue: () => boolean
+    items: { id: string; text: string }[]
+    sending?: string
+    edit?: { id: string; prompt: FollowupDraft["prompt"]; context: FollowupDraft["context"] }
+    onQueue: (draft: FollowupDraft) => void
+    onAbort: () => void
+    onSend: (id: string) => void
+    onEdit: (id: string) => void
+    onEditLoaded: () => void
+  }
+  revert?: {
+    items: { id: string; text: string }[]
+    restoring?: string
+    disabled?: boolean
+    onRestore: (id: string) => void
+  }
+  setPromptDockRef: (el: HTMLDivElement) => void
+}) {
+  const prompt = props.promptInput.state ?? usePrompt()
+  const language = useLanguage()
+  const sync = useSync()
+
+  const handoffPrompt = createMemo(() => getSessionHandoff(props.sessionKey)?.prompt)
+  const info = createMemo(() => (props.sessionID ? sync().session.get(props.sessionID) : undefined))
+  const parentID = createMemo(() => info()?.parentID)
+  const child = createMemo(() => !!parentID())
+  const showComposer = createMemo(() => !props.state.blocked() || child())
+
+  const previewPrompt = () =>
+    prompt
+      .current()
+      .map((part) => {
+        if (part.type === "file") return `[file:${part.path}]`
+        if (part.type === "agent") return `@${part.name}`
+        if (part.type === "image") return `[image:${part.filename}]`
+        return part.content
+      })
+      .join("")
+      .trim()
+
+  createEffect(() => {
+    if (!prompt.ready()) return
+    setSessionHandoff(props.sessionKey, { prompt: previewPrompt() })
+  })
+
+  const [store, setStore] = createStore({
+    ready: props.ready || props.state.dock(),
+    height: 320,
+    body: undefined as HTMLDivElement | undefined,
+  })
+  let timer: number | undefined
+  let frame: number | undefined
+
+  const clear = () => {
+    if (timer !== undefined) {
+      window.clearTimeout(timer)
+      timer = undefined
+    }
+    if (frame !== undefined) {
+      cancelAnimationFrame(frame)
+      frame = undefined
+    }
+  }
+
+  createEffect(() => {
+    props.sessionKey
+    const ready = props.ready
+    const dock = props.state.dock()
+    const delay = 140
+
+    clear()
+    if (store.ready || (!ready && !dock)) return
+    if (dock) {
+      setStore("ready", true)
+      return
+    }
+
+    frame = requestAnimationFrame(() => {
+      frame = undefined
+      timer = window.setTimeout(() => {
+        setStore("ready", true)
+        timer = undefined
+      }, delay)
+    })
+  })
+
+  onCleanup(clear)
+
+  const open = createMemo(() => store.ready && props.state.dock() && !props.state.closing())
+  const progress = useSpring(
+    () => (open() ? 1 : 0),
+    { visualDuration: 0.3, bounce: 0 },
+    () => `${props.sessionKey}\0${store.ready}`,
+  )
+  const value = createMemo(() => Math.max(0, Math.min(1, progress())))
+  const dock = createMemo(() => (store.ready && props.state.dock()) || value() > 0.001)
+  const rolled = createMemo(() => (props.revert?.items.length ? props.revert : undefined))
+  const lift = createMemo(() => (rolled() ? 18 : 36 * value()))
+  const full = createMemo(() => Math.max(78, store.height))
+
+  createEffect(() => {
+    const el = store.body
+    if (!el) return
+    const update = () => setStore("height", el.getBoundingClientRect().height)
+    createResizeObserver(store.body, update)
+    update()
+  })
+
+  const ready = Promise.resolve()
+  const [promptReadyResource] = createResource(
+    () => prompt.ready.promise ?? ready,
+    (promise) => promise.then(() => true),
+  )
 
   return (
     <div
-      ref={controller.setDockRef}
+      ref={props.setPromptDockRef}
       data-component="session-prompt-dock"
-      class="w-full shrink-0 flex flex-col justify-center items-center pb-3 bg-background-stronger pointer-events-none"
+      classList={{
+        "w-full flex flex-col justify-center items-center pointer-events-none": true,
+        "shrink-0 pb-3 bg-background-stronger": props.placement !== "inline",
+      }}
     >
       <div
         classList={{
-          "w-full px-3 pointer-events-auto": true,
-          "md:max-w-200 md:mx-auto 2xl:max-w-[1000px]": controller.centered(),
+          "w-full pointer-events-auto": true,
+          "px-3": props.placement !== "inline",
+          [NEW_SESSION_CONTENT_WIDTH]: props.placement === "inline",
+          "md:max-w-200 md:mx-auto 2xl:max-w-[1000px]": props.centered,
         }}
       >
-        <Show when={controller.state.questionRequest()} keyed>
+        <Show when={props.state.questionRequest()} keyed>
           {(request) => (
             <div>
-              <SessionQuestionDock request={request} onSubmit={controller.onResponseSubmit} />
+              <SessionQuestionDock request={request} onSubmit={props.onResponseSubmit} />
             </div>
           )}
         </Show>
 
-        <Show when={controller.state.permissionRequest()} keyed>
+        <Show when={props.state.permissionRequest()} keyed>
           {(request) => (
             <div>
               <SessionPermissionDock
                 request={request}
-                responding={controller.state.permissionResponding()}
+                responding={props.state.permissionResponding()}
                 onDecide={(response) => {
-                  controller.onResponseSubmit()
-                  controller.state.decide(response)
+                  props.onResponseSubmit()
+                  props.state.decide(response)
                 }}
               />
             </div>
           )}
         </Show>
 
-        <Show when={controller.showComposer()}>
-          <Show when={controller.dock()}>
+        <Show when={showComposer()}>
+          <Show when={dock()}>
             <div
               classList={{
                 "overflow-hidden": true,
-                "pointer-events-none": controller.dockProgress() < 0.98,
+                "pointer-events-none": value() < 0.98,
               }}
               style={{
-                "max-height": `${controller.dockHeight() * controller.dockProgress()}px`,
+                "max-height": `${full() * value()}px`,
               }}
             >
-              <div ref={controller.setDockBodyRef}>
+              <div ref={(el) => setStore("body", el)}>
                 <SessionTodoDock
-                  todos={controller.state.todos()}
-                  collapsed={controller.todo.collapsed()}
-                  onToggle={controller.todo.onToggle}
+                  todos={props.state.todos()}
+                  collapsed={props.todo.collapsed}
+                  onToggle={props.todo.onToggle}
                   collapseLabel={language.t("session.todo.collapse")}
                   expandLabel={language.t("session.todo.expand")}
-                  dockProgress={controller.dockProgress()}
+                  dockProgress={value()}
                 />
               </div>
             </div>
           </Show>
           <Show
-            when={controller.promptReady()}
+            when={prompt.ready() || promptReadyResource()}
             fallback={
               <>
                 <Show when={rolled()} keyed>
@@ -94,9 +227,9 @@ export function SessionComposerRegion(props: {
                 </Show>
                 <div
                   class="w-full min-h-32 md:min-h-40 rounded-md border border-border-weak-base bg-background-base/50 px-4 py-3 text-text-weak whitespace-pre-wrap pointer-events-none"
-                  style={{ "margin-top": `${-36 * controller.dockProgress()}px` }}
+                  style={{ "margin-top": `${-36 * value()}px` }}
                 >
-                  {controller.handoffPrompt() || language.t("prompt.loading")}
+                  {handoffPrompt() || language.t("prompt.loading")}
                 </div>
               </>
             }
@@ -105,7 +238,7 @@ export function SessionComposerRegion(props: {
               {(revert) => (
                 <div
                   style={{
-                    "margin-top": `${-36 * controller.dockProgress()}px`,
+                    "margin-top": `${-36 * value()}px`,
                   }}
                 >
                   <SessionRevertDock
@@ -122,31 +255,44 @@ export function SessionComposerRegion(props: {
                 "relative z-30": true,
               }}
               style={{
-                "margin-top": `${-controller.lift()}px`,
+                "margin-top": `${-lift()}px`,
               }}
             >
-              <Show when={controller.followup()?.items.length}>
+              <Show when={props.followup?.items.length}>
                 <SessionFollowupDock
-                  items={controller.followup()!.items}
-                  sending={controller.followup()!.sending}
-                  onSend={controller.followup()!.onSend}
-                  onEdit={controller.followup()!.onEdit}
+                  items={props.followup!.items}
+                  sending={props.followup!.sending}
+                  onSend={props.followup!.onSend}
+                  onEdit={props.followup!.onEdit}
                 />
               </Show>
               <Show
-                when={controller.child()}
-                fallback={<Show when={!controller.state.blocked()}>{props.promptInput}</Show>}
+                when={child()}
+                fallback={
+                  <Show when={!props.state.blocked()}>
+                    <PromptInput
+                      {...props.promptInput}
+                      controls={props.controls}
+                      variant={props.placement === "inline" ? "new-session" : undefined}
+                      edit={props.followup?.edit}
+                      onEditLoaded={props.followup?.onEditLoaded}
+                      shouldQueue={props.followup?.queue}
+                      onQueue={props.followup?.onQueue}
+                      onAbort={props.followup?.onAbort}
+                    />
+                  </Show>
+                }
               >
                 <div
-                  ref={controller.setPromptRef}
+                  ref={props.promptInput.ref}
                   class="w-full rounded-[12px] border border-border-weak-base bg-background-base p-3 text-16-regular text-text-weak"
                 >
                   <span>{language.t("session.child.promptDisabled")} </span>
-                  <Show when={controller.parentID()}>
+                  <Show when={parentID() && props.openParent}>
                     <button
                       type="button"
                       class="text-text-base transition-colors hover:text-text-strong"
-                      onClick={controller.openParent}
+                      onClick={props.openParent}
                     >
                       {language.t("session.child.backToParent")}
                     </button>

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

@@ -25,7 +25,7 @@ export const todoDockAtBoundary = (state: ReturnType<typeof todoState>) => state
 
 const idle = { type: "idle" as const }
 
-export function createSessionComposerController(options?: { closeMs?: number | (() => number) }) {
+export function createSessionComposerState(options?: { closeMs?: number | (() => number) }) {
   const params = useParams()
   const sdk = useSDK()
   const sync = useSync()
@@ -201,4 +201,4 @@ export function createSessionComposerController(options?: { closeMs?: number | (
   }
 }
 
-export type SessionComposerController = ReturnType<typeof createSessionComposerController>
+export type SessionComposerState = ReturnType<typeof createSessionComposerState>

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

@@ -432,23 +432,21 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
       header={
         <>
           <div data-slot="question-header-title">{summary()}</div>
-          <Show when={total() > 1}>
-            <div data-slot="question-progress">
-              <For each={questions()}>
-                {(_, i) => (
-                  <button
-                    type="button"
-                    data-slot="question-progress-segment"
-                    data-active={i() === store.tab}
-                    data-answered={answered(i())}
-                    disabled={sending()}
-                    onClick={() => jump(i())}
-                    aria-label={`${language.t("ui.tool.questions")} ${i() + 1}`}
-                  />
-                )}
-              </For>
-            </div>
-          </Show>
+          <div data-slot="question-progress">
+            <For each={questions()}>
+              {(_, i) => (
+                <button
+                  type="button"
+                  data-slot="question-progress-segment"
+                  data-active={i() === store.tab}
+                  data-answered={answered(i())}
+                  disabled={sending()}
+                  onClick={() => jump(i())}
+                  aria-label={`${language.t("ui.tool.questions")} ${i() + 1}`}
+                />
+              )}
+            </For>
+          </div>
         </>
       }
       footer={

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

@@ -3,13 +3,7 @@ import { createEffect, createMemo, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { Todo } from "@opencode-ai/sdk/v2"
 import { useServerSync } from "@/context/global-sync"
-import { PromptInput } from "@/components/prompt-input"
-import { usePrompt } from "@/context/prompt"
-import {
-  SessionComposerRegion,
-  createSessionComposerController,
-  createSessionComposerRegionController,
-} from "@/pages/session/composer"
+import { SessionComposerRegion, createSessionComposerState } from "@/pages/session/composer"
 
 export default {
   title: "UI/Todo Panel Motion",
@@ -66,6 +60,7 @@ const controls = {
     paid: true,
     loading: false,
   },
+  projects: { available: [], directory: "/tmp/story", select: () => {}, add: () => {} },
   session: {
     id: "story-session",
     tabs: { active: () => undefined, all: () => [], open: () => {}, setActive: () => {} },
@@ -154,7 +149,6 @@ const css = `
 export const Playground = {
   render: () => {
     const global = useServerSync()
-    const prompt = usePrompt()
     const [cfg, setCfg] = createStore({
       open: true,
       collapsed: false,
@@ -194,7 +188,7 @@ export const Playground = {
     const countMask = () => cfg.countMask
     const countMaskHeight = () => cfg.countMaskHeight
     const countWidthDuration = () => cfg.countWidthDuration
-    const state = createSessionComposerController({ closeMs: () => Math.round(dockCloseDuration() * 1000) })
+    const state = createSessionComposerState({ closeMs: () => Math.round(dockCloseDuration() * 1000) })
     let frame
     let scrollRef
 
@@ -223,6 +217,7 @@ export const Playground = {
 
     const collapsed = () => cfg.collapsed
     const setCollapsed = (value: boolean) => setCfg("collapsed", value)
+
     const openDock = () => {
       clear()
       setCfg("open", true)
@@ -286,30 +281,36 @@ export const Playground = {
 
                 <div>
                   <SessionComposerRegion
-                    controller={createSessionComposerRegionController({
-                      state,
-                      sessionKey: () => "story-session",
-                      sessionID: () => "story-session",
-                      prompt,
-                      ready: () => true,
-                      centered: () => false,
-                      todo: { collapsed, onToggle: () => setCollapsed(!collapsed()) },
-                      followup: () => undefined,
-                      revert: () => undefined,
-                      onResponseSubmit: pin,
-                      openParent: () => {},
-                      setPromptRef: () => {},
-                      setDockRef: () => {},
-                    })}
-                    promptInput={
-                      <PromptInput
-                        controls={controls}
-                        submission={{ abort: () => {}, handleSubmit: (event) => event.preventDefault() }}
-                        ref={() => {}}
-                        newSessionWorktree=""
-                        onNewSessionWorktreeReset={() => {}}
-                      />
-                    }
+                    state={state}
+                    sessionKey="story-session"
+                    sessionID="story-session"
+                    controls={controls}
+                    promptInput={{
+                      submission: { abort: () => {}, handleSubmit: (event) => event.preventDefault() },
+                      ref: () => {},
+                      newSessionWorktree: "",
+                      onNewSessionWorktreeReset: () => {},
+                    }}
+                    todo={{ collapsed: collapsed(), onToggle: () => setCollapsed(!collapsed()) }}
+                    ready
+                    centered={false}
+                    onResponseSubmit={pin}
+                    setPromptDockRef={() => {}}
+                    dockOpenVisualDuration={dockOpenDuration()}
+                    dockOpenBounce={dockOpenBounce()}
+                    dockCloseVisualDuration={dockCloseDuration()}
+                    dockCloseBounce={dockCloseBounce()}
+                    drawerExpandVisualDuration={drawerExpandDuration()}
+                    drawerExpandBounce={drawerExpandBounce()}
+                    drawerCollapseVisualDuration={drawerCollapseDuration()}
+                    drawerCollapseBounce={drawerCollapseBounce()}
+                    subtitleDuration={subtitleDuration()}
+                    subtitleTravel={subtitleAuto() ? undefined : subtitleTravel()}
+                    subtitleEdge={subtitleAuto() ? undefined : subtitleEdge()}
+                    countDuration={countDuration()}
+                    countMask={countMask()}
+                    countMaskHeight={countMaskHeight()}
+                    countWidthDuration={countWidthDuration()}
                   />
                 </div>
               </div>

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

@@ -293,7 +293,7 @@ export function TerminalPanel() {
                 </Tabs.List>
               </Tabs>
               <div class="flex-1 min-h-0 relative">
-                <Show when={opened() && terminal.active()} keyed>
+                <Show when={terminal.active()} keyed>
                   {(id) => {
                     const ops = terminal.bind()
                     return (

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

@@ -235,6 +235,7 @@ export function MessageTimeline(props: {
   onResumeScroll: () => void
   setScrollRef: (el: HTMLDivElement | undefined) => void
   onScheduleScrollState: (el: HTMLDivElement) => void
+  onCancelScrollRestore: () => void
   onAutoScrollHandleScroll: () => void
   onMarkScrollGesture: (target?: EventTarget | null) => void
   hasScrollGesture: () => boolean
@@ -242,6 +243,7 @@ export function MessageTimeline(props: {
   onHistoryScroll: () => void
   onAutoScrollInteraction: (event: MouseEvent) => void
   shouldAnchorBottom: () => boolean
+  initialScrollTop: () => number | undefined
   centered: boolean
   setContentRef: (el: HTMLDivElement) => void
   userMessages: UserMessage[]
@@ -400,7 +402,7 @@ export function MessageTimeline(props: {
       return timelineRows().length
     },
     getScrollElement: () => listRoot() ?? null,
-    initialOffset: () => (props.shouldAnchorBottom() ? Number.MAX_SAFE_INTEGER : 0),
+    initialOffset: () => (props.shouldAnchorBottom() ? Number.MAX_SAFE_INTEGER : (props.initialScrollTop() ?? 0)),
     initialMeasurementsCache: initialMeasurements,
     estimateSize: () => timelineFallbackItemSize,
     scrollToFn: (offset, options, instance) => {
@@ -552,6 +554,7 @@ export function MessageTimeline(props: {
   }
 
   const handleListWheel = (event: WheelEvent & { currentTarget: HTMLDivElement }) => {
+    props.onCancelScrollRestore()
     if (!prependLoading) clearPrependAnchor()
     const root = event.currentTarget
     const delta = normalizeWheelDelta({
@@ -564,6 +567,7 @@ export function MessageTimeline(props: {
   }
 
   const handleListTouchStart = (event: TouchEvent) => {
+    props.onCancelScrollRestore()
     if (!prependLoading) clearPrependAnchor()
     touchGesture = event.touches[0]?.clientY
   }
@@ -590,11 +594,17 @@ export function MessageTimeline(props: {
   }
 
   const handleListPointerDown = (event: PointerEvent & { currentTarget: HTMLDivElement }) => {
+    props.onCancelScrollRestore()
     if (!prependLoading) clearPrependAnchor()
     if (event.target !== event.currentTarget) return
     props.onMarkScrollGesture(event.currentTarget)
   }
 
+  const handleListKeyDown = (event: KeyboardEvent) => {
+    if (!["ArrowUp", "ArrowDown", "PageUp", "PageDown", "Home", "End", " "].includes(event.key)) return
+    props.onCancelScrollRestore()
+  }
+
   const handleListScroll = (event: Event & { currentTarget: HTMLDivElement }) => {
     if (prependLoading) updatePrependAnchor()
     props.onScheduleScrollState(event.currentTarget)
@@ -1277,6 +1287,7 @@ export function MessageTimeline(props: {
         onTouchEnd={handleListTouchEnd}
         onTouchCancel={handleListTouchEnd}
         onPointerDown={handleListPointerDown}
+        onKeyDown={handleListKeyDown}
         onScroll={handleListScroll}
         onClick={props.onAutoScrollInteraction}
         class="relative min-w-0 w-full h-full"

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

@@ -1,69 +0,0 @@
-import { useCommand, type CommandOption } from "@/context/command"
-import { useLanguage } from "@/context/language"
-import { useLocal } from "@/context/local"
-import { useSettings } from "@/context/settings"
-import { useDialog } from "@opencode-ai/ui/context/dialog"
-import { useSessionLayout } from "./session-layout"
-import { createSessionOwnership } from "./session-ownership"
-
-const withCategory = (category: string) => {
-  return (option: Omit<CommandOption, "category">): CommandOption => ({
-    ...option,
-    category,
-  })
-}
-
-export const useComposerCommands = () => {
-  const command = useCommand()
-  const dialog = useDialog()
-  const language = useLanguage()
-  const local = useLocal()
-  const settings = useSettings()
-  const { sessionKey } = useSessionLayout()
-  const sessionOwnership = createSessionOwnership(sessionKey)
-  const modelCommand = withCategory(language.t("command.category.model"))
-  const agentCommand = withCategory(language.t("command.category.agent"))
-
-  const chooseModel = async () => {
-    const owner = sessionOwnership.capture()
-    const { DialogSelectModel } = await import("@/components/dialog-select-model")
-    owner.run(() => {
-      void dialog.show(() => <DialogSelectModel model={local.model} />)
-    })
-  }
-
-  command.register("composer", () => [
-    modelCommand({
-      id: "model.choose",
-      title: language.t("command.model.choose"),
-      description: language.t("command.model.choose.description"),
-      keybind: "mod+'",
-      slash: "model",
-      onSelect: chooseModel,
-    }),
-    modelCommand({
-      id: "model.variant.cycle",
-      title: language.t("command.model.variant.cycle"),
-      description: language.t("command.model.variant.cycle.description"),
-      keybind: "shift+mod+d",
-      onSelect: () => local.model.variant.cycle(),
-    }),
-    agentCommand({
-      id: "agent.cycle",
-      title: language.t("command.agent.cycle"),
-      description: language.t("command.agent.cycle.description"),
-      keybind: "mod+.",
-      slash: "agent",
-      disabled: !settings.visibility.customAgents(),
-      onSelect: () => local.agent.move(1),
-    }),
-    agentCommand({
-      id: "agent.cycle.reverse",
-      title: language.t("command.agent.cycle.reverse"),
-      description: language.t("command.agent.cycle.reverse.description"),
-      keybind: "shift+mod+.",
-      disabled: !settings.visibility.customAgents(),
-      onSelect: () => local.agent.move(-1),
-    }),
-  ])
-}

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

@@ -136,7 +136,9 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   const contextCommand = withCategory(language.t("command.category.context"))
   const viewCommand = withCategory(language.t("command.category.view"))
   const terminalCommand = withCategory(language.t("command.category.terminal"))
+  const modelCommand = withCategory(language.t("command.category.model"))
   const mcpCommand = withCategory(language.t("command.category.mcp"))
+  const agentCommand = withCategory(language.t("command.category.agent"))
   const permissionsCommand = withCategory(language.t("command.category.permissions"))
 
   const isAutoAcceptActive = () => {
@@ -269,6 +271,13 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     view().terminal.open()
   }
 
+  const chooseModel = () => {
+    void openDialog(
+      () => import("@/components/dialog-select-model"),
+      (x) => dialog.show(() => <x.DialogSelectModel model={local.model} />),
+    )
+  }
+
   const chooseMcp = () => {
     void openDialog(
       () => import("@/components/dialog-select-mcp"),
@@ -546,6 +555,24 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     }),
   ]
 
+  const modelCmds = () => [
+    modelCommand({
+      id: "model.choose",
+      title: language.t("command.model.choose"),
+      description: language.t("command.model.choose.description"),
+      keybind: "mod+'",
+      slash: "model",
+      onSelect: chooseModel,
+    }),
+    modelCommand({
+      id: "model.variant.cycle",
+      title: language.t("command.model.variant.cycle"),
+      description: language.t("command.model.variant.cycle.description"),
+      keybind: "shift+mod+d",
+      onSelect: () => local.model.variant.cycle(),
+    }),
+  ]
+
   const mcpCmds = () => [
     mcpCommand({
       id: "mcp.toggle",
@@ -557,6 +584,26 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     }),
   ]
 
+  const agentCmds = () => [
+    agentCommand({
+      id: "agent.cycle",
+      title: language.t("command.agent.cycle"),
+      description: language.t("command.agent.cycle.description"),
+      keybind: "mod+.",
+      slash: "agent",
+      disabled: !settings.visibility.customAgents(),
+      onSelect: () => local.agent.move(1),
+    }),
+    agentCommand({
+      id: "agent.cycle.reverse",
+      title: language.t("command.agent.cycle.reverse"),
+      description: language.t("command.agent.cycle.reverse.description"),
+      keybind: "shift+mod+.",
+      disabled: !settings.visibility.customAgents(),
+      onSelect: () => local.agent.move(-1),
+    }),
+  ]
+
   const permissionsCmds = () => [
     permissionsCommand({
       id: "permissions.autoaccept",
@@ -577,7 +624,9 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     ...viewCmds(),
     ...terminalCmds(),
     ...messageCmds(),
+    ...modelCmds(),
     ...mcpCmds(),
+    ...agentCmds(),
     ...permissionsCmds(),
   ])
 }

packages/app/src/pages/session/use-session-hash-scroll.ts

@@ -19,12 +19,17 @@ export const useSessionHashScroll = (input: {
   scroller: () => HTMLDivElement | undefined
   anchor: (id: string) => string
   revealMessage?: (id: string) => void
+  scrollReady: () => boolean
+  hasSavedScroll: () => boolean
+  restoreScroll: () => boolean
+  onApplyScroll: () => void
   scheduleScrollState: (el: HTMLDivElement) => void
   consumePendingMessage: (key: string) => string | undefined
 }) => {
   const visibleUserMessages = createMemo(() => input.visibleUserMessages())
   const messageById = createMemo(() => new Map(visibleUserMessages().map((m) => [m.id, m])))
   let pendingKey = ""
+  let restoredKey = ""
   let clearing = false
 
   const location = useLocation()
@@ -99,14 +104,24 @@ export const useSessionHashScroll = (input: {
   }
 
   const applyHash = (behavior: ScrollBehavior) => {
+    const key = input.sessionKey()
+    const initial = restoredKey !== key
     const hash = location.hash.slice(1)
     if (!hash) {
+      if (initial && input.restoreScroll()) {
+        restoredKey = key
+        return
+      }
       input.autoScroll.forceScrollToBottom()
       const el = input.scroller()
       if (el) input.scheduleScrollState(el)
+      if (input.scrollReady()) input.onApplyScroll()
       return
     }
 
+    restoredKey = key
+    input.onApplyScroll()
+
     const messageId = messageIdFromHash(hash)
     if (messageId) {
       input.autoScroll.pause()
@@ -132,6 +147,8 @@ export const useSessionHashScroll = (input: {
 
   createEffect(() => {
     const hash = location.hash
+    input.scrollReady()
+    input.hasSavedScroll()
     if (!hash) clearing = false
     if (!input.sessionID() || !input.messagesReady()) return
     cancel()

packages/client/src/generated-effect/client.ts

@@ -1,5 +1,5 @@
 // Generated by @opencode-ai/httpapi-codegen. Do not edit.
-import { Effect, Stream, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import { Sse } from "effect/unstable/encoding"
 import { HttpClientError } from "effect/unstable/http"
 import { HttpApi, HttpApiClient } from "effect/unstable/httpapi"
@@ -55,49 +55,43 @@ const Endpoint0_1 = (raw: RawClient["server.session"]) => (input?: Endpoint0_1In
     Effect.map((value) => value.data),
   )
 
-const Endpoint0_2 = (raw: RawClient["server.session"]) => () =>
-  raw["session.active"]({}).pipe(
-    Effect.mapError(mapClientError),
-    Effect.map((value) => value.data),
-  )
-
-type Endpoint0_3Request = Parameters<RawClient["server.session"]["session.get"]>[0]
-type Endpoint0_3Input = { readonly sessionID: Endpoint0_3Request["params"]["sessionID"] }
-const Endpoint0_3 = (raw: RawClient["server.session"]) => (input: Endpoint0_3Input) =>
+type Endpoint0_2Request = Parameters<RawClient["server.session"]["session.get"]>[0]
+type Endpoint0_2Input = { readonly sessionID: Endpoint0_2Request["params"]["sessionID"] }
+const Endpoint0_2 = (raw: RawClient["server.session"]) => (input: Endpoint0_2Input) =>
   raw["session.get"]({ params: { sessionID: input.sessionID } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint0_4Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
-type Endpoint0_4Input = {
-  readonly sessionID: Endpoint0_4Request["params"]["sessionID"]
-  readonly agent: Endpoint0_4Request["payload"]["agent"]
+type Endpoint0_3Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
+type Endpoint0_3Input = {
+  readonly sessionID: Endpoint0_3Request["params"]["sessionID"]
+  readonly agent: Endpoint0_3Request["payload"]["agent"]
 }
-const Endpoint0_4 = (raw: RawClient["server.session"]) => (input: Endpoint0_4Input) =>
+const Endpoint0_3 = (raw: RawClient["server.session"]) => (input: Endpoint0_3Input) =>
   raw["session.switchAgent"]({ params: { sessionID: input.sessionID }, payload: { agent: input.agent } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint0_5Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
-type Endpoint0_5Input = {
-  readonly sessionID: Endpoint0_5Request["params"]["sessionID"]
-  readonly model: Endpoint0_5Request["payload"]["model"]
+type Endpoint0_4Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
+type Endpoint0_4Input = {
+  readonly sessionID: Endpoint0_4Request["params"]["sessionID"]
+  readonly model: Endpoint0_4Request["payload"]["model"]
 }
-const Endpoint0_5 = (raw: RawClient["server.session"]) => (input: Endpoint0_5Input) =>
+const Endpoint0_4 = (raw: RawClient["server.session"]) => (input: Endpoint0_4Input) =>
   raw["session.switchModel"]({ params: { sessionID: input.sessionID }, payload: { model: input.model } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint0_6Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
-type Endpoint0_6Input = {
-  readonly sessionID: Endpoint0_6Request["params"]["sessionID"]
-  readonly id?: Endpoint0_6Request["payload"]["id"]
-  readonly prompt: Endpoint0_6Request["payload"]["prompt"]
-  readonly delivery?: Endpoint0_6Request["payload"]["delivery"]
-  readonly resume?: Endpoint0_6Request["payload"]["resume"]
+type Endpoint0_5Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint0_5Input = {
+  readonly sessionID: Endpoint0_5Request["params"]["sessionID"]
+  readonly id?: Endpoint0_5Request["payload"]["id"]
+  readonly prompt: Endpoint0_5Request["payload"]["prompt"]
+  readonly delivery?: Endpoint0_5Request["payload"]["delivery"]
+  readonly resume?: Endpoint0_5Request["payload"]["resume"]
 }
-const Endpoint0_6 = (raw: RawClient["server.session"]) => (input: Endpoint0_6Input) =>
+const Endpoint0_5 = (raw: RawClient["server.session"]) => (input: Endpoint0_5Input) =>
   raw["session.prompt"]({
     params: { sessionID: input.sessionID },
     payload: { id: input.id, prompt: input.prompt, delivery: input.delivery, resume: input.resume },
@@ -106,23 +100,23 @@ const Endpoint0_6 = (raw: RawClient["server.session"]) => (input: Endpoint0_6Inp
     Effect.map((value) => value.data),
   )
 
-type Endpoint0_7Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint0_7Input = { readonly sessionID: Endpoint0_7Request["params"]["sessionID"] }
-const Endpoint0_7 = (raw: RawClient["server.session"]) => (input: Endpoint0_7Input) =>
+type Endpoint0_6Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint0_6Input = { readonly sessionID: Endpoint0_6Request["params"]["sessionID"] }
+const Endpoint0_6 = (raw: RawClient["server.session"]) => (input: Endpoint0_6Input) =>
   raw["session.compact"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint0_8Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-type Endpoint0_8Input = { readonly sessionID: Endpoint0_8Request["params"]["sessionID"] }
-const Endpoint0_8 = (raw: RawClient["server.session"]) => (input: Endpoint0_8Input) =>
+type Endpoint0_7Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint0_7Input = { readonly sessionID: Endpoint0_7Request["params"]["sessionID"] }
+const Endpoint0_7 = (raw: RawClient["server.session"]) => (input: Endpoint0_7Input) =>
   raw["session.wait"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint0_9Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint0_9Input = {
-  readonly sessionID: Endpoint0_9Request["params"]["sessionID"]
-  readonly messageID: Endpoint0_9Request["payload"]["messageID"]
-  readonly files?: Endpoint0_9Request["payload"]["files"]
+type Endpoint0_8Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint0_8Input = {
+  readonly sessionID: Endpoint0_8Request["params"]["sessionID"]
+  readonly messageID: Endpoint0_8Request["payload"]["messageID"]
+  readonly files?: Endpoint0_8Request["payload"]["files"]
 }
-const Endpoint0_9 = (raw: RawClient["server.session"]) => (input: Endpoint0_9Input) =>
+const Endpoint0_8 = (raw: RawClient["server.session"]) => (input: Endpoint0_8Input) =>
   raw["session.revert.stage"]({
     params: { sessionID: input.sessionID },
     payload: { messageID: input.messageID, files: input.files },
@@ -131,70 +125,37 @@ const Endpoint0_9 = (raw: RawClient["server.session"]) => (input: Endpoint0_9Inp
     Effect.map((value) => value.data),
   )
 
-type Endpoint0_10Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint0_10Input = { readonly sessionID: Endpoint0_10Request["params"]["sessionID"] }
-const Endpoint0_10 = (raw: RawClient["server.session"]) => (input: Endpoint0_10Input) =>
+type Endpoint0_9Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+type Endpoint0_9Input = { readonly sessionID: Endpoint0_9Request["params"]["sessionID"] }
+const Endpoint0_9 = (raw: RawClient["server.session"]) => (input: Endpoint0_9Input) =>
   raw["session.revert.clear"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint0_11Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
-type Endpoint0_11Input = { readonly sessionID: Endpoint0_11Request["params"]["sessionID"] }
-const Endpoint0_11 = (raw: RawClient["server.session"]) => (input: Endpoint0_11Input) =>
+type Endpoint0_10Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint0_10Input = { readonly sessionID: Endpoint0_10Request["params"]["sessionID"] }
+const Endpoint0_10 = (raw: RawClient["server.session"]) => (input: Endpoint0_10Input) =>
   raw["session.revert.commit"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint0_12Request = Parameters<RawClient["server.session"]["session.context"]>[0]
-type Endpoint0_12Input = { readonly sessionID: Endpoint0_12Request["params"]["sessionID"] }
-const Endpoint0_12 = (raw: RawClient["server.session"]) => (input: Endpoint0_12Input) =>
+type Endpoint0_11Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint0_11Input = { readonly sessionID: Endpoint0_11Request["params"]["sessionID"] }
+const Endpoint0_11 = (raw: RawClient["server.session"]) => (input: Endpoint0_11Input) =>
   raw["session.context"]({ params: { sessionID: input.sessionID } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint0_13Request = Parameters<RawClient["server.session"]["session.events"]>[0]
-type Endpoint0_13Input = {
-  readonly sessionID: Endpoint0_13Request["params"]["sessionID"]
-  readonly after?: Endpoint0_13Request["query"]["after"]
-}
-const Endpoint0_13 = (raw: RawClient["server.session"]) => (input: Endpoint0_13Input) =>
-  Stream.unwrap(
-    raw["session.events"]({ params: { sessionID: input.sessionID }, query: { after: input.after } }).pipe(
-      Effect.mapError(mapClientError),
-      Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))),
-    ),
-  )
-
-type Endpoint0_14Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint0_14Input = { readonly sessionID: Endpoint0_14Request["params"]["sessionID"] }
-const Endpoint0_14 = (raw: RawClient["server.session"]) => (input: Endpoint0_14Input) =>
-  raw["session.interrupt"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint0_15Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint0_15Input = {
-  readonly sessionID: Endpoint0_15Request["params"]["sessionID"]
-  readonly messageID: Endpoint0_15Request["params"]["messageID"]
-}
-const Endpoint0_15 = (raw: RawClient["server.session"]) => (input: Endpoint0_15Input) =>
-  raw["session.message"]({ params: { sessionID: input.sessionID, messageID: input.messageID } }).pipe(
-    Effect.mapError(mapClientError),
-    Effect.map((value) => value.data),
-  )
-
 const adaptGroup0 = (raw: RawClient["server.session"]) => ({
   list: Endpoint0_0(raw),
   create: Endpoint0_1(raw),
-  active: Endpoint0_2(raw),
-  get: Endpoint0_3(raw),
-  switchAgent: Endpoint0_4(raw),
-  switchModel: Endpoint0_5(raw),
-  prompt: Endpoint0_6(raw),
-  compact: Endpoint0_7(raw),
-  wait: Endpoint0_8(raw),
-  stage: Endpoint0_9(raw),
-  clear: Endpoint0_10(raw),
-  commit: Endpoint0_11(raw),
-  context: Endpoint0_12(raw),
-  events: Endpoint0_13(raw),
-  interrupt: Endpoint0_14(raw),
-  message: Endpoint0_15(raw),
+  get: Endpoint0_2(raw),
+  switchAgent: Endpoint0_3(raw),
+  switchModel: Endpoint0_4(raw),
+  prompt: Endpoint0_5(raw),
+  compact: Endpoint0_6(raw),
+  wait: Endpoint0_7(raw),
+  stage: Endpoint0_8(raw),
+  clear: Endpoint0_9(raw),
+  commit: Endpoint0_10(raw),
+  context: Endpoint0_11(raw),
 })
 
 const adaptClient = (raw: RawClient) => ({ sessions: adaptGroup0(raw["server.session"]) })

packages/client/src/generated/client.ts

@@ -3,7 +3,6 @@ import type {
   SessionsListOutput,
   SessionsCreateInput,
   SessionsCreateOutput,
-  SessionsActiveOutput,
   SessionsGetInput,
   SessionsGetOutput,
   SessionsSwitchAgentInput,
@@ -24,12 +23,6 @@ import type {
   SessionsCommitOutput,
   SessionsContextInput,
   SessionsContextOutput,
-  SessionsEventsInput,
-  SessionsEventsOutput,
-  SessionsInterruptInput,
-  SessionsInterruptOutput,
-  SessionsMessageInput,
-  SessionsMessageOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -199,17 +192,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      active: (requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsActiveOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/active`,
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
       get: (input: SessionsGetInput, requestOptions?: RequestOptions) =>
         request<{ readonly data: SessionsGetOutput }>(
           {
@@ -324,40 +306,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      events: (input: SessionsEventsInput, requestOptions?: RequestOptions): AsyncIterable<SessionsEventsOutput> =>
-        sse<SessionsEventsOutput>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/event`,
-            query: { after: input.after },
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      interrupt: (input: SessionsInterruptInput, requestOptions?: RequestOptions) =>
-        request<SessionsInterruptOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      message: (input: SessionsMessageInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsMessageOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
     },
   }
 }

packages/client/src/generated/types.ts

@@ -243,8 +243,6 @@ export type SessionsCreateOutput = {
   }
 }["data"]
 
-export type SessionsActiveOutput = { readonly data: { readonly [x: string]: { readonly type: "running" } } }["data"]
-
 export type SessionsGetInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
 
 export type SessionsGetOutput = {
@@ -581,26 +579,7 @@ export type SessionsContextOutput = {
           readonly reasoning: number
           readonly cache: { readonly read: number; readonly write: number }
         }
-        readonly error?:
-          | { readonly type: "unknown"; readonly message: string }
-          | {
-              readonly type: "provider"
-              readonly category:
-                | "invalid-request"
-                | "no-route"
-                | "authentication"
-                | "rate-limit"
-                | "quota-exceeded"
-                | "content-policy"
-                | "provider-internal"
-                | "transport"
-                | "invalid-provider-output"
-                | "unknown"
-              readonly message: string
-              readonly status?: number | null
-              readonly retryable: boolean
-              readonly retryAfterMs?: number | null
-            }
+        readonly error?: { readonly type: "unknown"; readonly message: string }
       }
     | {
         readonly type: "compaction"
@@ -613,657 +592,3 @@ export type SessionsContextOutput = {
       }
   >
 }["data"]
-
-export type SessionsEventsInput = {
-  readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly after?: { readonly after?: string | undefined }["after"]
-}
-
-export type SessionsEventsOutput =
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.agent.switched"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly agent: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.model.switched"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.moved"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly location: { readonly directory: string; readonly workspaceID?: string }
-        readonly subdirectory?: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.prompted"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly prompt: {
-          readonly text: string
-          readonly files?: ReadonlyArray<{
-            readonly uri: string
-            readonly mime: string
-            readonly name?: string
-            readonly description?: string
-            readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-          }>
-          readonly agents?: ReadonlyArray<{
-            readonly name: string
-            readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-          }>
-        }
-        readonly delivery: "steer" | "queue"
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.prompt.admitted"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly prompt: {
-          readonly text: string
-          readonly files?: ReadonlyArray<{
-            readonly uri: string
-            readonly mime: string
-            readonly name?: string
-            readonly description?: string
-            readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-          }>
-          readonly agents?: ReadonlyArray<{
-            readonly name: string
-            readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-          }>
-        }
-        readonly delivery: "steer" | "queue"
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.context.updated"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly text: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.synthetic"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly text: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.shell.started"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly callID: string
-        readonly command: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.shell.ended"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly callID: string
-        readonly output: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.step.started"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly agent: string
-        readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        readonly snapshot?: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.step.ended"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly finish: string
-        readonly cost: number
-        readonly tokens: {
-          readonly input: number
-          readonly output: number
-          readonly reasoning: number
-          readonly cache: { readonly read: number; readonly write: number }
-        }
-        readonly snapshot?: string
-        readonly files?: ReadonlyArray<string>
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.step.failed"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly error:
-          | { readonly type: "unknown"; readonly message: string }
-          | {
-              readonly type: "provider"
-              readonly category:
-                | "invalid-request"
-                | "no-route"
-                | "authentication"
-                | "rate-limit"
-                | "quota-exceeded"
-                | "content-policy"
-                | "provider-internal"
-                | "transport"
-                | "invalid-provider-output"
-                | "unknown"
-              readonly message: string
-              readonly status?: number | undefined
-              readonly retryable: boolean
-              readonly retryAfterMs?: number | undefined
-            }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.text.started"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly textID: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.text.ended"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly textID: string
-        readonly text: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.tool.input.started"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly callID: string
-        readonly name: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.tool.input.ended"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly callID: string
-        readonly text: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.tool.called"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly callID: string
-        readonly tool: string
-        readonly input: { readonly [x: string]: unknown }
-        readonly provider: {
-          readonly executed: boolean
-          readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
-        }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.tool.progress"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly callID: string
-        readonly structured: { readonly [x: string]: unknown }
-        readonly content: ReadonlyArray<
-          | { readonly type: "text"; readonly text: string }
-          | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
-        >
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.tool.success"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly callID: string
-        readonly structured: { readonly [x: string]: unknown }
-        readonly content: ReadonlyArray<
-          | { readonly type: "text"; readonly text: string }
-          | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
-        >
-        readonly outputPaths?: ReadonlyArray<string>
-        readonly result?: unknown
-        readonly provider: {
-          readonly executed: boolean
-          readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
-        }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.tool.failed"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly callID: string
-        readonly error: { readonly type: "unknown"; readonly message: string }
-        readonly result?: unknown
-        readonly provider: {
-          readonly executed: boolean
-          readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
-        }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.reasoning.started"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly reasoningID: string
-        readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.reasoning.ended"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly assistantMessageID: string
-        readonly reasoningID: string
-        readonly text: string
-        readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.retried"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly attempt: number
-        readonly error: {
-          readonly message: string
-          readonly statusCode?: number
-          readonly isRetryable: boolean
-          readonly responseHeaders?: { readonly [x: string]: string }
-          readonly responseBody?: string
-          readonly metadata?: { readonly [x: string]: string }
-        }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.compaction.started"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly reason: "auto" | "manual"
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.compaction.ended"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly messageID: string
-        readonly reason: "auto" | "manual"
-        readonly text: string
-        readonly recent: string
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.revert.staged"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly timestamp: number
-        readonly sessionID: string
-        readonly revert: {
-          readonly messageID: string
-          readonly partID?: string
-          readonly snapshot?: string
-          readonly diff?: string
-          readonly files?: ReadonlyArray<{
-            readonly path: string
-            readonly status: "added" | "modified" | "deleted"
-            readonly additions: number
-            readonly deletions: number
-            readonly patch: string
-          }>
-        }
-      }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.revert.cleared"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: { readonly timestamp: number; readonly sessionID: string }
-    }
-  | {
-      readonly id: string
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.next.revert.committed"
-      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: { readonly timestamp: number; readonly sessionID: string; readonly messageID: string }
-    }
-
-export type SessionsInterruptInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
-
-export type SessionsInterruptOutput = void
-
-export type SessionsMessageInput = {
-  readonly sessionID: { readonly sessionID: string; readonly messageID: string }["sessionID"]
-  readonly messageID: { readonly sessionID: string; readonly messageID: string }["messageID"]
-}
-
-export type SessionsMessageOutput = {
-  readonly data:
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly time: { readonly created: number }
-        readonly type: "agent-switched"
-        readonly agent: string
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly time: { readonly created: number }
-        readonly type: "model-switched"
-        readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly time: { readonly created: number }
-        readonly text: string
-        readonly files?: ReadonlyArray<{
-          readonly uri: string
-          readonly mime: string
-          readonly name?: string
-          readonly description?: string
-          readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-        }>
-        readonly agents?: ReadonlyArray<{
-          readonly name: string
-          readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-        }>
-        readonly type: "user"
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly time: { readonly created: number }
-        readonly sessionID: string
-        readonly text: string
-        readonly type: "synthetic"
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly time: { readonly created: number }
-        readonly type: "system"
-        readonly text: string
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly time: { readonly created: number; readonly completed?: number }
-        readonly type: "shell"
-        readonly callID: string
-        readonly command: string
-        readonly output: string
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly time: { readonly created: number; readonly completed?: number }
-        readonly type: "assistant"
-        readonly agent: string
-        readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        readonly content: ReadonlyArray<
-          | { readonly type: "text"; readonly id: string; readonly text: string }
-          | {
-              readonly type: "reasoning"
-              readonly id: string
-              readonly text: string
-              readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-            }
-          | {
-              readonly type: "tool"
-              readonly id: string
-              readonly name: string
-              readonly provider?: {
-                readonly executed: boolean
-                readonly metadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-                readonly resultMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-              }
-              readonly state:
-                | { readonly status: "pending"; readonly input: string }
-                | {
-                    readonly status: "running"
-                    readonly input: { readonly [x: string]: JsonValue }
-                    readonly structured: { readonly [x: string]: JsonValue }
-                    readonly content: ReadonlyArray<
-                      | { readonly type: "text"; readonly text: string }
-                      | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
-                    >
-                  }
-                | {
-                    readonly status: "completed"
-                    readonly input: { readonly [x: string]: JsonValue }
-                    readonly attachments?: ReadonlyArray<{
-                      readonly uri: string
-                      readonly mime: string
-                      readonly name?: string
-                      readonly description?: string
-                      readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-                    }>
-                    readonly content: ReadonlyArray<
-                      | { readonly type: "text"; readonly text: string }
-                      | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
-                    >
-                    readonly outputPaths?: ReadonlyArray<string>
-                    readonly structured: { readonly [x: string]: JsonValue }
-                    readonly result?: JsonValue
-                  }
-                | {
-                    readonly status: "error"
-                    readonly input: { readonly [x: string]: JsonValue }
-                    readonly content: ReadonlyArray<
-                      | { readonly type: "text"; readonly text: string }
-                      | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
-                    >
-                    readonly structured: { readonly [x: string]: JsonValue }
-                    readonly error: { readonly type: "unknown"; readonly message: string }
-                    readonly result?: JsonValue
-                  }
-              readonly time: {
-                readonly created: number
-                readonly ran?: number
-                readonly completed?: number
-                readonly pruned?: number
-              }
-            }
-        >
-        readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
-        readonly finish?: string
-        readonly cost?: number
-        readonly tokens?: {
-          readonly input: number
-          readonly output: number
-          readonly reasoning: number
-          readonly cache: { readonly read: number; readonly write: number }
-        }
-        readonly error?:
-          | { readonly type: "unknown"; readonly message: string }
-          | {
-              readonly type: "provider"
-              readonly category:
-                | "invalid-request"
-                | "no-route"
-                | "authentication"
-                | "rate-limit"
-                | "quota-exceeded"
-                | "content-policy"
-                | "provider-internal"
-                | "transport"
-                | "invalid-provider-output"
-                | "unknown"
-              readonly message: string
-              readonly status?: number | null
-              readonly retryable: boolean
-              readonly retryAfterMs?: number | null
-            }
-      }
-    | {
-        readonly type: "compaction"
-        readonly reason: "auto" | "manual"
-        readonly summary: string
-        readonly recent: string
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly time: { readonly created: number }
-      }
-}["data"]

packages/client/test/effect.test.ts

@@ -1,7 +1,7 @@
 import { expect, test } from "bun:test"
-import { DateTime, Effect, Stream } from "effect"
+import { DateTime, Effect } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-import { AbsolutePath, Agent, Location, Model, OpenCode, Prompt, Session, SessionMessage } from "../src/effect"
+import { AbsolutePath, Agent, Location, Model, OpenCode, Prompt, Session } from "../src/effect"
 
 test("sessions.get returns the decoded Effect projection", async () => {
   const httpClient = HttpClient.make((request) =>
@@ -18,30 +18,12 @@ test("sessions.get returns the decoded Effect projection", async () => {
 test("session methods retain decoded Effect inputs and outputs", async () => {
   const httpClient = HttpClient.make((request) => {
     const url = request.url
-    if (url.includes("/event")) {
-      return Effect.succeed(
-        HttpClientResponse.fromWeb(
-          request,
-          new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\n`, {
-            headers: { "content-type": "text/event-stream" },
-          }),
-        ),
-      )
-    }
     if (url.includes("/prompt")) {
       return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(admission)))
     }
     if (url.includes("/context")) {
       return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ data: [] })))
     }
-    if (url.includes("/message/")) {
-      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ data: modelSwitchedMessage })))
-    }
-    if (url.endsWith("/api/session/active")) {
-      return Effect.succeed(
-        HttpClientResponse.fromWeb(request, Response.json({ data: { ses_test: { type: "running" } } })),
-      )
-    }
     if (request.method === "POST" && url.endsWith("/api/session")) {
       return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(session)))
     }
@@ -55,7 +37,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   const result = await Effect.gen(function* () {
     const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
     const page = yield* client.sessions.list({ limit: 10 })
-    const active = yield* client.sessions.active()
     const created = yield* client.sessions.create({
       location: Location.Ref.make({ directory: AbsolutePath.make("/tmp/project") }),
     })
@@ -72,19 +53,10 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     yield* client.sessions.compact({ sessionID: Session.ID.make("ses_test") })
     yield* client.sessions.wait({ sessionID: Session.ID.make("ses_test") })
     const context = yield* client.sessions.context({ sessionID: Session.ID.make("ses_test") })
-    const events = yield* client.sessions
-      .events({ sessionID: Session.ID.make("ses_test"), after: 0 })
-      .pipe(Stream.runCollect)
-    yield* client.sessions.interrupt({ sessionID: Session.ID.make("ses_test") })
-    const message = yield* client.sessions.message({
-      sessionID: Session.ID.make("ses_test"),
-      messageID: SessionMessage.ID.make("msg_model"),
-    })
-    return { page, active, created, admitted, context, events, message }
+    return { page, created, admitted, context }
   }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
 
   expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
-  expect(result.active).toEqual({ ses_test: { type: "running" } })
   expect(Object.getPrototypeOf(result.page.data[0])).toBe(Object.prototype)
   expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
   expect(result.created.id).toBe("ses_test")
@@ -92,8 +64,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   expect(Object.getPrototypeOf(result.admitted.prompt)).toBe(Object.prototype)
   expect(DateTime.toEpochMillis(result.admitted.timeCreated)).toBe(1_717_171_717_000)
   expect(result.context).toEqual([])
-  expect(DateTime.toEpochMillis(result.events[0].data.timestamp)).toBe(1_717_171_717_000)
-  expect(result.message).toEqual(expect.objectContaining({ id: "msg_model", type: "model-switched" }))
 })
 
 const session = {
@@ -126,22 +96,3 @@ const admission = {
     timeCreated: 1_717_171_717_000,
   },
 }
-
-const modelSwitchedMessage = {
-  id: "msg_model",
-  type: "model-switched",
-  time: { created: 1_717_171_717_000 },
-  model: { id: "claude", providerID: "anthropic" },
-}
-
-const modelSwitchedEvent = {
-  id: "evt_model",
-  type: "session.next.model.switched",
-  durable: { aggregateID: "ses_test", seq: 1, version: 1 },
-  data: {
-    timestamp: 1_717_171_717_000,
-    sessionID: "ses_test",
-    messageID: "msg_model",
-    model: { id: "claude", providerID: "anthropic" },
-  },
-}

packages/client/test/promise.test.ts

@@ -24,15 +24,8 @@ test("session methods use the public HTTP contract", async () => {
     fetch: async (input, init) => {
       const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url
       requests.push({ url, init })
-      if (url.includes("/event")) {
-        return new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\n`, {
-          headers: { "content-type": "text/event-stream" },
-        })
-      }
       if (url.includes("/prompt")) return Response.json(admission)
       if (url.includes("/context")) return Response.json({ data: [] })
-      if (url.includes("/message/")) return Response.json({ data: modelSwitchedMessage })
-      if (url.endsWith("/api/session/active")) return Response.json({ data: { ses_test: { type: "running" } } })
       if (init?.method === "POST" && url.endsWith("/api/session")) return Response.json(session)
       if (init?.method === "POST") return new Response(null, { status: 204 })
       return Response.json({ data: [session.data], cursor: { next: "next" } })
@@ -40,7 +33,6 @@ test("session methods use the public HTTP contract", async () => {
   })
 
   const page = await client.sessions.list({ limit: "10", order: "desc" })
-  const active = await client.sessions.active()
   const created = await client.sessions.create({ location: { directory: "/tmp/project" } })
   await client.sessions.switchAgent({ sessionID: "ses_test", agent: "build" })
   await client.sessions.switchModel({
@@ -55,21 +47,13 @@ test("session methods use the public HTTP contract", async () => {
   await client.sessions.compact({ sessionID: "ses_test" })
   await client.sessions.wait({ sessionID: "ses_test" })
   const context = await client.sessions.context({ sessionID: "ses_test" })
-  const events = []
-  for await (const event of client.sessions.events({ sessionID: "ses_test", after: "0" })) events.push(event)
-  await client.sessions.interrupt({ sessionID: "ses_test" })
-  const message = await client.sessions.message({ sessionID: "ses_test", messageID: "msg_model" })
 
   expect(page.cursor.next).toBe("next")
-  expect(active).toEqual({ ses_test: { type: "running" } })
   expect(created.id).toBe("ses_test")
   expect(admitted.id).toBe("msg_test")
   expect(context).toEqual([])
-  expect(events).toEqual([modelSwitchedEvent])
-  expect(message).toEqual(modelSwitchedMessage)
   expect(requests.map((request) => [request.init?.method, request.url])).toEqual([
     ["GET", "http://localhost:3000/api/session?limit=10&order=desc"],
-    ["GET", "http://localhost:3000/api/session/active"],
     ["POST", "http://localhost:3000/api/session"],
     ["POST", "http://localhost:3000/api/session/ses_test/agent"],
     ["POST", "http://localhost:3000/api/session/ses_test/model"],
@@ -77,11 +61,8 @@ test("session methods use the public HTTP contract", async () => {
     ["POST", "http://localhost:3000/api/session/ses_test/compact"],
     ["POST", "http://localhost:3000/api/session/ses_test/wait"],
     ["GET", "http://localhost:3000/api/session/ses_test/context"],
-    ["GET", "http://localhost:3000/api/session/ses_test/event?after=0"],
-    ["POST", "http://localhost:3000/api/session/ses_test/interrupt"],
-    ["GET", "http://localhost:3000/api/session/ses_test/message/msg_model"],
   ])
-  const body = requests.find((request) => request.url.endsWith("/api/session/ses_test/prompt"))?.init?.body
+  const body = requests[4]?.init?.body
   if (typeof body !== "string") throw new Error("Expected JSON request body")
   expect(JSON.parse(body)).toEqual({
     prompt: { text: "Hello" },
@@ -134,22 +115,3 @@ const admission = {
     timeCreated: 1_717_171_717_000,
   },
 }
-
-const modelSwitchedMessage = {
-  id: "msg_model",
-  type: "model-switched",
-  time: { created: 1_717_171_717_000 },
-  model: { id: "claude", providerID: "anthropic" },
-}
-
-const modelSwitchedEvent = {
-  id: "evt_model",
-  type: "session.next.model.switched",
-  durable: { aggregateID: "ses_test", seq: 1, version: 1 },
-  data: {
-    timestamp: 1_717_171_717_000,
-    sessionID: "ses_test",
-    messageID: "msg_model",
-    model: { id: "claude", providerID: "anthropic" },
-  },
-}

packages/core/src/catalog.ts

@@ -235,11 +235,6 @@ export const layer = Layer.effect(
           if (!record) return
           const provider = record.provider
 
-          // TODO: Remove these provider-specific assumptions once model syncing reliably reports available deployments.
-          if (providerID === ProviderV2.ID.azure || providerID === ProviderV2.ID.make("azure-cognitive-services")) {
-            return
-          }
-
           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)

packages/core/src/config/mcp.ts

@@ -3,15 +3,6 @@ export * as ConfigMCP from "./mcp"
 import { Schema } from "effect"
 import { PositiveInt } from "../schema"
 
-export class Timeout extends Schema.Class<Timeout>("ConfigV2.MCP.Timeout")({
-  startup: PositiveInt.pipe(Schema.optional).annotate({
-    description: "Maximum time in milliseconds to establish and initialize the MCP server.",
-  }),
-  request: PositiveInt.pipe(Schema.optional).annotate({
-    description: "Maximum time in milliseconds to wait for each MCP request after initialization.",
-  }),
-}) {}
-
 export class Local extends Schema.Class<Local>("ConfigV2.MCP.Local")({
   type: Schema.Literal("local"),
   command: Schema.String.pipe(Schema.Array),
@@ -20,7 +11,7 @@ export class Local extends Schema.Class<Local>("ConfigV2.MCP.Local")({
   }),
   environment: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
   disabled: Schema.Boolean.pipe(Schema.optional),
-  timeout: Timeout.pipe(Schema.optional),
+  timeout: PositiveInt.pipe(Schema.optional),
 }) {}
 
 export class OAuth extends Schema.Class<OAuth>("ConfigV2.MCP.OAuth")({
@@ -37,12 +28,12 @@ export class Remote extends Schema.Class<Remote>("ConfigV2.MCP.Remote")({
   headers: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
   oauth: Schema.Union([OAuth, Schema.Literal(false)]).pipe(Schema.optional),
   disabled: Schema.Boolean.pipe(Schema.optional),
-  timeout: Timeout.pipe(Schema.optional),
+  timeout: PositiveInt.pipe(Schema.optional),
 }) {}
 
 export const Server = Schema.Union([Local, Remote]).pipe(Schema.toTaggedUnion("type"))
 
 export class Info extends Schema.Class<Info>("ConfigV2.MCP")({
-  timeout: Timeout.pipe(Schema.optional),
+  timeout: PositiveInt.pipe(Schema.optional),
   servers: Schema.Record(Schema.String, Server).pipe(Schema.optional),
 }) {}

packages/core/src/control-plane/move-session.ts

@@ -6,9 +6,9 @@ import { Git } from "../git"
 import { Location } from "../location"
 import { ProjectV2 } from "../project"
 import { SessionV2 } from "../session"
+import { SessionExecution } from "../session/execution"
 import { SessionEvent } from "../session/event"
 import { SessionSchema } from "../session/schema"
-import { SessionStore } from "../session/store"
 import { AbsolutePath, RelativePath } from "../schema"
 import path from "path"
 
@@ -71,11 +71,10 @@ export const layer = Layer.effect(
     const git = yield* Git.Service
     const events = yield* EventV2.Service
     const project = yield* ProjectV2.Service
-    const sessions = yield* SessionStore.Service
+    const session = yield* SessionV2.Service
 
     const moveSession = Effect.fn("MoveSession.moveSession")(function* (input: Input) {
-      const current = yield* sessions.get(input.sessionID)
-      if (!current) return yield* new SessionV2.NotFoundError({ sessionID: input.sessionID })
+      const current = yield* session.get(input.sessionID)
       const directory = AbsolutePath.make(input.destination.directory)
       if (current.location.directory === directory) return
 
@@ -144,5 +143,6 @@ export const defaultLayer = layer.pipe(
   Layer.provide(Git.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(ProjectV2.defaultLayer),
-  Layer.provide(SessionStore.defaultLayer),
+  Layer.provide(SessionExecution.noopLayer),
+  Layer.provide(SessionV2.defaultLayer),
 )

packages/core/src/cross-spawn-spawner.ts

@@ -503,6 +503,6 @@ export const layer: Layer.Layer<ChildProcessSpawner, never, FileSystem.FileSyste
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer), Layer.provide(NodePath.layer))
-export const node = LayerNode.make({ service: ChildProcessSpawner, layer, deps: [filesystem, path] })
+export const node = LayerNode.make(layer, [filesystem, path])
 
 export * as CrossSpawnSpawner from "./cross-spawn-spawner"

packages/core/src/database/database.ts

@@ -60,4 +60,4 @@ export const defaultLayer = Layer.unwrap(
   }),
 ).pipe(Layer.provide(Global.defaultLayer))
 
-export const node = LayerNode.make({ service: Service, layer: layerFromPath(path()), deps: [] })
+export const node = LayerNode.make(layerFromPath(path()), [])

packages/core/src/effect/layer-node-platform.ts

@@ -1,18 +1,12 @@
 import { NodeFileSystem, NodePath } from "@effect/platform-node"
 import { LLMClient, RequestExecutor } from "@opencode-ai/llm/route"
-import { FileSystem, Path } from "effect"
 import { FetchHttpClient } from "effect/unstable/http"
-import { HttpClient } from "effect/unstable/http"
 import { LayerNode } from "./layer-node"
 
-export const filesystem = LayerNode.make({ service: FileSystem.FileSystem, layer: NodeFileSystem.layer, deps: [] })
-export const path = LayerNode.make({ service: Path.Path, layer: NodePath.layer, deps: [] })
-export const httpClient = LayerNode.make({ service: HttpClient.HttpClient, layer: FetchHttpClient.layer, deps: [] })
-export const requestExecutor = LayerNode.make({
-  service: RequestExecutor.Service,
-  layer: RequestExecutor.layer,
-  deps: [httpClient],
-})
-export const llmClient = LayerNode.make({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] })
+export const filesystem = LayerNode.make(NodeFileSystem.layer, [])
+export const path = LayerNode.make(NodePath.layer, [])
+export const httpClient = LayerNode.make(FetchHttpClient.layer, [])
+export const requestExecutor = LayerNode.make(RequestExecutor.layer, [httpClient])
+export const llmClient = LayerNode.make(LLMClient.layer, [requestExecutor])
 
 export * as LayerNodePlatform from "./layer-node-platform"

packages/core/src/effect/layer-node.ts

@@ -1,10 +1,10 @@
-import { Brand, Context, Layer } from "effect"
+import { Layer } from "effect"
 
 type RuntimeLayer = Layer.Layer<never, unknown, unknown>
-type AnyNode = Node<unknown, unknown, any>
-type NodeList<Item extends AnyNode = AnyNode> = readonly [] | readonly [Item, ...Item[]]
-type Output<Item> = [Item] extends [never] ? never : Item extends Node<infer A, unknown, any> ? A : never
-type Error<Item> = [Item] extends [never] ? never : Item extends Node<unknown, infer E, any> ? E : never
+type AnyNode = Node<unknown, unknown>
+type NodeList = readonly [] | readonly [AnyNode, ...AnyNode[]]
+type Output<Item> = [Item] extends [never] ? never : Item extends Node<infer A, unknown> ? A : never
+type Error<Item> = [Item] extends [never] ? never : Item extends Node<unknown, infer E> ? E : never
 type Missing<Required, Dependencies extends NodeList> = Exclude<Required, Output<Dependencies[number]>>
 type CheckDependencies<Implementation extends Layer.Any, Dependencies extends NodeList> = [
   Missing<Layer.Services<Implementation>, Dependencies>,
@@ -14,235 +14,89 @@ type CheckDependencies<Implementation extends Layer.Any, Dependencies extends No
 declare const $OutputType: unique symbol
 declare const $ErrorType: unique symbol
 
-export type Tier<Name extends string = string> = Name & Brand.Brand<"LayerNode.Tier">
-
-const makeTier = Brand.nominal<Tier>()
-
-export type Node<A, E = never, T extends Tier | undefined = undefined> = {
+export type Node<A, E = never> = {
   readonly kind: "layer" | "group"
-  readonly name: string
-  readonly service?: Context.Service.Any
   readonly implementation?: Layer.Any
   readonly dependencies: readonly AnyNode[]
-  readonly tier?: T
   readonly [$OutputType]?: () => A
   readonly [$ErrorType]?: () => E
 }
 
-type NodeIdentity =
-  | { readonly service: Context.Service.Any; readonly name?: never }
-  | { readonly name: string; readonly service?: never }
-type DistributiveOmit<A, K extends PropertyKey> = A extends unknown ? Omit<A, K> : never
-
-type NodeInput<
-  Implementation extends Layer.Any,
-  Items extends NodeList,
-  T extends Tier | undefined = undefined,
-> = NodeIdentity & {
-  readonly layer: Implementation
-  readonly deps: Items & CheckDependencies<Implementation, NoInfer<Items>>
-  readonly tier?: T
-}
-
-export function make<
-  const Implementation extends Layer.Any,
-  const Items extends NodeList,
-  const T extends Tier | undefined = undefined,
->(
-  input: NodeInput<Implementation, Items, T>,
-): Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, T> {
-  return {
-    kind: "layer",
-    name: input.service !== undefined ? input.service.key : input.name,
-    service: input.service,
-    implementation: input.layer,
-    dependencies: input.deps,
-    tier: input.tier,
-  }
+export function make<const Implementation extends Layer.Any, const Items extends NodeList>(
+  implementation: Implementation,
+  dependencies: Items & CheckDependencies<Implementation, NoInfer<Items>>,
+): Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>> {
+  return { kind: "layer", implementation: implementation as Layer.Any, dependencies }
 }
 
 export function group<const Items extends NodeList>(
   dependencies: Items,
 ): Node<Output<Items[number]>, Error<Items[number]>> {
-  return { kind: "group", name: "group", dependencies }
+  return { kind: "group", dependencies }
 }
 
-type AllowedTierNames<Names extends readonly string[], Name extends Names[number]> = Names extends readonly [
-  infer Head extends string,
-  ...infer Tail extends readonly string[],
-]
-  ? Head extends Name
-    ? Head | Tail[number]
-    : AllowedTierNames<Tail, Name>
-  : never
-
-type NodeInTiers<Names extends string> = Node<unknown, unknown, Tier<Names>>
-
-export interface Tiers<Names extends readonly [string, ...string[]]> {
-  readonly names: Names
-  readonly values: { readonly [K in Names[number]]: Tier<K> }
-  readonly make: <Name extends Names[number]>(
-    name: Name,
-  ) => <
-    const Implementation extends Layer.Any,
-    const Items extends NodeList<NodeInTiers<AllowedTierNames<Names, Name>>>,
-  >(
-    input: DistributiveOmit<NodeInput<Implementation, Items, Tier<Name>>, "tier">,
-  ) => Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, Tier<Name>>
-}
-
-export function tiers<const Names extends readonly [string, ...string[]]>(names: Names): Tiers<Names> {
-  const values = Object.fromEntries(names.map((name) => [name, makeTier(name)])) as Tiers<Names>["values"]
-  return {
-    names,
-    values,
-    make: ((name: Names[number]) => (input: DistributiveOmit<NodeInput<Layer.Any, NodeList, Tier>, "tier">) =>
-      make({ ...input, tier: values[name] })) as Tiers<Names>["make"],
-  }
-}
-
-const defaultTiers = tiers(["untiered"])
-const untiered = defaultTiers.values.untiered
-
-export type Replacement = {
-  readonly source: Layer.Any
-  readonly replacement: Layer.Any
+export type Replacement<A = unknown> = {
+  readonly source: Node<A, unknown>
+  readonly replacement: Node<A, unknown>
 }
 
 type CheckReplacementErrors<SourceError, ReplacementError> = [Exclude<ReplacementError, SourceError>] extends [never]
   ? unknown
   : { readonly "New replacement errors": Exclude<ReplacementError, SourceError> }
 
-export function replace<A, E, R, E2>(
-  source: Layer.Layer<A, E, R>,
-  replacement: Layer.Layer<NoInfer<A>, E2, never> & CheckReplacementErrors<E, NoInfer<E2>>,
-): Replacement {
+export function replaceWithNode<A, E, E2>(
+  source: Node<A, E>,
+  replacement: Node<NoInfer<A>, E2> & CheckReplacementErrors<E, NoInfer<E2>>,
+): Replacement<A> {
   return { source, replacement }
 }
 
-export function buildLayer<
-  A,
-  E,
-  const Names extends readonly [string, ...string[]] = readonly ["untiered"],
-  const Built extends Layer.Any = Layer.Layer<never, never, never>,
->(
-  node: Node<A, E, any>,
-  options?: {
-    readonly tiers?: Tiers<Names>
-    readonly buildTier?: (tier: Names[number], layers: readonly Layer.Any[]) => Built
-    readonly replacements?: readonly Replacement[]
-  },
-): Layer.Layer<A | Layer.Success<Built>, E | Layer.Error<Built>, never> {
-  const tiers = options?.tiers ?? (defaultTiers as unknown as Tiers<Names>)
-  const replacementMap = new Map(options?.replacements?.map((item) => [item.source, item.replacement]))
-  const plans = plan(node, tiers, replacementMap)
-  const layers: RuntimeLayer[] = tiers.names.map((name) => {
-    const tier = tiers.values[name as Names[number]]
-    const layers = plans.get(tier) ?? []
-    return (options?.buildTier?.(name, layers) ?? combine(layers)) as RuntimeLayer
-  })
-  if (layers.length === 0) return Layer.empty as never
-  return layers.slice(1).reduce((result, layer) => result.pipe(Layer.provideMerge(layer)), layers[0]) as never
+export function replace<A, E, E2>(
+  source: Node<A, E>,
+  replacement: Layer.Layer<NoInfer<A>, E2, never> & CheckReplacementErrors<E, NoInfer<E2>>,
+): Replacement<A> {
+  return { source, replacement: make(replacement as Layer.Layer<A, E2>, []) }
 }
 
-export function combine(layers: readonly Layer.Any[]): RuntimeLayer {
-  return layers.reduce<RuntimeLayer>(
-    (result, layer) => (layer as RuntimeLayer).pipe(Layer.provideMerge(result)),
-    Layer.empty as RuntimeLayer,
-  )
-}
-
-function plan(
-  root: AnyNode,
-  tiers: Tiers<readonly [string, ...string[]]>,
-  replacements: ReadonlyMap<Layer.Any, Layer.Any>,
-) {
-  const indexes = new Map(tiers.names.map((name, index) => [tiers.values[name], index]))
-  const plans = new Map<Tier, Layer.Any[]>()
-  const activeImplementations = new Map<Tier, Map<string, AnyNode>>()
-  const serviceTiers = new Map<string, Tier>()
+export function buildLayer<A, E>(node: Node<A, E>, options?: { readonly replacements?: readonly Replacement[] }) {
+  const replacements = new Map(options?.replacements?.map((item) => [item.source, item.replacement]))
+  const cache = new Map<AnyNode, RuntimeLayer>()
   const visiting = new Set<AnyNode>()
   const stack: AnyNode[] = []
-  const boundaryVisited = new Map<AnyNode, Set<Tier>>()
-  const boundaryServices = new Map<Tier, Map<string, AnyNode>>()
-
-  const validateBoundary = (node: AnyNode, origin: Tier) => {
-    const checked = boundaryVisited.get(node) ?? new Set<Tier>()
-    boundaryVisited.set(node, checked)
-    if (checked.has(origin)) return false
-    checked.add(origin)
-    const services = boundaryServices.get(origin) ?? new Map<string, AnyNode>()
-    boundaryServices.set(origin, services)
-    const key = node.name
-    const existing = services.get(key)
-    if (existing && existing !== node) {
-      throw new Error(`Tier ${origin} has conflicting implementations for ${key}`)
-    }
-    services.set(key, node)
-    return true
-  }
-
-  const visit = (node: AnyNode, currentTier?: Tier, origins: readonly Tier[] = []) => {
-    if (node.kind === "group") {
-      node.dependencies.forEach((dependency) => visit(dependency, currentTier, origins))
-      return
-    }
-
-    const tier = node.tier ?? untiered
-    if (!indexes.has(tier)) throw new Error(`Node ${node.name} is not in the tier configuration`)
-    const key = node.name
-    const serviceTier = serviceTiers.get(key)
-    if (serviceTier && serviceTier !== tier) {
-      throw new Error(`Service ${key} belongs to both tier ${serviceTier} and tier ${tier}`)
-    }
-    serviceTiers.set(key, tier)
-    const nextOrigins = [...origins]
-    if (currentTier) {
-      const current = indexes.get(currentTier)!
-      const required = indexes.get(tier)!
-      if (required < current) {
-        throw new Error(`Tier ${currentTier} cannot depend on lower tier ${tier}`)
-      }
-      if (required > current) nextOrigins.push(currentTier)
-    }
-    const unseenOrigins = nextOrigins.filter((origin) => validateBoundary(node, origin))
-
-    // A node may need to be emitted more than once because the final output is a
-    // flat list of layers applied with Layer.provideMerge. If another node for
-    // the same service was emitted afterward, this node is no longer the active
-    // implementation for subsequent consumers. Re-emitting restores the intended
-    // implementation ordering while Effect memoization avoids reacquiring the layer.
-    const implementations = activeImplementations.get(tier) ?? new Map<string, AnyNode>()
-    activeImplementations.set(tier, implementations)
-    if (implementations.get(key) === node && unseenOrigins.length === 0) return
+  const ids = new Map<AnyNode, number>()
 
+  const visit = (input: AnyNode): RuntimeLayer => {
+    const node = replacements.get(input) ?? input
+    const cached = cache.get(node)
+    if (cached) return cached
     if (visiting.has(node)) {
       const start = stack.indexOf(node)
-      throw new Error(
-        `Cycle detected in layer graph: ${[...stack.slice(start), node].map((item) => item.name).join(" -> ")}`,
-      )
+      const cycle = [...stack.slice(start), node].map((item) => `${item.kind}#${ids.get(item)}`).join(" -> ")
+      throw new Error(`Cycle detected in app graph: ${cycle}`)
     }
-
+    if (!ids.has(node)) ids.set(node, ids.size + 1)
     visiting.add(node)
     stack.push(node)
     try {
-      node.dependencies.forEach((dependency) => visit(dependency, tier, unseenOrigins))
-      const layers = plans.get(tier) ?? []
-      plans.set(tier, layers)
-      layers.push(replacements.get(node.implementation!) ?? node.implementation!)
-      implementations.set(key, node)
+      const dependencies = node.dependencies.map(visit)
+      const nonEmpty = dependencies as [RuntimeLayer, ...RuntimeLayer[]]
+      const result =
+        node.kind === "group"
+          ? dependencies.length === 0
+            ? Layer.empty
+            : Layer.mergeAll(...nonEmpty)
+          : dependencies.length === 0
+            ? (node.implementation as RuntimeLayer)
+            : Layer.provide(node.implementation as RuntimeLayer, nonEmpty)
+      cache.set(node, result)
+      return result
     } finally {
       stack.pop()
       visiting.delete(node)
     }
   }
 
-  visit(root)
-  return plans
-}
-
-function requireTier(node: AnyNode, indexes: ReadonlyMap<Tier, number>) {
-  if (!node.tier || !indexes.has(node.tier)) throw new Error(`Node ${node.name} is not in the tier configuration`)
+  return visit(node) as unknown as Layer.Layer<A, E, never>
 }
 
 export * as LayerNode from "./layer-node"

packages/core/src/effect/scoped-node.ts

@@ -1,11 +0,0 @@
-import { LayerNode } from "./layer-node"
-
-export const tiers = LayerNode.tiers(["location", "global"])
-
-export type GlobalNode<A, E = never> = LayerNode.Node<A, E, (typeof tiers.values)["global"]>
-export type LocationNode<A, E = never> = LayerNode.Node<A, E, (typeof tiers.values)["location"]>
-
-export const makeGlobalNode = tiers.make("global")
-export const makeLocationNode = tiers.make("location")
-
-export * as ScopedNode from "./scoped-node"

packages/core/src/event.ts

@@ -569,6 +569,6 @@ export const layerWith = (options?: LayerOptions) =>
   )
 
 export const layer = layerWith()
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Database.node] })
+export const node = LayerNode.make(layer, [Database.node])
 
 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))

packages/core/src/fs-util.ts

@@ -201,7 +201,7 @@ export namespace FSUtil {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer))
-  export const node = LayerNode.make({ service: Service, layer: layer, deps: [filesystem] })
+  export const node = LayerNode.make(layer, [filesystem])
 
   // Pure helpers that don't need Effect (path manipulation, sync operations)
   export function mimeType(p: string): string {

packages/core/src/git.ts

@@ -944,7 +944,7 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer), Layer.provide(AppProcess.defaultLayer))
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node, AppProcess.node] })
+export const node = LayerNode.make(layer, [FSUtil.node, AppProcess.node])
 
 interface Result {
   readonly exitCode: number

packages/core/src/global.ts

@@ -77,7 +77,7 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [] })
+export const node = LayerNode.make(layer, [])
 
 export const layerWith = (input: Partial<Interface>) =>
   Layer.effect(

packages/core/src/models-dev.ts

@@ -244,6 +244,6 @@ export const defaultLayer = layer.pipe(
   Layer.provide(FSUtil.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
 )
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node, EventV2.node, httpClient] })
+export const node = LayerNode.make(layer, [FSUtil.node, EventV2.node, httpClient])
 
 export * as ModelsDev from "./models-dev"

packages/core/src/npm.ts

@@ -253,11 +253,7 @@ export const defaultLayer = layer.pipe(
   Layer.provide(Global.layer),
   Layer.provide(NodeFileSystem.layer),
 )
-export const node = LayerNode.make({
-  service: Service,
-  layer: layer,
-  deps: [FSUtil.node, Global.node, filesystem, EffectFlock.node],
-})
+export const node = LayerNode.make(layer, [FSUtil.node, Global.node, filesystem, EffectFlock.node])
 
 const { runPromise } = makeRuntime(Service, defaultLayer)
 

packages/core/src/process.ts

@@ -238,6 +238,6 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(CrossSpawnSpawner.defaultLayer))
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [CrossSpawnSpawner.node] })
+export const node = LayerNode.make(layer, [CrossSpawnSpawner.node])
 
 export * as AppProcess from "./process"

packages/core/src/project.ts

@@ -134,8 +134,4 @@ export const defaultLayer = layer.pipe(
   Layer.provide(Git.defaultLayer),
   Layer.provideMerge(ProjectDirectories.defaultLayer),
 )
-export const node = LayerNode.make({
-  service: Service,
-  layer: layer,
-  deps: [FSUtil.node, Git.node, ProjectDirectories.node],
-})
+export const node = LayerNode.make(layer, [FSUtil.node, Git.node, ProjectDirectories.node])

packages/core/src/project/copy.ts

@@ -279,8 +279,4 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-export const node = LayerNode.make({
-  service: Service,
-  layer: layer,
-  deps: [FSUtil.node, Git.node, ProjectDirectories.node, EventV2.node, Database.node],
-})
+export const node = LayerNode.make(layer, [FSUtil.node, Git.node, ProjectDirectories.node, EventV2.node, Database.node])

packages/core/src/project/directories.ts

@@ -156,4 +156,4 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Database.node] })
+export const node = LayerNode.make(layer, [Database.node])

packages/core/src/pty/ticket.ts

@@ -54,4 +54,4 @@ export const make = (ttl: Duration.Input = DEFAULT_TTL) =>
 export const layer = Layer.effect(Service, make())
 
 export const defaultLayer = layer
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [] })
+export const node = LayerNode.make(layer, [])

packages/core/src/ripgrep.ts

@@ -279,4 +279,4 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(Layer.merge(RipgrepBinary.defaultLayer, AppProcess.defaultLayer)))
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [RipgrepBinary.node, AppProcess.node] })
+export const node = LayerNode.make(layer, [RipgrepBinary.node, AppProcess.node])

packages/core/src/ripgrep/binary.ts

@@ -130,9 +130,5 @@ export namespace RipgrepBinary {
     Layer.provide(CrossSpawnSpawner.defaultLayer),
   )
 
-  export const node = LayerNode.make({
-    service: Service,
-    layer: layer,
-    deps: [FSUtil.node, httpClient, CrossSpawnSpawner.node],
-  })
+  export const node = LayerNode.make(layer, [FSUtil.node, httpClient, CrossSpawnSpawner.node])
 }

packages/core/src/session.ts

@@ -155,7 +155,6 @@ export interface Interface {
   }) => Effect.Effect<void, OperationUnavailableError>
   readonly compact: (input: CompactInput) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
   readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
-  readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
   readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | SessionRunner.RunError>
   readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
   readonly revert: {
@@ -403,7 +402,6 @@ export const layer = Layer.unwrap(
               yield* result.get(sessionID)
               return yield* new OperationUnavailableError({ operation: "wait" })
             }),
-            active: execution.active,
             resume: Effect.fn("V2Session.resume")(function* (sessionID) {
               yield* result.get(sessionID)
               yield* execution.resume(sessionID)
@@ -445,6 +443,7 @@ export const defaultLayer = layer.pipe(
   Layer.provide(
     Layer.unwrap(Effect.promise(() => import("./location-layer")).pipe(Effect.map((m) => m.LocationServiceMap.layer))),
   ),
+  Layer.provide(SessionExecution.noopLayer),
   Layer.provide(SessionStore.defaultLayer),
   Layer.provide(SessionProjector.defaultLayer),
   Layer.provide(EventV2.defaultLayer),

packages/core/src/session/execution.ts

@@ -5,8 +5,6 @@ import { SessionRunner } from "./runner/index"
 import { SessionSchema } from "./schema"
 
 export interface Interface {
-  /** Snapshots active execution owned by this process. */
-  readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
   /** Starts execution while idle or joins the active execution. */
   readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, SessionRunner.RunError>
   /** Registers newly recorded work. Repeated wakeups may coalesce. */
@@ -21,10 +19,5 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 /** Low-level compatibility layer for callers that only need durable Session recording. */
 export const noopLayer = Layer.succeed(
   Service,
-  Service.of({
-    active: Effect.succeed(new Set()),
-    resume: () => Effect.void,
-    wake: () => Effect.void,
-    interrupt: () => Effect.void,
-  }),
+  Service.of({ resume: () => Effect.void, wake: () => Effect.void, interrupt: () => Effect.void }),
 )

packages/core/src/session/execution/local.ts

@@ -28,7 +28,6 @@ export const layer = Layer.effect(
     })
 
     return SessionExecution.Service.of({
-      active: coordinator.active,
       interrupt: coordinator.interrupt,
       resume: coordinator.run,
       wake: coordinator.wake,

packages/core/src/session/projector.ts

@@ -456,4 +456,4 @@ export const layer = Layer.effectDiscard(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(EventV2.defaultLayer), Layer.provide(Database.defaultLayer))
-export const node = LayerNode.make({ name: "session-projector", layer, deps: [EventV2.node, Database.node] })
+export const node = LayerNode.make(layer, [EventV2.node, Database.node])

packages/core/src/session/run-coordinator.ts

@@ -4,8 +4,6 @@ import { Deferred, Effect, Exit, Fiber, FiberSet, Scope } from "effect"
 
 /** Serializes execution for each key while allowing different keys to run concurrently. */
 export interface Coordinator<Key, E> {
-  /** Snapshots keys with an execution owned by this coordinator. */
-  readonly active: Effect.Effect<ReadonlySet<Key>>
   /** Starts execution while idle or joins the active execution. */
   readonly run: (key: Key) => Effect.Effect<void, E>
   /** Registers one coalesced follow-up after newly recorded work. */
@@ -100,5 +98,5 @@ export const make = <Key, E>(options: {
         return Fiber.interrupt(entry.owner)
       })
 
-    return { active: Effect.sync(() => new Set(active.keys())), run, wake, interrupt }
+    return { run, wake, interrupt }
   })

packages/core/src/session/runner/llm.ts

@@ -6,7 +6,6 @@ import {
   Message,
   SystemPart,
   isContextOverflowFailure,
-  type LLMErrorReason,
   type ProviderErrorEvent,
 } from "@opencode-ai/llm"
 import { Cause, DateTime, Effect, FiberSet, Layer, Option, Semaphore, Stream } from "effect"
@@ -33,7 +32,7 @@ import { SessionSchema } from "../schema"
 import { SessionStore } from "../store"
 import { type RunError, Service } from "./index"
 import { SessionRunnerModel } from "./model"
-import { createLLMEventPublisher, providerError } from "./publish-llm-event"
+import { createLLMEventPublisher } from "./publish-llm-event"
 import { toLLMMessages } from "./to-llm-message"
 import { MAX_STEPS_PROMPT } from "./max-steps"
 import { Snapshot } from "../../snapshot"
@@ -88,29 +87,6 @@ import { Snapshot } from "../../snapshot"
  * explicit loop starts the next provider turn after local settlement. Configured agent step limits bound the loop.
  */
 
-const providerCategories = {
-  InvalidRequest: "invalid-request",
-  NoRoute: "no-route",
-  Authentication: "authentication",
-  RateLimit: "rate-limit",
-  QuotaExceeded: "quota-exceeded",
-  ContentPolicy: "content-policy",
-  ProviderInternal: "provider-internal",
-  Transport: "transport",
-  InvalidProviderOutput: "invalid-provider-output",
-  UnknownProvider: "unknown",
-} as const satisfies Record<LLMErrorReason["_tag"], Parameters<typeof providerError>[0]["category"]>
-
-const toSessionProviderError = (reason: LLMErrorReason) =>
-  providerError({
-    category: providerCategories[reason._tag],
-    status:
-      ("http" in reason ? reason.http?.response?.status : undefined) ??
-      ("status" in reason ? reason.status : undefined),
-    retryable: reason.retryable,
-    retryAfterMs: "retryAfterMs" in reason ? reason.retryAfterMs : undefined,
-  })
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -307,7 +283,7 @@ export const layer = Layer.effect(
           const llmFailure = failure instanceof LLMError ? failure : undefined
           if (llmFailure && !publisher.hasProviderError()) {
             yield* withPublication(publisher.failUnsettledTools("Provider did not return a tool result", true))
-            yield* withPublication(publisher.failAssistant(toSessionProviderError(llmFailure.reason)))
+            yield* withPublication(publisher.failAssistant(llmFailure.reason.message))
           }
           if (stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)) yield* FiberSet.clear(toolFibers)
           const settled = yield* restore(awaitToolFibers(toolFibers)).pipe(Effect.exit)
@@ -323,7 +299,7 @@ export const layer = Layer.effect(
             yield* FiberSet.clear(toolFibers)
             yield* withPublication(publisher.failUnsettledTools("Tool execution interrupted"))
             if (publisher.hasActiveAssistant())
-              yield* withPublication(publisher.failAssistant({ type: "unknown", message: "Provider turn interrupted" }))
+              yield* withPublication(publisher.failAssistant("Provider turn interrupted"))
           }
           if (settled._tag === "Failure" && !Cause.hasInterrupts(settled.cause)) {
             const failure = Cause.squash(settled.cause)

packages/core/src/session/runner/publish-llm-event.ts

@@ -50,33 +50,6 @@ const settledOutput = (value: ToolOutput | undefined, result: ToolResultValue):
   return { structured: record(settled.structured), content: settled.content }
 }
 
-const providerMessages: Record<SessionMessage.ProviderErrorCategory, string> = {
-  "invalid-request": "Provider rejected the request",
-  "no-route": "Provider unavailable: no provider route",
-  authentication: "Provider authentication failed",
-  "rate-limit": "Provider rate limit exceeded",
-  "quota-exceeded": "Provider quota exceeded",
-  "content-policy": "Provider rejected the invalid request due to content policy",
-  "provider-internal": "Provider service unavailable",
-  transport: "Provider connection failed",
-  "invalid-provider-output": "Provider returned an invalid response",
-  unknown: "Provider request failed",
-}
-
-export const providerError = (input: {
-  readonly category: SessionMessage.ProviderErrorCategory
-  readonly status?: number
-  readonly retryable?: boolean
-  readonly retryAfterMs?: number
-}): SessionMessage.ProviderError => ({
-  type: "provider",
-  category: input.category,
-  message: providerMessages[input.category],
-  status: input.status,
-  retryable: input.retryable ?? (input.category === "rate-limit" || input.category === "provider-internal"),
-  retryAfterMs: input.retryAfterMs,
-})
-
 /** Persist one provider turn without executing tools or starting a continuation turn. */
 export const createLLMEventPublisher = (events: EventV2.Interface, input: Input) => {
   const tools = new Map<
@@ -94,6 +67,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
   const timestamp = DateTime.now
   let assistantMessageID: SessionMessage.ID | undefined
   let assistantActive = false
+  let assistantFailed = false
   let providerFailed = false
   let stepSettlement: { readonly finish: string; readonly tokens: ReturnType<typeof tokens> } | undefined
 
@@ -222,17 +196,17 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     yield* flushFragments()
   })
 
-  const failAssistant = Effect.fnUntraced(function* (error: SessionMessage.Error) {
-    if (providerFailed) return
-    providerFailed = true
+  const failAssistant = Effect.fnUntraced(function* (message: string) {
+    if (assistantFailed) return
     yield* flush()
     const assistantMessageID = yield* startAssistant()
     assistantActive = false
+    assistantFailed = true
     yield* events.publish(SessionEvent.Step.Failed, {
       sessionID: input.sessionID,
       timestamp: yield* timestamp,
       assistantMessageID,
-      error,
+      error: { type: "unknown", message },
     })
   })
 
@@ -428,13 +402,8 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
       case "finish":
         return
       case "provider-error":
-        yield* failAssistant(
-          providerError({
-            category: event.category ?? (event.classification === "context-overflow" ? "invalid-request" : "unknown"),
-            status: event.status,
-            retryable: event.retryable,
-          }),
-        )
+        providerFailed = true
+        yield* failAssistant(event.message)
         return
     }
   })

packages/core/src/session/runner/to-llm-message.ts

@@ -70,28 +70,17 @@ const toolResult = (tool: SessionMessage.AssistantTool, providerMetadata: Provid
 const assistant = (message: SessionMessage.Assistant, model: Model) => {
   const sameModel =
     String(message.model.providerID) === String(model.provider) && String(message.model.id) === String(model.id)
-  const reuseProviderMetadata = sameModel && message.error === undefined
   const content = message.content.flatMap((item): ContentPart[] => {
     if (item.type === "text") return [{ type: "text", text: item.text }]
     if (item.type === "reasoning")
       return sameModel
-        ? [
-            {
-              type: "reasoning",
-              text: item.text,
-              providerMetadata: reuseProviderMetadata ? item.providerMetadata : undefined,
-            },
-          ]
+        ? [{ type: "reasoning", text: item.text, providerMetadata: item.providerMetadata }]
         : item.text.length > 0
           ? [{ type: "text", text: item.text }]
           : []
-    const call = toolCall(item, reuseProviderMetadata ? item.provider?.metadata : undefined)
-    if (item.provider?.executed !== true) return [call]
-    const result = toolResult(
-      item,
-      reuseProviderMetadata ? (item.provider.resultMetadata ?? item.provider.metadata) : undefined,
-    )
-    return result ? [call, result] : [call]
+    const call = toolCall(item, sameModel ? item.provider?.metadata : undefined)
+    const result = toolResult(item, sameModel ? (item.provider?.resultMetadata ?? item.provider?.metadata) : undefined)
+    return item.provider?.executed === true && result ? [call, result] : [call]
   })
   const meaningful = content.filter((part) => {
     if (part.type === "text") return part.text !== ""
@@ -100,9 +89,7 @@ const assistant = (message: SessionMessage.Assistant, model: Model) => {
   })
   const results = message.content
     .filter((item): item is SessionMessage.AssistantTool => item.type === "tool" && item.provider?.executed !== true)
-    .map((item) =>
-      toolResult(item, reuseProviderMetadata ? (item.provider?.resultMetadata ?? item.provider?.metadata) : undefined),
-    )
+    .map((item) => toolResult(item, sameModel ? (item.provider?.resultMetadata ?? item.provider?.metadata) : undefined))
     .filter((message) => message !== undefined)
     .map(Message.tool)
   if (meaningful.length === 0) return results

packages/core/src/util/effect-flock.ts

@@ -281,5 +281,5 @@ export namespace EffectFlock {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer), Layer.provide(Global.layer))
-  export const node = LayerNode.make({ service: Service, layer: layer, deps: [Global.node, FSUtil.node] })
+  export const node = LayerNode.make(layer, [Global.node, FSUtil.node])
 }

packages/core/src/v1/config/migrate.ts

@@ -132,7 +132,7 @@ function mcp(info: typeof ConfigV1.Info.Type) {
   )
   const timeout = info.experimental?.mcp_timeout
   if (!timeout && !Object.keys(servers).length) return undefined
-  return { timeout: timeout === undefined ? undefined : { request: timeout }, servers }
+  return { timeout, servers }
 }
 
 function migrateMcp(info: ConfigMCPV1.Info) {
@@ -144,7 +144,7 @@ function migrateMcp(info: ConfigMCPV1.Info) {
       cwd: info.cwd,
       environment: info.environment,
       disabled,
-      timeout: info.timeout === undefined ? undefined : { request: info.timeout },
+      timeout: info.timeout,
     }
   return {
     type: info.type,
@@ -158,7 +158,7 @@ function migrateMcp(info: ConfigMCPV1.Info) {
       redirect_uri: info.oauth.redirectUri,
     },
     disabled,
-    timeout: info.timeout === undefined ? undefined : { request: info.timeout },
+    timeout: info.timeout,
   }
 }
 

packages/core/test/config/config.test.ts

@@ -298,14 +298,14 @@ describe("Config", () => {
                 },
                 tool_output: { max_lines: 1000, max_bytes: 32768 },
                 mcp: {
-                  timeout: { startup: 5000, request: 60000 },
+                  timeout: 5000,
                   servers: {
                     local: {
                       type: "local",
                       command: ["node", "./mcp/server.js"],
                       environment: { API_KEY: "secret" },
                       disabled: false,
-                      timeout: { request: 10000 },
+                      timeout: 10000,
                     },
                     remote: {
                       type: "remote",
@@ -313,7 +313,6 @@ describe("Config", () => {
                       headers: { Authorization: "Bearer token" },
                       oauth: { client_id: "client", scope: "read write", callback_port: 19876 },
                       disabled: true,
-                      timeout: { startup: 15000 },
                     },
                   },
                 },
@@ -384,14 +383,14 @@ describe("Config", () => {
             })
             expect(documents[0]?.info.tool_output).toEqual({ max_lines: 1000, max_bytes: 32768 })
             expect(documents[0]?.info.mcp).toEqual({
-              timeout: { startup: 5000, request: 60000 },
+              timeout: 5000,
               servers: {
                 local: {
                   type: "local",
                   command: ["node", "./mcp/server.js"],
                   environment: { API_KEY: "secret" },
                   disabled: false,
-                  timeout: { request: 10000 },
+                  timeout: 10000,
                 },
                 remote: {
                   type: "remote",
@@ -399,7 +398,6 @@ describe("Config", () => {
                   headers: { Authorization: "Bearer token" },
                   oauth: { client_id: "client", scope: "read write", callback_port: 19876 },
                   disabled: true,
-                  timeout: { startup: 15000 },
                 },
               },
             })
@@ -543,12 +541,11 @@ describe("Config", () => {
                 compaction: { auto: true, tail_turns: 3, preserve_recent_tokens: 2000, reserved: 10000 },
                 experimental: { mcp_timeout: 5000 },
                 mcp: {
-                  local: { type: "local", command: ["node", "server.js"], enabled: false, timeout: 10000 },
+                  local: { type: "local", command: ["node", "server.js"], enabled: false },
                   remote: {
                     type: "remote",
                     url: "https://mcp.example.com",
                     oauth: { clientId: "client", callbackPort: 19876 },
-                    timeout: 20000,
                   },
                 },
               }),
@@ -626,19 +623,13 @@ describe("Config", () => {
               buffer: 10000,
             })
             expect(documents[0]?.info.mcp).toMatchObject({
-              timeout: { request: 5000 },
+              timeout: 5000,
               servers: {
-                local: {
-                  type: "local",
-                  command: ["node", "server.js"],
-                  disabled: true,
-                  timeout: { request: 10000 },
-                },
+                local: { type: "local", command: ["node", "server.js"], disabled: true },
                 remote: {
                   type: "remote",
                   url: "https://mcp.example.com",
                   oauth: { client_id: "client", callback_port: 19876 },
-                  timeout: { request: 20000 },
                 },
               },
             })

packages/core/test/move-session.test.ts

@@ -42,7 +42,7 @@ const layer = MoveSession.layer.pipe(
   Layer.provide(Git.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(project),
-  Layer.provide(SessionStore.defaultLayer),
+  Layer.provide(sessions),
 )
 const it = testEffect(
   Layer.mergeAll(
@@ -53,6 +53,7 @@ const it = testEffect(
     project,
     SessionProjector.defaultLayer,
     SessionStore.defaultLayer,
+    SessionExecution.noopLayer,
     sessions,
   ),
 )

packages/core/test/session-prompt.test.ts

@@ -22,11 +22,9 @@ import { testEffect } from "./lib/effect"
 const executionCalls: SessionV2.ID[] = []
 const interruptCalls: SessionV2.ID[] = []
 const wakeCalls: SessionV2.ID[] = []
-const activeSessions = new Set<SessionV2.ID>()
 const execution = Layer.succeed(
   SessionExecution.Service,
   SessionExecution.Service.of({
-    active: Effect.sync(() => new Set(activeSessions)),
     resume: (sessionID) =>
       Effect.sync(() => {
         executionCalls.push(sessionID)
@@ -110,13 +108,6 @@ const eventCount = (type: string) =>
   )
 
 describe("SessionV2.prompt", () => {
-  it.effect("exposes the execution registry", () =>
-    Effect.gen(function* () {
-      activeSessions.add(sessionID)
-      expect(Array.from(yield* (yield* SessionV2.Service).active)).toEqual([sessionID])
-    }).pipe(Effect.ensuring(Effect.sync(() => activeSessions.clear()))),
-  )
-
   it.effect("delegates execution continuation through SessionExecution", () =>
     Effect.gen(function* () {
       yield* setup

packages/core/test/session-run-coordinator.test.ts

@@ -66,78 +66,6 @@ describe("SessionRunCoordinator", () => {
     ),
   )
 
-  it.effect("snapshots only active executions", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const firstStarted = yield* Deferred.make<void>()
-        const secondStarted = yield* Deferred.make<void>()
-        const firstGate = yield* Deferred.make<void>()
-        const secondGate = yield* Deferred.make<void>()
-        const coordinator = yield* SessionRunCoordinator.make({
-          drain: (key: string) =>
-            Deferred.succeed(key === "first" ? firstStarted : secondStarted, undefined).pipe(
-              Effect.andThen(Deferred.await(key === "first" ? firstGate : secondGate)),
-            ),
-        })
-
-        expect(Array.from(yield* coordinator.active)).toEqual([])
-        const first = yield* coordinator.run("first").pipe(Effect.forkChild)
-        yield* Deferred.await(firstStarted)
-        expect(Array.from(yield* coordinator.active)).toEqual(["first"])
-
-        const second = yield* coordinator.run("second").pipe(Effect.forkChild)
-        yield* Deferred.await(secondStarted)
-        expect(Array.from(yield* coordinator.active)).toEqual(["first", "second"])
-
-        yield* Deferred.succeed(firstGate, undefined)
-        yield* Fiber.join(first)
-        expect(Array.from(yield* coordinator.active)).toEqual(["second"])
-        yield* Deferred.succeed(secondGate, undefined)
-        yield* Fiber.join(second)
-        expect(Array.from(yield* coordinator.active)).toEqual([])
-      }),
-    ),
-  )
-
-  it.effect("cleans active executions after failure and defect", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const failure = new Error("failed")
-        const defect = new Error("defect")
-        const coordinator = yield* SessionRunCoordinator.make({
-          drain: (key: string) => (key === "failure" ? Effect.fail(failure) : Effect.die(defect)),
-        })
-
-        const failed = yield* coordinator.run("failure").pipe(Effect.exit)
-        expect(Exit.isFailure(failed) && Cause.hasFails(failed.cause)).toBeTrue()
-        expect(Array.from(yield* coordinator.active)).toEqual([])
-
-        const died = yield* coordinator.run("defect").pipe(Effect.exit)
-        expect(Exit.isFailure(died) && Cause.hasDies(died.cause)).toBeTrue()
-        expect(Array.from(yield* coordinator.active)).toEqual([])
-      }),
-    ),
-  )
-
-  it.effect("cleans active executions when its scope closes", () =>
-    Effect.gen(function* () {
-      const started = yield* Deferred.make<void>()
-      const coordinator = yield* Effect.scoped(
-        Effect.gen(function* () {
-          const coordinator = yield* SessionRunCoordinator.make({
-            drain: () => Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)),
-          })
-          yield* coordinator.wake("session")
-          yield* Deferred.await(started)
-          expect(Array.from(yield* coordinator.active)).toEqual(["session"])
-          return coordinator
-        }),
-      )
-
-      expect(Array.from(yield* coordinator.active)).toEqual([])
-    }),
-  )
-
   it.effect("coalesces wakes received during active execution", () =>
     Effect.scoped(
       Effect.gen(function* () {
@@ -238,7 +166,6 @@ describe("SessionRunCoordinator", () => {
 
         const exit = yield* Fiber.await(resumed)
         expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBeTrue()
-        expect(Array.from(yield* coordinator.active)).toEqual([])
         expect(runs).toBe(1)
       }),
     ),

packages/core/test/session-runner-message.test.ts

@@ -327,78 +327,6 @@ Recent work
     ])
   })
 
-  test("drops provider-native continuation metadata from failed assistant turns", () => {
-    const messages = toLLMMessages(
-      [
-        SessionMessage.Assistant.make({
-          id: id("assistant-failed"),
-          type: "assistant",
-          agent: "build",
-          model: { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") },
-          content: [
-            SessionMessage.AssistantReasoning.make({
-              type: "reasoning",
-              id: "reasoning-failed",
-              text: "Partial thought",
-              providerMetadata: { openai: { itemId: "rs_failed", reasoningEncryptedContent: null } },
-            }),
-            SessionMessage.AssistantTool.make({
-              type: "tool",
-              id: "hosted-failed",
-              name: "web_search",
-              provider: {
-                executed: true,
-                metadata: { openai: { itemId: "call_failed" } },
-                resultMetadata: { openai: { itemId: "result_failed" } },
-              },
-              state: SessionMessage.ToolStateError.make({
-                status: "error",
-                input: { query: "Effect" },
-                error: { type: "unknown", message: "Provider turn interrupted" },
-                content: [],
-                structured: {},
-              }),
-              time: { created, completed: created },
-            }),
-          ],
-          finish: "error",
-          error: { type: "unknown", message: "Provider turn interrupted" },
-          time: { created, completed: created },
-        }),
-      ],
-      model,
-    )
-
-    expect(messages[0]?.content).toEqual([
-      { type: "reasoning", text: "Partial thought", providerMetadata: undefined },
-      {
-        type: "tool-call",
-        id: "hosted-failed",
-        name: "web_search",
-        input: { query: "Effect" },
-        providerExecuted: true,
-        providerMetadata: undefined,
-      },
-      {
-        type: "tool-result",
-        id: "hosted-failed",
-        name: "web_search",
-        result: {
-          type: "error",
-          value: {
-            error: { type: "unknown", message: "Provider turn interrupted" },
-            content: [],
-            structured: {},
-          },
-        },
-        providerExecuted: true,
-        cache: undefined,
-        metadata: undefined,
-        providerMetadata: undefined,
-      },
-    ])
-  })
-
   test("drops provider-native continuation metadata after a model switch", () => {
     const messages = toLLMMessages(
       [

packages/core/test/session-runner-recorded.test.ts

@@ -95,7 +95,6 @@ const execution = Layer.effect(
       drain: (sessionID, force) => sessionRunner.run({ sessionID, force }),
     })
     return SessionExecution.Service.of({
-      active: coordinator.active,
       resume: coordinator.run,
       wake: coordinator.wake,
       interrupt: coordinator.interrupt,

packages/core/test/session-runner.test.ts

@@ -4,11 +4,6 @@ import {
   LLMError,
   LLMEvent,
   Model,
-  HttpContext,
-  HttpRateLimitDetails,
-  HttpRequestDetails,
-  HttpResponseDetails,
-  RateLimitReason,
   TransportReason,
   InvalidRequestReason,
   type LLMClientShape,
@@ -259,7 +254,6 @@ const execution = Layer.effect(
       drain: (sessionID, force) => sessionRunner.run({ sessionID, force }),
     })
     return SessionExecution.Service.of({
-      active: coordinator.active,
       resume: coordinator.run,
       wake: coordinator.wake,
       interrupt: coordinator.interrupt,
@@ -520,21 +514,13 @@ const verifyPartialFlushOnFailure = (kind: FragmentKind) =>
     responseStream = Stream.concat(Stream.fromIterable(fixture.partialEvents), Stream.fail(failure))
 
     expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
-    const expectedContent =
-      kind === "tool input"
-        ? {
-            type: "tool",
-            id: fragmentID(kind, "partial"),
-            state: { status: "error", error: { message: "Tool execution interrupted" } },
-          }
-        : fixture.expectedContent
     expect(yield* session.context(sessionID)).toMatchObject([
       { type: "user", text: prompt },
       {
         type: "assistant",
         finish: "error",
-        error: { type: "provider", category: "transport", message: "Provider connection failed", retryable: false },
-        content: [expectedContent],
+        error: { type: "unknown", message: "Provider unavailable" },
+        content: [fixture.expectedContent],
       },
     ])
   })
@@ -1209,16 +1195,7 @@ describe("SessionRunnerLLM", () => {
       expect(requests).toHaveLength(3)
       expect(yield* session.context(sessionID)).toMatchObject([
         { type: "compaction" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "invalid-request",
-            message: "Provider rejected the request",
-            retryable: false,
-          },
-        },
+        { type: "assistant", finish: "error", error: { message: "prompt too long" } },
       ])
     }),
   )
@@ -1266,16 +1243,7 @@ describe("SessionRunnerLLM", () => {
       expect(context.some((message) => message.type === "compaction")).toBe(false)
       expect(context.slice(-2)).toMatchObject([
         { type: "user", text: "Continue" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "invalid-request",
-            message: "Provider rejected the request",
-            retryable: false,
-          },
-        },
+        { type: "assistant", finish: "error", error: { message: "prompt too long" } },
       ])
     }),
   )
@@ -2951,16 +2919,7 @@ describe("SessionRunnerLLM", () => {
       expect(requests).toHaveLength(1)
       expect(yield* session.context(sessionID)).toMatchObject([
         { type: "user", text: "Fail durably" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "unknown",
-            message: "Provider request failed",
-            retryable: false,
-          },
-        },
+        { type: "assistant", finish: "error", error: { type: "unknown", message: "Provider unavailable" } },
       ])
     }),
   )
@@ -2979,16 +2938,7 @@ describe("SessionRunnerLLM", () => {
       expect(requests).toHaveLength(1)
       expect(yield* session.context(sessionID)).toMatchObject([
         { type: "user", text: "Fail before step" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "unknown",
-            message: "Provider request failed",
-            retryable: false,
-          },
-        },
+        { type: "assistant", finish: "error", error: { type: "unknown", message: "Provider unavailable" } },
       ])
     }),
   )
@@ -3015,12 +2965,7 @@ describe("SessionRunnerLLM", () => {
         {
           type: "assistant",
           finish: "error",
-          error: {
-            type: "provider",
-            category: "invalid-request",
-            message: "Provider rejected the request",
-            retryable: false,
-          },
+          error: { message: "prompt too long" },
           content: [{ type: "text", text: "Partial" }],
         },
       ])
@@ -3039,138 +2984,11 @@ describe("SessionRunnerLLM", () => {
       yield* replaySessionProjection(sessionID)
       expect(yield* session.context(sessionID)).toMatchObject([
         { type: "user", text: "Fail raw stream durably" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: { type: "provider", category: "transport", message: "Provider connection failed", retryable: false },
-        },
+        { type: "assistant", finish: "error", error: { type: "unknown", message: "Provider unavailable" } },
       ])
     }),
   )
 
-  it.effect("does not publish step ended when the provider throws after step finish", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* SessionV2.Service
-      const db = yield* Database.Service
-      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail after finish" }), resume: false })
-      const failure = providerUnavailable()
-      responseStream = Stream.concat(
-        Stream.fromIterable([LLMEvent.stepFinish({ index: 0, reason: "stop" })]),
-        Stream.fail(failure),
-      )
-
-      expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
-
-      const types = yield* db.db.select({ type: EventTable.type }).from(EventTable).all().pipe(Effect.orDie)
-      expect(types).toContainEqual({
-        type: EventV2.versionedType(SessionEvent.Step.Failed.type, 2),
-      })
-      expect(types).not.toContainEqual({
-        type: EventV2.versionedType(SessionEvent.Step.Ended.type, 2),
-      })
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user", text: "Fail after finish" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: { type: "provider", category: "transport", message: "Provider connection failed" },
-        },
-      ])
-    }),
-  )
-
-  it.effect("preserves sanitized HTTP rate-limit details in the durable event and projection", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* SessionV2.Service
-      const db = yield* Database.Service
-      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail with rate limit" }), resume: false })
-      const failure = new LLMError({
-        module: "RequestExecutor",
-        method: "execute",
-        reason: new RateLimitReason({
-          message: "secret provider response message",
-          retryAfterMs: 12_000,
-          rateLimit: new HttpRateLimitDetails({ retryAfterMs: 12_000, limit: { requests: "secret-limit" } }),
-          http: new HttpContext({
-            request: new HttpRequestDetails({
-              method: "POST",
-              url: "https://secret.example/v1/responses?api_key=credential",
-              headers: { authorization: "Bearer credential" },
-            }),
-            response: new HttpResponseDetails({ status: 429, headers: { "x-secret": "secret-header" } }),
-            body: '{"secret":"provider body"}',
-            requestId: "secret-request-id",
-          }),
-        }),
-      })
-      responseStream = Stream.fail(failure)
-
-      expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
-
-      const event = yield* db.db
-        .select({ data: EventTable.data })
-        .from(EventTable)
-        .where(eq(EventTable.type, EventV2.versionedType(SessionEvent.Step.Failed.type, 2)))
-        .get()
-        .pipe(Effect.orDie)
-      const expected = {
-        type: "provider",
-        category: "rate-limit",
-        message: "Provider rate limit exceeded",
-        status: 429,
-        retryable: true,
-        retryAfterMs: 12_000,
-      }
-      expect(event?.data.error).toEqual(expected)
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user", text: "Fail with rate limit" },
-        { type: "assistant", finish: "error", error: expected },
-      ])
-      expect(JSON.stringify(event)).not.toMatch(
-        /secret provider|secret\.example|credential|secret-header|provider body|secret-request-id|secret-limit/,
-      )
-      expect(JSON.stringify(yield* session.context(sessionID))).not.toMatch(
-        /secret provider|secret\.example|credential|secret-header|provider body|secret-request-id|secret-limit/,
-      )
-    }),
-  )
-
-  it.effect("projects categorized in-band failures without fabricating an HTTP status", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* SessionV2.Service
-      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail in band" }), resume: false })
-      response = [
-        LLMEvent.providerError({
-          message: "rate_limit_exceeded: secret provider message",
-          category: "rate-limit",
-          retryable: false,
-        }),
-      ]
-
-      yield* session.resume(sessionID)
-
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user", text: "Fail in band" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "rate-limit",
-            message: "Provider rate limit exceeded",
-            retryable: false,
-          },
-        },
-      ])
-      const assistant = (yield* session.context(sessionID))[1]
-      expect(assistant?.type === "assistant" ? assistant.error : undefined).not.toHaveProperty("status")
-      expect(JSON.stringify(assistant)).not.toContain("secret provider message")
-    }),
-  )
-
   it.effect("does not continue automatically after a provider error follows a local tool call", () =>
     Effect.gen(function* () {
       yield* setup
@@ -3186,25 +3004,13 @@ describe("SessionRunnerLLM", () => {
       response = [
         LLMEvent.stepStart({ index: 0 }),
         LLMEvent.toolCall({ id: "call-before-provider-error", name: "echo", input: { text: "settled" } }),
-        LLMEvent.providerError({ message: "secret provider failure" }),
+        LLMEvent.providerError({ message: "Provider unavailable" }),
       ]
 
       yield* session.resume(sessionID)
 
       expect(requests).toHaveLength(1)
       expect(executions.slice(executionCount)).toEqual(["settled"])
-      const assistant = (yield* session.context(sessionID))[1]
-      expect(assistant).toMatchObject({
-        type: "assistant",
-        finish: "error",
-        error: {
-          type: "provider",
-          category: "unknown",
-          message: "Provider request failed",
-          retryable: false,
-        },
-      })
-      expect(JSON.stringify(assistant)).not.toContain("secret provider failure")
     }),
   )
 
@@ -3294,12 +3100,7 @@ describe("SessionRunnerLLM", () => {
         {
           type: "assistant",
           finish: "error",
-          error: {
-            type: "provider",
-            category: "transport",
-            message: "Provider connection failed",
-            retryable: false,
-          },
+          error: { type: "unknown", message: "Provider unavailable" },
           content: [{ type: "tool", id: "call-hosted-raw-failure", state: { status: "error" } }],
         },
       ])

packages/core/test/shared-schema.test.ts

@@ -144,8 +144,6 @@ test("Core reuses the canonical shared schemas", async () => {
     [coreSessionInput.Admitted, SessionInput.Admitted],
     [coreSessionMessage.ID, SessionMessage.ID],
     [coreSessionMessage.UnknownError, SessionMessage.UnknownError],
-    [coreSessionMessage.ProviderError, SessionMessage.ProviderError],
-    [coreSessionMessage.Error, SessionMessage.Error],
     [coreSessionMessage.AgentSwitched, SessionMessage.AgentSwitched],
     [coreSessionMessage.ModelSwitched, SessionMessage.ModelSwitched],
     [coreSessionMessage.User, SessionMessage.User],
@@ -206,17 +204,3 @@ test("shared record schemas construct and decode plain objects", () => {
   expect(Prompt.fromUserMessage({ text: "hello" })).toEqual(made)
   expect(Workspace.ID.ascending("")).toStartWith("wrk_")
 })
-
-test("assistant errors retain legacy unknown decode compatibility", () => {
-  const assistant = Schema.decodeUnknownSync(SessionMessage.Assistant)({
-    id: "msg_legacy_error",
-    type: "assistant",
-    agent: "build",
-    model: { id: "model", providerID: "provider" },
-    content: [],
-    error: { type: "unknown", message: "Legacy failure" },
-    time: { created: 0 },
-  })
-
-  expect(assistant.error).toEqual({ type: "unknown", message: "Legacy failure" })
-})

packages/httpapi-codegen/README.md

@@ -37,6 +37,6 @@ The existing public `generate(Api, { directory })` operation writes the rich Eff
 
 Generation formats TypeScript with Prettier before writing. Output paths are flat, unique, and checked against traversal, reserved manifest names, and existing symbolic links.
 
-Portable Effect output uses one self-contained module per `HttpApiGroup`, plus root client and index modules. Promise output uses shared type and client modules, while imported Effect output keeps adapters in the root client module. Schema dependencies may be duplicated across portable Effect group modules. Cross-group schema partitioning is deferred until measured output or bundle cost requires it.
+Generated source starts with one self-contained module per `HttpApiGroup`, plus root client and index modules. Schema dependencies may be duplicated across group modules. Cross-group schema partitioning is deferred until measured output or bundle cost requires it.
 
-Codegen preserves transport identifiers internally. `compile` may explicitly map consumer-facing group names, and endpoint operation IDs are projected to their final dot-delimited segment. The generator performs no other implicit product-specific naming or public-name annotation mapping.
+Codegen preserves group and endpoint identifiers exactly. The composed remote `HttpApi` owns public names such as `session` and `get`; the generator performs no prefix stripping, casing conversion, or public-name annotation mapping.

packages/httpapi-codegen/src/index.ts

@@ -69,7 +69,6 @@ type Slot = {
 
 const resolveHttpApiStatus = SchemaAST.resolveAt<number>("httpApiStatus")
 const resolveHttpApiEncoding = SchemaAST.resolveAt<HttpApiSchema.Encoding>("~httpApiEncoding")
-const resolveContentSchema = SchemaAST.resolveAt<SchemaAST.AST>("contentSchema")
 const Manifest = Schema.fromJsonString(Schema.Array(Schema.String))
 const manifestName = ".httpapi-codegen.json"
 
@@ -126,10 +125,9 @@ export function compile<Id extends string, Groups extends HttpApiGroup.Any>(
         ...responseSchemas(success.schema, `${name}.success`),
         ...errorSchemas.map((item) => [`${name}.error`, item.schema] as const),
       ]
-      const effectPortable =
-        [params, query, headers, ...payloads, success, ...errorSchemas].every(
-          (item) => item?.effectPortable !== false,
-        ) && streamEffectPortable(success.schema)
+      const effectPortable = [params, query, headers, ...payloads, success, ...errorSchemas].every(
+        (item) => item?.effectPortable !== false,
+      )
       if (effectPortable) {
         for (const [path, schema] of schemaPaths) assertPortable(schema, path, portable)
       }
@@ -456,7 +454,7 @@ function renderPromiseTypes(groups: ReadonlyArray<Group>) {
         const success = typeOf(
           isStreamSchema(successSchema) && successSchema._tag === "StreamSse"
             ? successSchema.sseMode === "data"
-              ? streamEncodedDataSchema(successSchema)
+              ? streamDataSchema(successSchema)
               : successSchema.events
             : successSchema,
         )
@@ -784,6 +782,17 @@ function responseSchemas(schema: Schema.Top, path: string): Array<readonly [stri
   if (!isStreamSchema(schema)) return [[path, schema]]
   if (schema._tag === "StreamUint8Array") return []
   const value = schema.sseMode === "data" ? streamDataSchema(schema) : schema.events
+  const rebuilt =
+    schema.sseMode === "data"
+      ? HttpApiSchema.StreamSse({ data: value, error: schema.error, contentType: schema.contentType })
+      : HttpApiSchema.StreamSse({
+          events: schema.events,
+          error: schema.error,
+          contentType: schema.contentType,
+        })
+  if (!sameEncoding(schema.events.ast, rebuilt.events.ast)) {
+    throw new GenerationError({ reason: `Unportable schema: ${path}.${schema.sseMode}` })
+  }
   return [
     [`${path}.${schema.sseMode}`, value],
     [`${path}.error`, schema.error],
@@ -955,33 +964,11 @@ function isStreamSchema(schema: Schema.Top): schema is HttpApiSchema.StreamSchem
 }
 
 function streamDataSchema(schema: Extract<HttpApiSchema.StreamSchema, { readonly _tag: "StreamSse" }>) {
-  return Schema.make(streamDataAst(Schema.toType(schema.events).ast))
-}
-
-function streamEncodedDataSchema(schema: Extract<HttpApiSchema.StreamSchema, { readonly _tag: "StreamSse" }>) {
-  const data = streamDataAst(schema.events.ast)
-  const encodedAst = data.encoding?.at(-1)?.to
-  if (encodedAst === undefined) throw new GenerationError({ reason: "Invalid SSE data schema" })
-  const encoded = resolveContentSchema(encodedAst)
-  if (!SchemaAST.isAST(encoded)) throw new GenerationError({ reason: "Invalid SSE data schema" })
-  return Schema.make(encoded)
-}
-
-function streamDataAst(ast: SchemaAST.AST) {
+  const ast = Schema.toType(schema.events).ast
   if (!SchemaAST.isObjects(ast)) throw new GenerationError({ reason: "Invalid SSE data schema" })
   const data = ast.propertySignatures.find((field) => field.name === "data")?.type
   if (data === undefined) throw new GenerationError({ reason: "Invalid SSE data schema" })
-  return data
-}
-
-function streamEffectPortable(schema: Schema.Top) {
-  if (!isStreamSchema(schema) || schema._tag === "StreamUint8Array" || schema.sseMode === "events") return true
-  const rebuilt = HttpApiSchema.StreamSse({
-    data: streamDataSchema(schema),
-    error: schema.error,
-    contentType: schema.contentType,
-  })
-  return sameEncoding(schema.events.ast, rebuilt.events.ast)
+  return Schema.make(data)
 }
 
 function renderGroup(group: Group, groupIndex: number) {

packages/httpapi-codegen/test/generate.test.ts

@@ -395,9 +395,7 @@ describe("HttpApiCodegen.generate", () => {
         api(
           HttpApiEndpoint.get("subscribe", "/event", {
             query: { after: Schema.optional(Schema.Number) },
-            success: HttpApiSchema.StreamSse({
-              data: Schema.Struct({ type: Schema.String, count: Schema.NumberFromString }),
-            }),
+            success: HttpApiSchema.StreamSse({ data: Schema.Struct({ type: Schema.String }) }),
           }),
         ),
       ),
@@ -418,7 +416,7 @@ describe("HttpApiCodegen.generate", () => {
           return new Response(
             new ReadableStream({
               start(controller) {
-                controller.enqueue(encoder.encode('data: {"type":"ready","count":"1"}\r'))
+                controller.enqueue(encoder.encode('data: {"type":"ready"}\r'))
                 controller.enqueue(encoder.encode("\n\r\n"))
                 controller.close()
               },
@@ -432,7 +430,7 @@ describe("HttpApiCodegen.generate", () => {
       expect(requests).toBe(0)
       const received = []
       for await (const event of events) received.push(event)
-      expect(received).toEqual([{ type: "ready", count: "1" }])
+      expect(received).toEqual([{ type: "ready" }])
       expect(requests).toBe(1)
       expect(url).toBe("https://example.com/event?after=2")
     } finally {

packages/llm/src/protocols/openai-responses.ts

@@ -258,8 +258,6 @@ const lowerTool = (tool: ToolDefinition): OpenAIResponsesTool => ({
   name: tool.name,
   description: tool.description,
   parameters: ProviderShared.openAiToolInputSchema(tool.inputSchema),
-  // TODO: Read this from OpenAI-specific tool options so direct LLM callers can opt into strict schemas.
-  strict: false,
 })
 
 const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>

packages/llm/src/schema/errors.ts

@@ -4,20 +4,6 @@ import { ModelID, ProviderID, ProviderMetadata, RouteID } from "./ids"
 export const ProviderFailureClassification = Schema.Literal("context-overflow")
 export type ProviderFailureClassification = typeof ProviderFailureClassification.Type
 
-export const ProviderFailureCategory = Schema.Literals([
-  "invalid-request",
-  "no-route",
-  "authentication",
-  "rate-limit",
-  "quota-exceeded",
-  "content-policy",
-  "provider-internal",
-  "transport",
-  "invalid-provider-output",
-  "unknown",
-])
-export type ProviderFailureCategory = typeof ProviderFailureCategory.Type
-
 export class HttpRequestDetails extends Schema.Class<HttpRequestDetails>("LLM.HttpRequestDetails")({
   method: Schema.String,
   url: Schema.String,

packages/llm/src/schema/events.ts

@@ -2,7 +2,7 @@ import { Schema } from "effect"
 import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, RouteID, ToolCallID } from "./ids"
 import { ModelSchema } from "./options"
 import { ToolOutput, ToolResultValue } from "./messages"
-import { ProviderFailureCategory, ProviderFailureClassification } from "./errors"
+import { ProviderFailureClassification } from "./errors"
 
 /**
  * Token usage reported by an LLM provider.
@@ -201,8 +201,6 @@ export const ProviderErrorEvent = Schema.Struct({
   type: Schema.tag("provider-error"),
   message: Schema.String,
   classification: Schema.optional(ProviderFailureClassification),
-  category: Schema.optional(ProviderFailureCategory),
-  status: Schema.optional(Schema.Number),
   retryable: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ProviderError" })

packages/llm/test/fixtures/recordings/openai-responses/gpt-5-5-drives-a-tool-loop.json

@@ -22,7 +22,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool, then answer in one short sentence.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"stream\":true,\"max_output_tokens\":80}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool, then answer in one short sentence.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"stream\":true,\"max_output_tokens\":80}"
       },
       "response": {
         "status": 200,
@@ -40,7 +40,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool, then answer in one short sentence.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]},{\"type\":\"function_call\",\"call_id\":\"call_JCuVTkQxVB3cCmFWx52adJKZ\",\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_JCuVTkQxVB3cCmFWx52adJKZ\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"stream\":true,\"max_output_tokens\":80}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool, then answer in one short sentence.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]},{\"type\":\"function_call\",\"call_id\":\"call_JCuVTkQxVB3cCmFWx52adJKZ\",\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_JCuVTkQxVB3cCmFWx52adJKZ\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"stream\":true,\"max_output_tokens\":80}"
       },
       "response": {
         "status": 200,

packages/llm/test/fixtures/recordings/openai-responses/gpt-5-5-streams-tool-call.json

@@ -14,7 +14,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Call tools exactly as requested.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Call get_weather with city exactly Paris.\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"tool_choice\":{\"type\":\"function\",\"name\":\"get_weather\"},\"stream\":true,\"max_output_tokens\":80}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Call tools exactly as requested.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Call get_weather with city exactly Paris.\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"tool_choice\":{\"type\":\"function\",\"name\":\"get_weather\"},\"stream\":true,\"max_output_tokens\":80}"
       },
       "response": {
         "status": 200,

packages/llm/test/provider/openai-responses.test.ts

@@ -115,7 +115,6 @@ describe("OpenAI Responses route", () => {
           type: "function",
           name: "read",
           description: "Read a path or resource.",
-          strict: false,
           parameters: {
             type: "object",
             properties: {

packages/opencode/src/account/account.ts

@@ -458,6 +458,6 @@ export const layer: Layer.Layer<Service, never, AccountRepo.Service | HttpClient
 
 export const defaultLayer = layer.pipe(Layer.provide(AccountRepo.defaultLayer), Layer.provide(FetchHttpClient.layer))
 
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [AccountRepo.node, httpClient] })
+export const node = LayerNode.make(layer, [AccountRepo.node, httpClient])
 
 export * as Account from "./account"

packages/opencode/src/account/repo.ts

@@ -168,6 +168,6 @@ export const layer = Layer.effect(
 
 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
 
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Database.node] })
+export const node = LayerNode.make(layer, [Database.node])
 
 export * as AccountRepo from "./repo"

packages/opencode/src/agent/agent.ts

@@ -447,12 +447,15 @@ export const defaultLayer = layer.pipe(
   Layer.provide(LocationServiceMap.layer),
 )
 
-const locationServiceMapNode = LayerNode.make({ service: Service, layer: LocationServiceMap.layer, deps: [] })
+const locationServiceMapNode = LayerNode.make(LocationServiceMap.layer, [])
 
-export const node = LayerNode.make({
-  service: Service,
-  layer: layer,
-  deps: [Config.node, Auth.node, Plugin.node, Skill.node, Provider.node, locationServiceMapNode],
-})
+export const node = LayerNode.make(layer, [
+  Config.node,
+  Auth.node,
+  Plugin.node,
+  Skill.node,
+  Provider.node,
+  locationServiceMapNode,
+])
 
 export * as Agent from "./agent"

packages/opencode/src/auth/index.ts

@@ -94,6 +94,6 @@ export const layer = Layer.effect(
 
 export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer))
 
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node] })
+export const node = LayerNode.make(layer, [FSUtil.node])
 
 export * as Auth from "."

packages/opencode/src/background/job.ts

@@ -34,6 +34,6 @@ export const layer = Layer.effect(
 
 export const defaultLayer = layer
 
-export const node = LayerNode.make({ service: CoreBackgroundJob.Service, layer, deps: [] })
+export const node = LayerNode.make(layer, [])
 
 export * as BackgroundJob from "./job"

packages/opencode/src/cli/cmd/mcp.ts

@@ -669,20 +669,14 @@ export const McpDebugCommand = effectCmd({
     const config = yield* Config.Service.use((cfg) => cfg.get())
     const mcp = yield* MCP.Service
     const auth = yield* McpAuth.Service
-    const serverConfig = config.mcp?.[args.name]
-    const authInfo =
-      serverConfig && isMcpRemote(serverConfig) && serverConfig.oauth !== false
-        ? yield* Effect.all({
-            authStatus: mcp.getAuthStatus(args.name),
-            entry: auth.get(args.name),
-          })
-        : undefined
     yield* Effect.promise(async () => {
       UI.empty()
       prompts.intro("MCP OAuth Debug")
 
+      const mcpServers = config.mcp ?? {}
       const serverName = args.name
 
+      const serverConfig = mcpServers[serverName]
       if (!serverConfig) {
         prompts.log.error(`MCP server not found: ${serverName}`)
         prompts.outro("Done")
@@ -704,13 +698,17 @@ export const McpDebugCommand = effectCmd({
       prompts.log.info(`Server: ${serverName}`)
       prompts.log.info(`URL: ${serverConfig.url}`)
 
-      const { authStatus, entry } = authInfo!
+      // Check stored auth status — services already in hand, run inline.
+      const { authStatus, entry } = await Effect.runPromise(
+        Effect.all({
+          authStatus: mcp.getAuthStatus(serverName),
+          entry: auth.get(serverName),
+        }),
+      )
       prompts.log.info(`Auth status: ${getAuthStatusIcon(authStatus)} ${getAuthStatusText(authStatus)}`)
 
       if (entry?.tokens) {
-        prompts.log.info(
-          `  Access token: ${entry.tokens.accessToken.length > 8 ? `${entry.tokens.accessToken.slice(0, 4)}***${entry.tokens.accessToken.slice(-4)}` : "***"}`,
-        )
+        prompts.log.info(`  Access token: ${entry.tokens.accessToken.substring(0, 20)}...`)
         if (entry.tokens.expiresAt) {
           const expiresDate = new Date(entry.tokens.expiresAt * 1000)
           const isExpired = entry.tokens.expiresAt < Date.now() / 1000

packages/opencode/src/command/index.ts

@@ -170,6 +170,6 @@ export const defaultLayer = layer.pipe(
   Layer.provide(Skill.defaultLayer),
 )
 
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Config.node, MCP.node, Skill.node] })
+export const node = LayerNode.make(layer, [Config.node, MCP.node, Skill.node])
 
 export * as Command from "."

packages/opencode/src/config/config.ts

@@ -681,10 +681,6 @@ export const defaultLayer = layer.pipe(
   Layer.provide(FetchHttpClient.layer),
 )
 
-export const node = LayerNode.make({
-  service: Service,
-  layer: layer,
-  deps: [FSUtil.node, Auth.node, Account.node, Env.node, Npm.node, httpClient],
-})
+export const node = LayerNode.make(layer, [FSUtil.node, Auth.node, Account.node, Env.node, Npm.node, httpClient])
 
 export * as Config from "./config"

packages/opencode/src/control-plane/workspace.ts

@@ -958,20 +958,16 @@ function route(url: string | URL, path: string) {
   return next
 }
 
-export const node = LayerNode.make({
-  service: Service,
-  layer: layer,
-  deps: [
-    Auth.node,
-    Session.node,
-    SessionPrompt.node,
-    httpClient,
-    EventV2Bridge.node,
-    Vcs.node,
-    RuntimeFlags.node,
-    FSUtil.node,
-    Database.node,
-  ],
-})
+export const node = LayerNode.make(layer, [
+  Auth.node,
+  Session.node,
+  SessionPrompt.node,
+  httpClient,
+  EventV2Bridge.node,
+  Vcs.node,
+  RuntimeFlags.node,
+  FSUtil.node,
+  Database.node,
+])
 
 export * as Workspace from "./workspace"