fix(core): separate interruption from finish

CONTEXT.md

@@ -174,7 +174,6 @@ _Avoid_: Response envelope
 - `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.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.

bun.lock

@@ -31,10 +31,6 @@
       "name": "@opencode-ai/app",
       "version": "1.17.11",
       "dependencies": {
-        "@dnd-kit/abstract": "0.5.0",
-        "@dnd-kit/dom": "0.5.0",
-        "@dnd-kit/helpers": "0.5.0",
-        "@dnd-kit/solid": "0.5.0",
         "@kobalte/core": "catalog:",
         "@opencode-ai/core": "workspace:*",
         "@opencode-ai/sdk": "workspace:*",
@@ -63,7 +59,7 @@
         "diff": "catalog:",
         "effect": "catalog:",
         "fuzzysort": "catalog:",
-        "ghostty-web": "github:anomalyco/ghostty-web#513463a6f1190253057e8a3f0dac8f6ee8393553",
+        "ghostty-web": "github:anomalyco/ghostty-web#main",
         "luxon": "catalog:",
         "marked": "catalog:",
         "marked-shiki": "catalog:",
@@ -1455,20 +1451,6 @@
 
     "@develar/schema-utils": ["@develar/schema-utils@2.6.5", "", { "dependencies": { "ajv": "^6.12.0", "ajv-keywords": "^3.4.1" } }, "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig=="],
 
-    "@dnd-kit/abstract": ["@dnd-kit/abstract@0.5.0", "", { "dependencies": { "@dnd-kit/geometry": "^0.5.0", "@dnd-kit/state": "^0.5.0", "tslib": "^2.6.2" } }, "sha512-hi13iMJgjPX/KDYVKg5VeDIhmYiV6buc9bAX+tCLYf4QdyYjPbsXjn2sPo6m7fQ6SGJBEFgHJ2PemeKDUbwBaA=="],
-
-    "@dnd-kit/collision": ["@dnd-kit/collision@0.5.0", "", { "dependencies": { "@dnd-kit/abstract": "^0.5.0", "@dnd-kit/geometry": "^0.5.0", "tslib": "^2.6.2" } }, "sha512-xUqRn3lS7oqLkT0AnnHS/STh/Czvwe1UapZFYiLbsUGxopMsQd4teaPCzPouOThoMdGEe+dHWjfqJl6t9iG4mQ=="],
-
-    "@dnd-kit/dom": ["@dnd-kit/dom@0.5.0", "", { "dependencies": { "@dnd-kit/abstract": "^0.5.0", "@dnd-kit/collision": "^0.5.0", "@dnd-kit/geometry": "^0.5.0", "@dnd-kit/state": "^0.5.0", "tslib": "^2.6.2" } }, "sha512-f2xFJp5SYQ8EW/Fbtaa8iBb66hpkWc7qa8vU826KW11/tb44sH+AisZnGtwOOTWTQ0GraqBDr5ixTErww+eKXw=="],
-
-    "@dnd-kit/geometry": ["@dnd-kit/geometry@0.5.0", "", { "dependencies": { "@dnd-kit/state": "^0.5.0", "tslib": "^2.6.2" } }, "sha512-ubHQS1CiSDH8ssYH2xG5BnpwPSFP1tStXXjug7/Ba6qnQdu/EUH47l6QXKIksQnnanfVfDf0aGeevRxgZlj28A=="],
-
-    "@dnd-kit/helpers": ["@dnd-kit/helpers@0.5.0", "", { "dependencies": { "@dnd-kit/abstract": "^0.5.0", "tslib": "^2.6.2" } }, "sha512-i4y+51/icSw+OHMr/su19qhnmNhAzh8PnBwXvapFYTd+64oodIyJRiRkB+hhfxAfnur7RYSW8qacDTrXjg2XOg=="],
-
-    "@dnd-kit/solid": ["@dnd-kit/solid@0.5.0", "", { "dependencies": { "@dnd-kit/abstract": "^0.5.0", "@dnd-kit/dom": "^0.5.0", "@dnd-kit/state": "^0.5.0", "tslib": "^2.6.2" }, "peerDependencies": { "solid-js": "^1.8.0" } }, "sha512-IKDqVZICS0jEeUzpJMIIF61w0WA4zisyx9U7K7Skbmkb/kQSDa3lB0cOc0947RwSO+ALoxytRNOuoNfyOIm3lQ=="],
-
-    "@dnd-kit/state": ["@dnd-kit/state@0.5.0", "", { "dependencies": { "@preact/signals-core": "^1.10.0", "tslib": "^2.6.2" } }, "sha512-y7XbabQqjF58Lk8YmDQuR8l6QjN+Kh4qlGEjUvHuIeasLk1QP+9L5diXS98VMxQIivyMmUtX2//f+3N7qPJX4w=="],
-
     "@dot/log": ["@dot/log@0.1.5", "", { "dependencies": { "chalk": "^4.1.2", "loglevelnext": "^6.0.0", "p-defer": "^3.0.0" } }, "sha512-ECraEVJWv2f2mWK93lYiefUkphStVlKD6yKDzisuoEmxuLKrxO9iGetHK2DoEAkj7sxjE886n0OUVVCUx0YPNg=="],
 
     "@drizzle-team/brocli": ["@drizzle-team/brocli@0.11.0", "", {}, "sha512-hD3pekGiPg0WPCCGAZmusBBJsDqGUR66Y452YgQsZOnkdQ7ViEPKuyP4huUGEZQefp8g34RRodXYmJ2TbCH+tg=="],
@@ -2305,8 +2287,6 @@
 
     "@poppinss/exception": ["@poppinss/exception@1.2.3", "", {}, "sha512-dCED+QRChTVatE9ibtoaxc+WkdzOSjYTKi/+uacHWIsfodVfpsueo3+DKpgU5Px8qXjgmXkSvhXvSCz3fnP9lw=="],
 
-    "@preact/signals-core": ["@preact/signals-core@1.14.3", "", {}, "sha512-m0K3vnbSLC5rHs2ZVfeAMvBtT1zIyq4mxx5OlNncSgMj5Iz6W5Rn3kPrDxAC+iIKmiVe0lSl6U37t5ZkEWoVAw=="],
-
     "@protobuf-ts/plugin": ["@protobuf-ts/plugin@2.11.1", "", { "dependencies": { "@bufbuild/protobuf": "^2.4.0", "@bufbuild/protoplugin": "^2.4.0", "@protobuf-ts/protoc": "^2.11.1", "@protobuf-ts/runtime": "^2.11.1", "@protobuf-ts/runtime-rpc": "^2.11.1", "typescript": "^3.9" }, "bin": { "protoc-gen-ts": "bin/protoc-gen-ts", "protoc-gen-dump": "bin/protoc-gen-dump" } }, "sha512-HyuprDcw0bEEJqkOWe1rnXUP0gwYLij8YhPuZyZk6cJbIgc/Q0IFgoHQxOXNIXAcXM4Sbehh6kjVnCzasElw1A=="],
 
     "@protobuf-ts/protoc": ["@protobuf-ts/protoc@2.11.1", "", { "bin": { "protoc": "protoc.js" } }, "sha512-mUZJaV0daGO6HUX90o/atzQ6A7bbN2RSuHtdwo8SSF2Qoe3zHwa4IHyCN1evftTeHfLmdz+45qo47sL+5P8nyg=="],
@@ -3801,7 +3781,7 @@
 
     "get-tsconfig": ["get-tsconfig@4.14.0", "", { "dependencies": { "resolve-pkg-maps": "^1.0.0" } }, "sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA=="],
 
-    "ghostty-web": ["ghostty-web@github:anomalyco/ghostty-web#513463a", {}, "anomalyco-ghostty-web-513463a", "sha512-GZR8LSmgGzViWnBJrqRI8MpAZRCJxhcr1Hi9Tyeh7YRooHZQjK9J97FQRD3tbBaM2wjq05gzGY2UEsG+JtZeBw=="],
+    "ghostty-web": ["ghostty-web@github:anomalyco/ghostty-web#20bd361", {}, "anomalyco-ghostty-web-20bd361", "sha512-dW0nwaiBBcun9y5WJSvm3HxDLe5o9V0xLCndQvWonRVubU8CS1PHxZpLffyPt1YujPWC13ez03aWxcuKBPYYGQ=="],
 
     "giget": ["giget@2.0.0", "", { "dependencies": { "citty": "^0.1.6", "consola": "^3.4.0", "defu": "^6.1.4", "node-fetch-native": "^1.6.6", "nypm": "^0.6.0", "pathe": "^2.0.3" }, "bin": { "giget": "dist/cli.mjs" } }, "sha512-L5bGsVkxJbJgdnwyuheIunkGatUF/zssUoxxjACCseZYAVbaqdh9Tsmmlkl8vYan09H7sbvKt4pS8GqKLBrEzA=="],
 

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-OiWvZ57vuyHwiIKNtW1n1KX+MLmOXVG3x4fLKvUoGQw=",
-    "aarch64-linux": "sha256-RnPLxVEg/UsL5IeIFWmXMSLUOG6rVrajYxhyDYj1vTA=",
-    "aarch64-darwin": "sha256-KPIgcBA0pTFBPrCTSZgIbvEorbtWcMgXvyX9bFAypVs=",
-    "x86_64-darwin": "sha256-6jVU7/uVId0VD24MVQ8s8Ill5b6PsKdlBgHg+oceKRg="
+    "x86_64-linux": "sha256-drc/Ev96W6b8b0b5LqdZeeGDQ1SMgsz8r5cMO91ei2o=",
+    "aarch64-linux": "sha256-Ti0hNjhUgkVtdb54vea/lpI0ltDwLoPitVyHtx4JGwY=",
+    "aarch64-darwin": "sha256-br4iQ/kK3tSGp+1FefiCTlwsCRhHHhGbKzSixGWaCto=",
+    "x86_64-darwin": "sha256-h7yje968Kyh8/mVY19YmDB5g693XDhIf0XnuwukzCWE="
   }
 }

packages/app/package.json

@@ -44,10 +44,6 @@
     "vite-plugin-solid": "catalog:"
   },
   "dependencies": {
-    "@dnd-kit/abstract": "0.5.0",
-    "@dnd-kit/dom": "0.5.0",
-    "@dnd-kit/helpers": "0.5.0",
-    "@dnd-kit/solid": "0.5.0",
     "@kobalte/core": "catalog:",
     "@opencode-ai/core": "workspace:*",
     "@opencode-ai/sdk": "workspace:*",
@@ -76,7 +72,7 @@
     "diff": "catalog:",
     "effect": "catalog:",
     "fuzzysort": "catalog:",
-    "ghostty-web": "github:anomalyco/ghostty-web#513463a6f1190253057e8a3f0dac8f6ee8393553",
+    "ghostty-web": "github:anomalyco/ghostty-web#main",
     "luxon": "catalog:",
     "marked": "catalog:",
     "marked-shiki": "catalog:",

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

@@ -1,8 +1,7 @@
+import { Popover } from "@kobalte/core/popover"
 import { For, Show, splitProps, type Accessor, type ComponentProps } from "solid-js"
 import { createStore } from "solid-js/store"
-import { DropdownMenu } from "@opencode-ai/ui/dropdown-menu"
 import { Icon } from "@opencode-ai/ui/icon"
-import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { ProjectAvatar } from "@opencode-ai/ui/v2/project-avatar-v2"
 import { getProjectAvatarVariant } from "@/context/layout"
 import { useLanguage } from "@/context/language"
@@ -26,23 +25,12 @@ export type PromptProjectControls = {
   add: (title: string, server?: string) => void
 }
 
-const actionPrefix = "action:"
-const projectPrefix = "project:"
-
-function projectKey(project: PromptProject) {
-  return `${projectPrefix}${encodeURIComponent(project.server?.key ?? "")}:${encodeURIComponent(project.worktree)}`
-}
-
-function actionKey(server?: string) {
-  return `${actionPrefix}${encodeURIComponent(server ?? "")}`
-}
-
 export function createPromptProjectController(input: {
   controls: Accessor<PromptProjectControls>
   onDone: () => void
 }) {
   const language = useLanguage()
-  const [store, setStore] = createStore({ open: false, search: "", active: "" })
+  const [store, setStore] = createStore({ open: false, search: "" })
   let searchRef: HTMLInputElement | undefined
 
   const selected = () => {
@@ -65,25 +53,8 @@ export function createPromptProjectController(input: {
       .controls()
       .available.map((project) => project.server)
       .filter((server, index, all) => server && all.findIndex((item) => item?.key === server.key) === index)
-  const keys = () => {
-    if (servers().length <= 1) {
-      return [...projects().map(projectKey), actionKey(servers()[0]?.key)]
-    }
-    return servers().flatMap((server) => [
-      ...projects()
-        .filter((project) => project.server?.key === server!.key)
-        .map(projectKey),
-      actionKey(server!.key),
-    ])
-  }
-  const initialActive = () => {
-    const selectedKey = selected() ? projectKey(selected()!) : undefined
-    const options = keys()
-    if (selectedKey && options.includes(selectedKey)) return selectedKey
-    return options[0] ?? ""
-  }
   const close = () => {
-    setStore({ open: false, search: "", active: "" })
+    setStore({ open: false, search: "" })
     input.onDone()
   }
   const select = (project: PromptProject) => {
@@ -96,7 +67,7 @@ export function createPromptProjectController(input: {
     close()
   }
   const add = (server?: string) => {
-    setStore({ open: false, search: "", active: "" })
+    setStore("open", false)
     input.controls().add(language.t("command.project.open"), server)
   }
 
@@ -104,11 +75,8 @@ export function createPromptProjectController(input: {
     selected,
     projects,
     servers,
-    projectKey,
-    actionKey,
     open: () => store.open,
     search: () => store.search,
-    active: () => store.active,
     labels: {
       add: () => language.t("session.new.project.add"),
       clear: () => language.t("common.clear"),
@@ -118,188 +86,50 @@ export function createPromptProjectController(input: {
     add,
     select,
     setOpen(open: boolean) {
-      if (open) {
-        setStore({ open: true, active: initialActive() })
-        setTimeout(() => requestAnimationFrame(() => searchRef?.focus()))
-        return
-      }
-      setStore({ open: false, search: "", active: "" })
+      setStore("open", open)
+      if (open) requestAnimationFrame(() => searchRef?.focus())
     },
     setSearch(value: string) {
-      const search = value.trim().toLowerCase()
-      const first = input
-        .controls()
-        .available.find((project) => !search || displayName(project).toLowerCase().includes(search))
-      setStore({ search: value, active: first ? projectKey(first) : actionKey(servers()[0]?.key) })
-    },
-    clearSearch() {
-      setStore({ search: "", active: initialActive() })
-      setTimeout(() => searchRef?.focus())
-    },
-    setActive(key: string) {
-      setStore("active", key)
-    },
-    moveActive(delta: number) {
-      const options = keys()
-      if (options.length === 0) return
-      const index = options.indexOf(store.active)
-      const start = index === -1 ? 0 : index
-      setStore("active", options[(start + delta + options.length) % options.length])
-    },
-    activeProject() {
-      return store.active.startsWith(projectPrefix)
-        ? projects().find((project) => projectKey(project) === store.active)
-        : undefined
-    },
-    activeServer() {
-      return store.active.startsWith(actionPrefix)
-        ? decodeURIComponent(store.active.slice(actionPrefix.length)) || undefined
-        : undefined
+      setStore("search", value)
     },
     setSearchRef(el: HTMLInputElement) {
       searchRef = el
     },
-    focusSearch() {
-      setTimeout(() => requestAnimationFrame(() => searchRef?.focus()))
-    },
   }
 }
 
 export type PromptProjectController = ReturnType<typeof createPromptProjectController>
 
 export function PromptProjectSelector(props: { controller: PromptProjectController }) {
-  let contentRef: HTMLDivElement | undefined
-  let restoreTrigger = true
-
-  const activeItem = () =>
-    props.controller.active()
-      ? contentRef?.querySelector<HTMLElement>(`[data-option-key="${CSS.escape(props.controller.active())}"]`)
-      : undefined
-  const afterClose = (callback: () => void) => {
-    const complete = () => {
-      if (contentRef?.isConnected) {
-        requestAnimationFrame(complete)
-        return
-      }
-      requestAnimationFrame(() => requestAnimationFrame(callback))
-    }
-    requestAnimationFrame(complete)
-  }
-  const selectProject = (project: PromptProject) => {
-    restoreTrigger = false
-    props.controller.setOpen(false)
-    afterClose(() => props.controller.select(project))
-  }
-  const selectAction = (server?: string) => {
-    restoreTrigger = false
-    props.controller.setOpen(false)
-    afterClose(() => props.controller.add(server))
-  }
-  const selectActive = () => {
-    const project = props.controller.activeProject()
-    if (project) {
-      selectProject(project)
-      return
-    }
-    selectAction(props.controller.activeServer())
-  }
-  const moveActive = (delta: number) => {
-    props.controller.moveActive(delta)
-    queueMicrotask(() => activeItem()?.scrollIntoView({ block: "nearest" }))
-  }
-  const focusPreviousControl = () => {
-    const target = Array.from(
-      document.querySelectorAll<HTMLElement>(
-        'button:not([disabled]), a[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])',
-      ),
-    )
-      .filter((element) => !contentRef?.contains(element) && !element.hasAttribute("data-focus-trap"))
-      .findLast((element) => element.offsetParent !== null)
-    restoreTrigger = false
-    target?.focus()
-    queueMicrotask(() => {
-      if (props.controller.open()) props.controller.setOpen(false)
-    })
-  }
-  const selectedValue = () => {
-    const project = props.controller.selected()
-    return project ? props.controller.projectKey(project) : undefined
-  }
-
   return (
-    <DropdownMenu
+    <Popover
       open={props.controller.open()}
       placement="bottom-start"
       gutter={4}
-      shift={-6}
       modal={false}
       onOpenChange={(open) => props.controller.setOpen(open)}
     >
-      <DropdownMenu.Trigger as={ProjectTrigger} controller={props.controller} />
-      <DropdownMenu.Portal>
-        <DropdownMenu.Content
-          ref={contentRef}
-          id="prompt-project-menu"
-          class="w-[243px] overflow-hidden rounded-md border-0 bg-v2-background-bg-layer-01 p-0 shadow-[var(--v2-elevation-floating)] focus:outline-none [&[data-closed]]:!animate-none"
+      <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()}
-          onPointerDownOutside={() => (restoreTrigger = false)}
-          onFocusOutside={() => (restoreTrigger = false)}
-          onCloseAutoFocus={(event) => {
-            if (!restoreTrigger) event.preventDefault()
-          }}
         >
           <div class="flex flex-col p-0.5">
-            <div class="flex h-7 items-center gap-2 rounded-sm pl-3 pr-2.5 text-v2-icon-icon-muted">
+            <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()}
-                aria-autocomplete="list"
-                aria-controls="prompt-project-menu"
-                aria-activedescendant={props.controller.active() || undefined}
                 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)}
-                onKeyDown={(event) => {
-                  if (event.key === "Tab") {
-                    event.preventDefault()
-                    event.stopPropagation()
-                    if (event.shiftKey) {
-                      focusPreviousControl()
-                      return
-                    }
-                    activeItem()?.focus()
-                    return
-                  }
-                  event.stopPropagation()
-                  if (event.key === "Escape") {
-                    event.preventDefault()
-                    props.controller.setOpen(false)
-                    return
-                  }
-                  if (event.altKey || event.metaKey) return
-                  if (event.key === "ArrowDown") {
-                    event.preventDefault()
-                    moveActive(1)
-                    return
-                  }
-                  if (event.key === "ArrowUp") {
-                    event.preventDefault()
-                    moveActive(-1)
-                    return
-                  }
-                  if (event.key === "Enter" && !event.isComposing) {
-                    event.preventDefault()
-                    selectActive()
-                  }
-                }}
               />
               <Show when={props.controller.search().trim()}>
                 <button
                   type="button"
-                  class="flex size-5 items-center justify-center rounded-sm text-v2-icon-icon-muted hover:bg-v2-overlay-simple-overlay-hover"
-                  onPointerDown={(event) => event.preventDefault()}
-                  onClick={() => props.controller.clearSearch()}
+                  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" />
@@ -309,13 +139,15 @@ export function PromptProjectSelector(props: { controller: PromptProjectControll
             <Show
               when={props.controller.servers().length > 1}
               fallback={
-                <DropdownMenu.RadioGroup value={selectedValue()}>
-                  <For each={props.controller.projects()}>
-                    {(project) => (
-                      <ProjectItem project={project} controller={props.controller} onSelect={selectProject} />
-                    )}
-                  </For>
-                </DropdownMenu.RadioGroup>
+                <For each={props.controller.projects()}>
+                  {(project) => (
+                    <ProjectItem
+                      project={project}
+                      selected={props.controller.selected()}
+                      onSelect={props.controller.select}
+                    />
+                  )}
+                </For>
               }
             >
               <For each={props.controller.servers()}>
@@ -324,14 +156,19 @@ export function PromptProjectSelector(props: { controller: PromptProjectControll
                     <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>
-                    <DropdownMenu.RadioGroup value={selectedValue()}>
-                      <For each={props.controller.projects().filter((project) => project.server?.key === server!.key)}>
-                        {(project) => (
-                          <ProjectItem project={project} controller={props.controller} onSelect={selectProject} />
-                        )}
-                      </For>
-                    </DropdownMenu.RadioGroup>
-                    <ProjectAction server={server!.key} controller={props.controller} onSelect={selectAction} />
+                    <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>
@@ -341,15 +178,14 @@ export function PromptProjectSelector(props: { controller: PromptProjectControll
             <div class="h-px bg-v2-border-border-muted" />
             <div class="flex flex-col p-0.5">
               <ProjectAction
-                server={props.controller.servers()[0]?.key}
-                controller={props.controller}
-                onSelect={selectAction}
+                label={props.controller.labels.add()}
+                onSelect={() => props.controller.add(props.controller.servers()[0]?.key)}
               />
             </div>
           </Show>
-        </DropdownMenu.Content>
-      </DropdownMenu.Portal>
-    </DropdownMenu>
+        </Popover.Content>
+      </Popover.Portal>
+    </Popover>
   )
 }
 
@@ -369,28 +205,15 @@ export function PromptProjectAddButton(props: { controller: PromptProjectControl
 }
 
 function ProjectTrigger(props: ComponentProps<"button"> & { controller: PromptProjectController }) {
-  const [local, rest] = splitProps(props, ["controller", "class", "classList", "onClick", "onKeyDown"])
+  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 focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none"
-      classList={{
-        ...local.classList,
-        "hover:bg-v2-overlay-simple-overlay-hover": !local.controller.open(),
-        "bg-v2-overlay-simple-overlay-pressed": local.controller.open(),
-      }}
-      onClick={local.onClick ?? (() => local.controller.setOpen(true))}
-      onKeyDown={(event) => {
-        if (!local.controller.open() && (event.key === "ArrowDown" || event.key === "ArrowUp")) {
-          event.preventDefault()
-          event.stopPropagation()
-          return
-        }
-        if (typeof local.onKeyDown === "function") local.onKeyDown(event)
-      }}
+      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()}
@@ -414,77 +237,42 @@ function ProjectTrigger(props: ComponentProps<"button"> & { controller: PromptPr
 
 function ProjectItem(props: {
   project: PromptProject
-  controller: PromptProjectController
+  selected?: PromptProject
   onSelect: (project: PromptProject) => void
 }) {
-  const key = () => props.controller.projectKey(props.project)
   return (
-    <DropdownMenu.RadioItem
-      id={key()}
-      value={key()}
-      data-option-key={key()}
-      class="h-7 gap-2 rounded-sm px-3 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base data-[highlighted]:!bg-v2-overlay-simple-overlay-hover"
-      classList={{ "!bg-v2-overlay-simple-overlay-hover": props.controller.active() === key() }}
-      style={{
-        "font-family": "var(--v2-font-family-sans)",
-        "font-size": "13px",
-        "font-weight": 440,
-        "line-height": "20px",
-        "letter-spacing": "-0.04px",
-        color: "var(--v2-text-text-base)",
-        padding: "0 12px",
-      }}
-      closeOnSelect
-      onMouseEnter={() => {
-        props.controller.setActive(key())
-        props.controller.focusSearch()
-      }}
-      onSelect={() => props.onSelect(props.project)}
+    <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)}
       />
-      <DropdownMenu.ItemLabel class="min-w-0 truncate leading-5">{displayName(props.project)}</DropdownMenu.ItemLabel>
-      <DropdownMenu.ItemIndicator style={{ width: "14px", height: "14px", right: "12px" }}>
-        <IconV2 name="check" size="small" class="shrink-0 text-v2-icon-icon-base" />
-      </DropdownMenu.ItemIndicator>
-    </DropdownMenu.RadioItem>
+      <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: {
-  server?: string
-  controller: PromptProjectController
-  onSelect: (server?: string) => void
-}) {
-  const key = () => props.controller.actionKey(props.server)
+function ProjectAction(props: { label: string; onSelect: () => void }) {
   return (
-    <DropdownMenu.Item
-      id={key()}
-      data-option-key={key()}
-      class="h-7 gap-2 rounded-sm px-3 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base data-[highlighted]:!bg-v2-overlay-simple-overlay-hover"
-      classList={{ "!bg-v2-overlay-simple-overlay-hover": props.controller.active() === key() }}
-      style={{
-        "font-family": "var(--v2-font-family-sans)",
-        "font-size": "13px",
-        "font-weight": 440,
-        "line-height": "20px",
-        "letter-spacing": "-0.04px",
-        color: "var(--v2-text-text-base)",
-        padding: "0 12px",
-      }}
-      onMouseEnter={() => {
-        props.controller.setActive(key())
-        props.controller.focusSearch()
-      }}
-      onSelect={() => props.onSelect(props.server)}
+    <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" />
-      <DropdownMenu.ItemLabel class="min-w-0 truncate leading-5">
-        {props.controller.labels.add()}
-      </DropdownMenu.ItemLabel>
-    </DropdownMenu.Item>
+      <span class="min-w-0 flex-1 truncate leading-5">{props.label}</span>
+    </button>
   )
 }

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

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

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

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

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

@@ -1,33 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { canOpenTabRename, canStartTabDrag, forwardTabRef, isTabCloseTarget } from "./titlebar-tab-gesture"
-
-describe("titlebar tab gestures", () => {
-  test("excludes close controls from tab gestures", () => {
-    const close = document.createElement("div")
-    const button = document.createElement("button")
-    const link = document.createElement("a")
-    close.dataset.slot = "tab-close"
-    close.append(button)
-    expect(isTabCloseTarget(close)).toBe(true)
-    expect(isTabCloseTarget(button)).toBe(true)
-    expect(isTabCloseTarget(link)).toBe(false)
-  })
-
-  test("forwards component refs", () => {
-    const element = document.createElement("div")
-    let received: HTMLDivElement | undefined
-    forwardTabRef((value) => (received = value), element)
-    expect(received).toBe(element)
-  })
-
-  test("does not reopen rename while a save is pending", () => {
-    expect(canOpenTabRename(false, false, false)).toBe(true)
-    expect(canOpenTabRename(false, false, true)).toBe(false)
-  })
-
-  test("preserves native panning for touch pointers", () => {
-    expect(canStartTabDrag("mouse")).toBe(true)
-    expect(canStartTabDrag("pen")).toBe(true)
-    expect(canStartTabDrag("touch")).toBe(false)
-  })
-})

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

@@ -8,6 +8,22 @@ export function canStartTabDrag(pointerType: string) {
   return pointerType !== "touch"
 }
 
+export function isPrimaryPointerPressed(buttons: number) {
+  return (buttons & 1) !== 0
+}
+
+export function captureTabPointerDown(element: HTMLDivElement, clientX: number, clientY: number) {
+  const rect = element.getBoundingClientRect()
+  return {
+    startX: clientX,
+    startY: clientY,
+    grabOffsetX: clientX - rect.left,
+    grabOffsetY: clientY - rect.top,
+    width: rect.width,
+    element,
+  }
+}
+
 export function forwardTabRef(ref: Ref<HTMLDivElement> | undefined, element: HTMLDivElement) {
   if (typeof ref === "function") ref(element)
 }
@@ -15,3 +31,7 @@ export function forwardTabRef(ref: Ref<HTMLDivElement> | undefined, element: HTM
 export function canOpenTabRename(dragging: boolean | undefined, editing: boolean, committing: boolean) {
   return !dragging && !editing && !committing
 }
+
+export function createTabDragPreview(element: HTMLDivElement) {
+  return element.cloneNode(true) as HTMLDivElement
+}

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

@@ -9,10 +9,6 @@
   justify-content: center;
 }
 
-[data-titlebar-tab][data-editing="true"] [data-slot="tab-close"] {
-  display: none;
-}
-
 [data-titlebar-tab-list] {
   gap: 13.5px;
 }

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

@@ -29,6 +29,9 @@ export function TabNavItem(props: {
   dragging?: boolean
   pressed?: boolean
   hidden?: boolean
+  tabKey: string
+  dragActive: boolean
+  onPointerDown: (event: PointerEvent) => void
 }) {
   const language = useLanguage()
   const [editing, setEditing] = createSignal(false)
@@ -170,105 +173,112 @@ export function TabNavItem(props: {
 
   return (
     <div
-      ref={(el) => {
-        tabRoot = el
-        forwardTabRef(props.ref, el)
-      }}
-      data-titlebar-tab
-      data-slot="titlebar-tab-item"
-      data-title-overflow={titleOverflowing()}
-      data-editing={editing()}
-      class="group relative flex h-7 w-full min-w-0 select-none flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [container-type:inline-size] [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] has-[>a:focus-visible]:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[dragging='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[pressed='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[editing='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
-      classList={{ invisible: props.hidden }}
-      data-active={props.active}
-      data-dragging={props.dragging}
-      data-pressed={props.pressed}
-      onMouseDown={(event) => {
-        if (event.button !== 1) return
-        closeTab(event)
-      }}
+      data-titlebar-tab-slot
+      data-tab-key={props.tabKey}
+      class="relative flex w-56 min-w-7 max-w-56 flex-shrink"
+      classList={{ invisible: props.hidden, "pointer-events-none": props.dragActive }}
+      onPointerDown={props.onPointerDown}
     >
-      <Show when={props.session()}>
-        {(session) => {
-          return (
-            <a
-              data-slot="tab-link"
-              data-titlebar-tab-link
-              href={props.href}
-              draggable={false}
-              onDragStart={(event) => {
-                event.preventDefault()
-                event.stopPropagation()
-              }}
-              onClick={(event) => {
-                event.preventDefault()
-                if (editing()) return
-                if (props.suppressNavigation?.()) return
-                props.onNavigate()
-              }}
-              class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 text-[13px] font-medium text-v2-text-text-faint group-data-[active='true']:text-v2-text-text-base group-data-[editing='true']:text-v2-text-text-base [-webkit-user-drag:none]"
-            >
-              <span data-slot="project-avatar-slot">
-                <SessionTabAvatar
-                  project={project()}
-                  directory={session().directory}
-                  sessionId={session().id}
-                  activeServer={props.activeServer}
-                />
-              </span>
-              <span
-                ref={(el) => {
-                  titleEl = el
-                  titleEl.textContent = session().title
-                }}
-                data-slot="tab-title"
-                data-titlebar-tab-title
-                class="min-w-0 flex-1 outline-none leading-4"
-                classList={{
-                  "overflow-hidden text-clip whitespace-nowrap": !editing(),
-                  "select-text": editing(),
-                }}
-                contenteditable={editing() ? true : undefined}
-                onDblClick={openRename}
-                onKeyDown={(event) => {
-                  event.stopPropagation()
-                  if (event.key === "Enter") {
-                    event.preventDefault()
-                    void closeRename(true)
-                    return
-                  }
-                  if (event.key !== "Escape") return
+      <div
+        ref={(el) => {
+          tabRoot = el
+          forwardTabRef(props.ref, el)
+        }}
+        data-titlebar-tab
+        data-slot="titlebar-tab-item"
+        data-title-overflow={titleOverflowing()}
+        data-editing={editing()}
+        class="group relative flex h-7 w-full min-w-0 select-none flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [container-type:inline-size] [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] has-[>a:focus-visible]:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[dragging='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[pressed='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[editing='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
+        data-active={props.active}
+        data-dragging={props.dragging}
+        data-pressed={props.pressed}
+        onMouseDown={(event) => {
+          if (event.button !== 1) return
+          closeTab(event)
+        }}
+      >
+        <Show when={props.session()}>
+          {(session) => {
+            return (
+              <a
+                data-slot="tab-link"
+                data-titlebar-tab-link
+                href={props.href}
+                draggable={false}
+                onDragStart={(event) => {
                   event.preventDefault()
-                  titleEl.textContent = session().title
-                  void closeRename(false)
-                }}
-                onBlur={() => void closeRename(true)}
-                onPointerDown={(event) => {
-                  if (!editing()) return
                   event.stopPropagation()
                 }}
                 onClick={(event) => {
-                  if (!editing()) return
                   event.preventDefault()
+                  if (editing()) return
+                  if (props.suppressNavigation?.()) return
+                  props.onNavigate()
                 }}
-              />
-            </a>
-          )
-        }}
-      </Show>
-
-      <div data-slot="tab-close" class="group-hover:bg-[var(--tab-bg)] group-data-[active=true]:bg-[var(--tab-bg)]">
-        <IconButtonV2
-          size="small"
-          variant="ghost-muted"
-          class="hover-reveal relative z-10 group-hover:opacity-100 group-data-[active=true]:opacity-100 group-data-[editing=true]:opacity-100"
-          onPointerDown={(event) => {
-            event.preventDefault()
-            event.stopPropagation()
+                class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 text-[13px] font-medium text-v2-text-text-faint group-data-[active='true']:text-v2-text-text-base group-data-[editing='true']:text-v2-text-text-base [-webkit-user-drag:none]"
+              >
+                <span data-slot="project-avatar-slot">
+                  <SessionTabAvatar
+                    project={project()}
+                    directory={session().directory}
+                    sessionId={session().id}
+                    activeServer={props.activeServer}
+                  />
+                </span>
+                <span
+                  ref={(el) => {
+                    titleEl = el
+                    titleEl.textContent = session().title
+                  }}
+                  data-slot="tab-title"
+                  data-titlebar-tab-title
+                  class="min-w-0 flex-1 outline-none leading-4"
+                  classList={{
+                    "overflow-hidden text-clip whitespace-nowrap": !editing(),
+                    "select-text": editing(),
+                  }}
+                  contenteditable={editing() ? true : undefined}
+                  onDblClick={openRename}
+                  onKeyDown={(event) => {
+                    event.stopPropagation()
+                    if (event.key === "Enter") {
+                      event.preventDefault()
+                      void closeRename(true)
+                      return
+                    }
+                    if (event.key !== "Escape") return
+                    event.preventDefault()
+                    titleEl.textContent = session().title
+                    void closeRename(false)
+                  }}
+                  onBlur={() => void closeRename(true)}
+                  onPointerDown={(event) => {
+                    if (!editing()) return
+                    event.stopPropagation()
+                  }}
+                  onClick={(event) => {
+                    if (!editing()) return
+                    event.preventDefault()
+                  }}
+                />
+              </a>
+            )
           }}
-          onClick={closeTab}
-          icon={<IconV2 name="xmark-small" />}
-        />
+        </Show>
+
+        <div data-slot="tab-close" class="group-hover:bg-[var(--tab-bg)] group-data-[active=true]:bg-[var(--tab-bg)]">
+          <IconButtonV2
+            size="small"
+            variant="ghost-muted"
+            class="hover-reveal relative z-10 group-hover:opacity-100 group-data-[active=true]:opacity-100 group-data-[editing=true]:opacity-100"
+            onPointerDown={(event) => {
+              event.preventDefault()
+              event.stopPropagation()
+            }}
+            onClick={closeTab}
+            icon={<IconV2 name="xmark-small" />}
+          />
+        </div>
       </div>
     </div>
   )
@@ -285,6 +295,9 @@ export function DraftTabItem(props: {
   dragging?: boolean
   pressed?: boolean
   hidden?: boolean
+  tabKey: string
+  dragActive: boolean
+  onPointerDown: (event: PointerEvent) => void
 }) {
   const closeTab = (event: MouseEvent) => {
     event.preventDefault()
@@ -293,62 +306,69 @@ export function DraftTabItem(props: {
   }
   return (
     <div
-      ref={(el) => forwardTabRef(props.ref, el)}
-      data-titlebar-tab
-      data-slot="titlebar-tab-item"
-      data-active={props.active}
-      data-dragging={props.dragging}
-      data-pressed={props.pressed}
-      class="group relative flex h-7 w-full min-w-0 flex-row items-center gap-1.5 overflow-hidden rounded-[6px] bg-[var(--tab-bg)] px-1.5 [container-type:inline-size] whitespace-nowrap [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] has-[>a:focus-visible]:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[dragging='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[pressed='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[editing='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
-      classList={{ invisible: props.hidden }}
-      onMouseDown={(event) => {
-        if (event.button !== 1) return
-        closeTab(event)
-      }}
+      data-titlebar-tab-slot
+      data-tab-key={props.tabKey}
+      class="relative flex w-56 min-w-7 max-w-56 flex-shrink"
+      classList={{ invisible: props.hidden, "pointer-events-none": props.dragActive }}
+      onPointerDown={props.onPointerDown}
     >
-      <a
-        data-slot="tab-link"
-        data-titlebar-tab-link
-        href={props.href}
-        draggable={false}
-        onDragStart={(event) => {
-          event.preventDefault()
-          event.stopPropagation()
+      <div
+        ref={(el) => forwardTabRef(props.ref, el)}
+        data-titlebar-tab
+        data-slot="titlebar-tab-item"
+        data-active={props.active}
+        data-dragging={props.dragging}
+        data-pressed={props.pressed}
+        class="group relative flex h-7 w-full min-w-0 select-none flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [container-type:inline-size] [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] has-[>a:focus-visible]:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[dragging='true']:[--tab-bg:var(--v2-background-bg-layer-02)] data-[pressed='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
+        onMouseDown={(event) => {
+          if (event.button !== 1) return
+          closeTab(event)
         }}
-        onClick={(event) => {
-          event.preventDefault()
-          if (props.suppressNavigation?.()) return
-          props.onNavigate()
-        }}
-        class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 text-[13px] font-medium text-v2-text-text-faint group-data-[active='true']:text-v2-text-text-base [-webkit-user-drag:none]"
       >
-        <span class="flex size-4 shrink-0 items-center justify-center">
-          <IconV2 name="edit" />
-        </span>
-        <span
-          data-titlebar-tab-title
-          class="min-w-0 flex-1 overflow-hidden text-clip whitespace-nowrap outline-none leading-4"
+        <a
+          data-slot="tab-link"
+          data-titlebar-tab-link
+          href={props.href}
+          draggable={false}
+          onDragStart={(event) => {
+            event.preventDefault()
+            event.stopPropagation()
+          }}
+          onClick={(event) => {
+            event.preventDefault()
+            if (props.suppressNavigation?.()) return
+            props.onNavigate()
+          }}
+          class="flex h-full min-w-0 flex-1 flex-row items-center gap-1.5 text-[13px] font-medium text-v2-text-text-faint group-data-[active='true']:text-v2-text-text-base [-webkit-user-drag:none]"
         >
-          {props.title}
-        </span>
-      </a>
-      <div data-slot="tab-close" class="group-hover:bg-[var(--tab-bg)] group-data-[active=true]:bg-[var(--tab-bg)]">
-        <IconButtonV2
-          size="small"
-          variant="ghost-muted"
-          onPointerDown={(event) => {
-            event.preventDefault()
-            event.stopPropagation()
-          }}
-          onMouseDown={(event) => {
-            event.preventDefault()
-            event.stopPropagation()
-          }}
-          class="hover-reveal relative z-10 group-hover:opacity-100 group-data-[active=true]:opacity-100 group-data-[editing=true]:opacity-100"
-          onClick={closeTab}
-          icon={<IconV2 name="xmark-small" />}
-          aria-label="Close tab"
-        />
+          <span class="flex size-4 shrink-0 items-center justify-center">
+            <IconV2 name="edit" />
+          </span>
+          <span
+            data-titlebar-tab-title
+            class="min-w-0 flex-1 overflow-hidden text-clip whitespace-nowrap outline-none leading-4"
+          >
+            {props.title}
+          </span>
+        </a>
+        <div data-slot="tab-close" class="group-hover:bg-[var(--tab-bg)] group-data-[active=true]:bg-[var(--tab-bg)]">
+          <IconButtonV2
+            size="small"
+            variant="ghost-muted"
+            onPointerDown={(event) => {
+              event.preventDefault()
+              event.stopPropagation()
+            }}
+            onMouseDown={(event) => {
+              event.preventDefault()
+              event.stopPropagation()
+            }}
+            class="hover-reveal relative z-10 group-hover:opacity-100 group-data-[active=true]:opacity-100 group-data-[editing=true]:opacity-100"
+            onClick={closeTab}
+            icon={<IconV2 name="xmark-small" />}
+            aria-label="Close tab"
+          />
+        </div>
       </div>
     </div>
   )

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

@@ -1,11 +1,18 @@
-import { createEffect, createMemo, createResource, createRoot, For, onCleanup, onMount } from "solid-js"
+import {
+  createEffect,
+  createMemo,
+  createResource,
+  createRoot,
+  createSignal,
+  For,
+  onCleanup,
+  onMount,
+  Show,
+} from "solid-js"
+import { Portal } from "solid-js/web"
+import { createStore } from "solid-js/store"
+import { makeEventListener } from "@solid-primitives/event-listener"
 import { createResizeObserver } from "@solid-primitives/resize-observer"
-import { DragDropProvider, PointerSensor } from "@dnd-kit/solid"
-import { isSortable, useSortable } from "@dnd-kit/solid/sortable"
-import { Accessibility, AutoScroller, Feedback, PointerActivationConstraints } from "@dnd-kit/dom"
-import { RestrictToHorizontalAxis } from "@dnd-kit/abstract/modifiers"
-import { RestrictToElement } from "@dnd-kit/dom/modifiers"
-import { arrayMove } from "@dnd-kit/helpers"
 import { tabHref, tabKey, type SessionTab, type Tab } from "@/context/tabs"
 import { ServerConnection } from "@/context/server"
 import { DraftTabItem, TabNavItem } from "@/components/titlebar-tab-nav"
@@ -15,30 +22,42 @@ import { useCommand } from "@/context/command"
 import { useTabs } from "@/context/tabs"
 import { createTabPromptState } from "@/context/prompt"
 import { base64Encode } from "@opencode-ai/core/util/encode"
-import { canStartTabDrag, isTabCloseTarget } from "./titlebar-tab-gesture"
-
-const sortableTransition = { duration: 0 }
+import {
+  captureTabPointerDown,
+  canStartTabDrag,
+  createTabDragPreview,
+  isPrimaryPointerPressed,
+  isTabCloseTarget,
+} from "./titlebar-tab-gesture"
+import {
+  ACTIVATION_DISTANCE,
+  autoscrollSpeed,
+  captureTabDragLayout,
+  clampFloaterLeft,
+  draftOrderChanged,
+  insertIndexFromVirtualLayout,
+  movePlaceholder,
+  pointerDistance,
+  syncLayoutScroll,
+  type TabDragLayout,
+} from "@/components/titlebar-tab-drag"
 
 function SessionTabSlot(props: {
   tab: SessionTab
   id: string
-  index: () => number
   active: () => boolean
   activeServerKey: ServerConnection.Key
   forceTruncate: boolean
+  dragActive: boolean
+  dragged: () => boolean
+  pressed: () => boolean
   serverCtx: () => ServerCtx | undefined
+  suppressNavigation: () => boolean
+  onPointerDown: (event: PointerEvent) => void
   onNavigate: (element: HTMLDivElement) => void
   onClose: () => void
 }) {
   const tabs = useTabs()
-  const sortable = useSortable({
-    get id() {
-      return props.id
-    },
-    get index() {
-      return props.index()
-    },
-  })
   let ref!: HTMLDivElement
   const sdk = createMemo(() => props.serverCtx()?.sdk ?? null)
   const cachedSession = createMemo(() => props.serverCtx()?.sync.session.peek(props.tab.sessionId))
@@ -81,79 +100,33 @@ function SessionTabSlot(props: {
   })
 
   return (
-    <div
-      ref={sortable.ref}
-      data-titlebar-tab-slot
-      data-tab-key={props.id}
-      class="relative flex w-56 min-w-7 max-w-56 flex-shrink"
-      classList={{ hidden: !session() }}
-    >
-      <TabNavItem
-        ref={(el) => {
-          ref = el
-        }}
-        href={tabHref(props.tab)}
-        server={props.tab.server}
-        session={session}
-        onTitleChange={(title) => {
-          const value = session()
-          const ctx = props.serverCtx()
-          if (value && ctx) ctx.sync.session.remember({ ...value, title })
-        }}
-        onTitleChangeFailed={(title) => {
-          const value = session()
-          const ctx = props.serverCtx()
-          if (value && ctx) ctx.sync.session.remember({ ...value, title })
-        }}
-        onNavigate={() => props.onNavigate(ref)}
-        onClose={props.onClose}
-        active={props.active()}
-        activeServer={props.tab.server === props.activeServerKey}
-        forceTruncate={props.forceTruncate}
-        dragging={sortable.isDragSource()}
-      />
-    </div>
-  )
-}
-
-function DraftTabSlot(props: {
-  tab: Extract<Tab, { type: "draft" }>
-  id: string
-  index: () => number
-  active: () => boolean
-  title: string
-  onNavigate: (element: HTMLDivElement) => void
-  onClose: () => void
-}) {
-  const sortable = useSortable({
-    get id() {
-      return props.id
-    },
-    get index() {
-      return props.index()
-    },
-  })
-  let ref!: HTMLDivElement
-
-  return (
-    <div
-      ref={sortable.ref}
-      data-titlebar-tab-slot
-      data-tab-key={props.id}
-      class="relative flex w-56 min-w-7 max-w-56 flex-shrink"
-    >
-      <DraftTabItem
-        ref={(el) => {
-          ref = el
-        }}
-        href={tabHref(props.tab)}
-        title={props.title}
-        onNavigate={() => props.onNavigate(ref)}
-        onClose={props.onClose}
-        active={props.active()}
-        dragging={sortable.isDragSource()}
-      />
-    </div>
+    <TabNavItem
+      tabKey={props.id}
+      dragActive={props.dragActive}
+      onPointerDown={props.onPointerDown}
+      ref={ref}
+      href={tabHref(props.tab)}
+      server={props.tab.server}
+      session={session}
+      onTitleChange={(title) => {
+        const value = session()
+        const ctx = props.serverCtx()
+        if (value && ctx) ctx.sync.session.remember({ ...value, title })
+      }}
+      onTitleChangeFailed={(title) => {
+        const value = session()
+        const ctx = props.serverCtx()
+        if (value && ctx) ctx.sync.session.remember({ ...value, title })
+      }}
+      onNavigate={() => props.onNavigate(ref)}
+      onClose={props.onClose}
+      active={props.active()}
+      activeServer={props.tab.server === props.activeServerKey}
+      forceTruncate={props.forceTruncate}
+      suppressNavigation={props.suppressNavigation}
+      pressed={props.pressed()}
+      hidden={props.dragged() || !session()}
+    />
   )
 }
 
@@ -169,12 +142,52 @@ export function TitlebarTabStrip(props: {
 }) {
   const global = useGlobal()
   const language = useLanguage()
+  const [drag, setDrag] = createStore({
+    active: false,
+    draggedId: undefined as string | undefined,
+    placeholderIndex: 0,
+    draftOrder: [] as string[],
+    initialOrder: [] as string[],
+    draggedWidth: 0,
+    pointerX: 0,
+    grabOffsetX: 0,
+    floaterTop: 0,
+  })
+
+  const [gesture, setGesture] = createStore({
+    pending: undefined as
+      | {
+          id: string
+          startX: number
+          startY: number
+          grabOffsetX: number
+          grabOffsetY: number
+          pointerId: number
+          width: number
+          element: HTMLDivElement
+        }
+      | undefined,
+  })
+
+  const [suppressNavigation, setSuppressNavigation] = createSignal(false)
+  const [pressedId, setPressedId] = createSignal<string | undefined>()
+  const [stripScrollLeft, setStripScrollLeft] = createSignal(0)
   let scrollRef!: HTMLDivElement
   let listRef!: HTMLDivElement
+  let dragLayout: TabDragLayout | undefined
+  let dragPointerId: number | undefined
+  let autoscrollFrame: number | undefined
   let resizeFrame: number | undefined
+  let dragPreview: HTMLDivElement | undefined
 
   const tabIds = () => props.tabs.map(tabKey)
 
+  const displayTabs = createMemo(() => {
+    if (!drag.active || drag.draftOrder.length === 0) return props.tabs
+    const byKey = new Map(props.tabs.map((tab) => [tabKey(tab), tab]))
+    return drag.draftOrder.map((key) => byKey.get(key)).filter((tab): tab is Tab => !!tab)
+  })
+
   function refreshOverflow() {
     if (!scrollRef) return
     props.onOverflowChange(scrollRef.scrollWidth > scrollRef.clientWidth)
@@ -187,14 +200,220 @@ export function TitlebarTabStrip(props: {
       resizeFrame = requestAnimationFrame(() => {
         resizeFrame = undefined
         refreshOverflow()
+        if (!drag.active || !listRef) return
+        dragLayout = captureTabDragLayout(listRef, drag.draftOrder)
+        updateInsertIndex()
       })
     },
   )
 
-  onMount(() => {
+  function syncScroll() {
+    if (!scrollRef || !listRef || !dragLayout) return
+    syncLayoutScroll(listRef, dragLayout)
+    setStripScrollLeft(scrollRef.scrollLeft)
+    updateInsertIndex()
+  }
+
+  function stopAutoscroll() {
+    if (autoscrollFrame === undefined) return
+    cancelAnimationFrame(autoscrollFrame)
+    autoscrollFrame = undefined
+  }
+
+  function tickAutoscroll() {
+    if (!drag.active || !scrollRef) return
+
+    const strip = scrollRef.getBoundingClientRect()
+    const speed = autoscrollSpeed(drag.pointerX, strip.left, strip.right)
+
+    if (speed !== 0) {
+      scrollRef.scrollLeft += speed
+      syncScroll()
+    }
+
+    autoscrollFrame = requestAnimationFrame(tickAutoscroll)
+  }
+
+  function startAutoscroll() {
+    stopAutoscroll()
+    autoscrollFrame = requestAnimationFrame(tickAutoscroll)
+  }
+
+  function applyPlaceholderIndex(nextIndex: number) {
+    const id = drag.draggedId
+    if (!id) return
+    const next = movePlaceholder(drag.draftOrder, id, nextIndex)
+    setDrag({
+      draftOrder: next,
+      placeholderIndex: nextIndex,
+    })
+  }
+
+  function updateInsertIndex() {
+    if (!drag.active || !dragLayout) return
+    const draggedId = drag.draggedId
+    if (!draggedId) return
+    const nextIndex = insertIndexFromVirtualLayout(
+      drag.pointerX,
+      drag.draftOrder,
+      draggedId,
+      drag.placeholderIndex,
+      dragLayout,
+    )
+    if (nextIndex === drag.placeholderIndex) return
+    applyPlaceholderIndex(nextIndex)
+  }
+
+  function startDrag(id: string) {
+    const order = tabIds()
+    const index = order.indexOf(id)
+    const pending = gesture.pending
+    if (index === -1 || !pending || !listRef || !scrollRef) return
+
+    dragLayout = captureTabDragLayout(listRef, order)
+    dragPreview = createTabDragPreview(pending.element)
+    dragPointerId = pending.pointerId
+    setGesture("pending", undefined)
+
+    setDrag({
+      active: true,
+      draggedId: id,
+      placeholderIndex: index,
+      draftOrder: order,
+      initialOrder: order,
+      draggedWidth: pending.width,
+      pointerX: pending.startX,
+      grabOffsetX: pending.grabOffsetX,
+      floaterTop: pending.startY - pending.grabOffsetY,
+    })
+    setPressedId(undefined)
+    setStripScrollLeft(scrollRef.scrollLeft)
+    startAutoscroll()
+  }
+
+  function endDrag(commit: boolean) {
+    const initial = drag.initialOrder
+    const final = drag.draftOrder
+    const moved = drag.active
+
+    if (commit && moved && draftOrderChanged(initial, final)) {
+      props.onReorder(final)
+    }
+
+    if (moved) setSuppressNavigation(true)
+
+    setDrag({
+      active: false,
+      draggedId: undefined,
+      placeholderIndex: 0,
+      draftOrder: [],
+      initialOrder: [],
+      draggedWidth: 0,
+      pointerX: 0,
+      grabOffsetX: 0,
+      floaterTop: 0,
+    })
+
+    dragLayout = undefined
+    dragPreview = undefined
+    dragPointerId = undefined
+    setGesture("pending", undefined)
+    setPressedId(undefined)
+    stopAutoscroll()
     refreshOverflow()
+    requestAnimationFrame(() => setSuppressNavigation(false))
+  }
+
+  function onPointerDown(id: string, event: PointerEvent) {
+    if (event.button !== 0 || drag.active) return
+    if (!canStartTabDrag(event.pointerType)) return
+    if (isTabCloseTarget(event.target)) return
+    const target = event.currentTarget as HTMLDivElement
+    const tabEl = target.matches("[data-titlebar-tab]")
+      ? target
+      : target.querySelector<HTMLDivElement>("[data-titlebar-tab]")
+    if (!tabEl) return
+    if (!tabEl.querySelector('[data-slot="tab-link"]')) return
+    const tab = props.tabs.find((item) => tabKey(item) === id)
+    if (!tab) return
+    const pointer = captureTabPointerDown(tabEl, event.clientX, event.clientY)
+    setSuppressNavigation(true)
+    props.onNavigate(tab, tabEl)
+    setPressedId(id)
+    setGesture("pending", {
+      id,
+      pointerId: event.pointerId,
+      ...pointer,
+    })
+  }
+
+  function onPointerMove(event: PointerEvent) {
+    const pending = gesture.pending
+    if (pending && event.pointerId !== pending.pointerId) return
+    if (drag.active && dragPointerId !== undefined && event.pointerId !== dragPointerId) return
+    if (!isPrimaryPointerPressed(event.buttons)) {
+      if (drag.active) endDrag(true)
+      if (pending) {
+        setGesture("pending", undefined)
+        setPressedId(undefined)
+        requestAnimationFrame(() => setSuppressNavigation(false))
+      }
+      return
+    }
+
+    if (pending && !drag.active) {
+      if (pointerDistance(pending.startX, pending.startY, event.clientX, event.clientY) < ACTIVATION_DISTANCE) return
+      startDrag(pending.id)
+    }
+
+    if (!drag.active) return
+
+    setDrag("pointerX", event.clientX)
+    syncScroll()
+  }
+
+  function onPointerUp(event: PointerEvent) {
+    if (drag.active) {
+      if (dragPointerId !== undefined && event.pointerId !== dragPointerId) return
+      setDrag("pointerX", event.clientX)
+      syncScroll()
+      endDrag(true)
+      return
+    }
+
+    const pending = gesture.pending
+    if (pending && event.pointerId !== pending.pointerId) return
+
+    setGesture("pending", undefined)
+    setPressedId(undefined)
+    requestAnimationFrame(() => setSuppressNavigation(false))
+  }
+
+  function onPointerCancel(event: PointerEvent) {
+    if (drag.active) {
+      if (dragPointerId !== undefined && event.pointerId !== dragPointerId) return
+      endDrag(false)
+      return
+    }
+
+    if (!gesture.pending) return
+    if (gesture.pending.pointerId !== event.pointerId) return
+    setGesture("pending", undefined)
+    setPressedId(undefined)
+    requestAnimationFrame(() => setSuppressNavigation(false))
+  }
+
+  onMount(() => {
+    const cleanups = [
+      makeEventListener(window, "pointermove", onPointerMove),
+      makeEventListener(window, "pointerup", onPointerUp),
+      makeEventListener(window, "pointercancel", onPointerCancel),
+    ]
+    refreshOverflow()
+    onCleanup(() => cleanups.forEach((cleanup) => cleanup()))
   })
 
+  onCleanup(stopAutoscroll)
   onCleanup(() => {
     if (resizeFrame !== undefined) cancelAnimationFrame(resizeFrame)
   })
@@ -205,54 +424,50 @@ export function TitlebarTabStrip(props: {
     refreshOverflow()
   })
 
-  return (
-    <div data-slot="titlebar-tabs" class="relative min-w-0">
-      <div
-        data-slot="titlebar-tabs-scroll"
-        class="flex min-w-0 flex-row items-center gap-1.5 overflow-x-auto no-scrollbar [app-region:no-drag]"
-        ref={scrollRef}
-      >
-        <DragDropProvider
-          sensors={[
-            PointerSensor.configure({
-              activationConstraints: [new PointerActivationConstraints.Distance({ value: 4 })],
-              preventActivation: (event) =>
-                !canStartTabDrag(event.pointerType) ||
-                isTabCloseTarget(event.target) ||
-                (event.target instanceof Element && !!event.target.closest('[contenteditable="true"]')),
-            }),
-          ]}
-          modifiers={[RestrictToHorizontalAxis, RestrictToElement.configure({ element: () => listRef })]}
-          plugins={(defaults) => [
-            ...defaults.filter((plugin) => plugin !== Accessibility),
-            AutoScroller.configure({ acceleration: 8, threshold: { x: 0.05, y: 0 } }),
-            Feedback.configure({ dropAnimation: null }),
-          ]}
-          onDragStart={(event) => {
-            const source = event.operation.source
-            if (!source) return
-            const tab = props.tabs.find((item) => tabKey(item) === source.id.toString())
-            if (!tab) return
-            const tabEl = source.element?.querySelector<HTMLDivElement>("[data-titlebar-tab]")
-            props.onNavigate(tab, tabEl ?? undefined)
-          }}
-          onDragEnd={(event) => {
-            const current = tabIds()
-            const source = event.operation.source
-            if (event.canceled || !isSortable(source)) return
+  createEffect(() => {
+    if (!drag.active || !scrollRef) return
+    onCleanup(makeEventListener(scrollRef, "scroll", syncScroll))
+  })
 
-            const { initialIndex, index } = source
-            if (initialIndex !== index) {
-              props.onReorder(arrayMove(current, source.initialIndex, source.index))
-            }
-          }}
+  const floaterStyle = () => {
+    stripScrollLeft()
+    const strip = scrollRef?.getBoundingClientRect()
+    const left = strip
+      ? clampFloaterLeft(drag.pointerX - drag.grabOffsetX, drag.draggedWidth, strip.left, strip.right)
+      : drag.pointerX - drag.grabOffsetX
+
+    return {
+      position: "fixed" as const,
+      top: `${drag.floaterTop}px`,
+      left: `${left}px`,
+      width: `${drag.draggedWidth}px`,
+      "z-index": "10000",
+      "pointer-events": "none" as const,
+    }
+  }
+
+  const draggedTab = createMemo(() => {
+    const id = drag.draggedId
+    if (!id) return
+    return props.tabs.find((tab) => tabKey(tab) === id)
+  })
+
+  return (
+    <>
+      <div data-slot="titlebar-tabs" class="relative min-w-0">
+        <div
+          data-slot="titlebar-tabs-scroll"
+          class="flex min-w-0 flex-row items-center gap-1.5 overflow-x-auto no-scrollbar [app-region:no-drag]"
+          ref={scrollRef}
         >
-          <div data-titlebar-tab-list class="flex w-full min-w-0 flex-row items-center" ref={listRef}>
-            <For each={props.tabs}>
+          <div data-titlebar-tab-list class="flex min-w-0 flex-row items-center" ref={listRef}>
+            <For each={displayTabs()}>
               {(tab, index) => {
                 const id = tabKey(tab)
                 let ref!: HTMLDivElement
                 useTabShortcut(index, () => props.onNavigate(tab, ref))
+
+                const dragged = () => drag.active && drag.draggedId === id
                 const serverCtx = createMemo(() => {
                   if (tab.type !== "session") return
                   const conn = global.servers.list().find((item) => ServerConnection.key(item) === tab.server)
@@ -264,50 +479,68 @@ export function TitlebarTabStrip(props: {
                     <SessionTabSlot
                       tab={tab}
                       id={id}
-                      index={index}
                       active={() => props.currentTab() === tab}
                       activeServerKey={props.activeServerKey}
                       forceTruncate={props.forceTruncate}
+                      dragActive={drag.active}
+                      dragged={dragged}
+                      pressed={() => pressedId() === id}
                       serverCtx={serverCtx}
-                      onNavigate={(element) => {
-                        ref = element
-                        props.onNavigate(tab, element)
+                      suppressNavigation={() => suppressNavigation()}
+                      onPointerDown={(event) => {
+                        if (dragged()) return
+                        onPointerDown(id, event)
                       }}
+                      onNavigate={(element) => props.onNavigate(tab, element)}
                       onClose={() => props.onClose(tab)}
                     />
                   )
                 }
 
                 return (
-                  <DraftTabSlot
-                    tab={tab}
-                    id={id}
-                    index={index}
-                    active={() => props.currentTab() === tab}
-                    title={language.t("command.session.new")}
-                    onNavigate={(element) => {
-                      ref = element
-                      props.onNavigate(tab, element)
+                  <DraftTabItem
+                    tabKey={id}
+                    dragActive={drag.active}
+                    onPointerDown={(event) => {
+                      if (dragged()) return
+                      onPointerDown(id, event)
                     }}
+                    ref={ref}
+                    href={tabHref(tab)}
+                    title={language.t("command.session.new")}
+                    onNavigate={() => props.onNavigate(tab, ref)}
                     onClose={() => props.onClose(tab)}
+                    suppressNavigation={() => suppressNavigation()}
+                    active={props.currentTab() === tab}
+                    pressed={pressedId() === id}
+                    hidden={dragged()}
                   />
                 )
               }}
             </For>
           </div>
-        </DragDropProvider>
+        </div>
+        <div
+          data-slot="titlebar-tabs-fade-left"
+          aria-hidden="true"
+          class="pointer-events-none absolute inset-y-0 left-0 z-10 w-6 bg-[linear-gradient(to_right,var(--v2-background-bg-deep),transparent)]"
+        />
+        <div
+          data-slot="titlebar-tabs-fade-right"
+          aria-hidden="true"
+          class="pointer-events-none absolute inset-y-0 right-0 z-10 w-6 bg-[linear-gradient(to_left,var(--v2-background-bg-deep),transparent)]"
+        />
       </div>
-      <div
-        data-slot="titlebar-tabs-fade-left"
-        aria-hidden="true"
-        class="pointer-events-none absolute inset-y-0 left-0 z-10 w-6 bg-[linear-gradient(to_right,var(--v2-background-bg-deep),transparent)]"
-      />
-      <div
-        data-slot="titlebar-tabs-fade-right"
-        aria-hidden="true"
-        class="pointer-events-none absolute inset-y-0 right-0 z-10 w-6 bg-[linear-gradient(to_left,var(--v2-background-bg-deep),transparent)]"
-      />
-    </div>
+      <Show when={drag.active && draggedTab() && dragPreview}>
+        {(_) => (
+          <Portal>
+            <div data-titlebar-tab-preview style={floaterStyle()}>
+              {dragPreview}
+            </div>
+          </Portal>
+        )}
+      </Show>
+    </>
   )
 }
 

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

@@ -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,30 +125,30 @@ 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"]
+type Endpoint0_12Request = Parameters<RawClient["server.session"]["session.events"]>[0]
+type Endpoint0_12Input = {
+  readonly sessionID: Endpoint0_12Request["params"]["sessionID"]
+  readonly after?: Endpoint0_12Request["query"]["after"]
 }
-const Endpoint0_13 = (raw: RawClient["server.session"]) => (input: Endpoint0_13Input) =>
+const Endpoint0_12 = (raw: RawClient["server.session"]) => (input: Endpoint0_12Input) =>
   Stream.unwrap(
     raw["session.events"]({ params: { sessionID: input.sessionID }, query: { after: input.after } }).pipe(
       Effect.mapError(mapClientError),
@@ -162,17 +156,17 @@ const Endpoint0_13 = (raw: RawClient["server.session"]) => (input: Endpoint0_13I
     ),
   )
 
-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) =>
+type Endpoint0_13Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint0_13Input = { readonly sessionID: Endpoint0_13Request["params"]["sessionID"] }
+const Endpoint0_13 = (raw: RawClient["server.session"]) => (input: Endpoint0_13Input) =>
   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"]
+type Endpoint0_14Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint0_14Input = {
+  readonly sessionID: Endpoint0_14Request["params"]["sessionID"]
+  readonly messageID: Endpoint0_14Request["params"]["messageID"]
 }
-const Endpoint0_15 = (raw: RawClient["server.session"]) => (input: Endpoint0_15Input) =>
+const Endpoint0_14 = (raw: RawClient["server.session"]) => (input: Endpoint0_14Input) =>
   raw["session.message"]({ params: { sessionID: input.sessionID, messageID: input.messageID } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
@@ -181,20 +175,19 @@ const Endpoint0_15 = (raw: RawClient["server.session"]) => (input: Endpoint0_15I
 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),
+  events: Endpoint0_12(raw),
+  interrupt: Endpoint0_13(raw),
+  message: Endpoint0_14(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,
@@ -199,17 +198,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 }>(
           {

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 = {
@@ -574,6 +572,7 @@ export type SessionsContextOutput = {
         >
         readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
         readonly finish?: string
+        readonly settlement?: "completed" | "failed" | "interrupted"
         readonly cost?: number
         readonly tokens?: {
           readonly input: number
@@ -797,6 +796,14 @@ export type SessionsEventsOutput =
         readonly error: { readonly type: "unknown"; readonly message: string }
       }
     }
+  | {
+      readonly id: string
+      readonly metadata?: { readonly [x: string]: unknown }
+      readonly type: "session.next.step.interrupted"
+      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 id: string
       readonly metadata?: { readonly [x: string]: unknown }
@@ -1191,6 +1198,7 @@ export type SessionsMessageOutput = {
         >
         readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
         readonly finish?: string
+        readonly settlement?: "completed" | "failed" | "interrupted"
         readonly cost?: number
         readonly tokens?: {
           readonly input: number

packages/client/test/effect.test.ts

@@ -37,11 +37,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     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 +50,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") }),
     })
@@ -80,11 +74,10 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
       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, events, message }
   }).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")

packages/client/test/promise.test.ts

@@ -32,7 +32,6 @@ test("session methods use the public HTTP contract", async () => {
       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 +39,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({
@@ -61,7 +59,6 @@ test("session methods use the public HTTP contract", async () => {
   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([])
@@ -69,7 +66,6 @@ test("session methods use the public HTTP contract", async () => {
   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"],
@@ -81,7 +77,7 @@ test("session methods use the public HTTP contract", async () => {
     ["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" },

packages/core/src/oauth/page.ts

@@ -1,276 +0,0 @@
-// Branded HTML pages for local OAuth callback servers.
-//
-// These are served by the loopback HTTP servers that finish an OAuth exchange
-// (MCP, Codex/ChatGPT, xAI, Snowflake, DigitalOcean, ...). The functions return
-// a fully self-contained HTML string with no external assets, so they work
-// offline and drop into any transport (`res.end(...)`, Effect `response.end`,
-// etc.).
-//
-// The visual language mirrors the opencode app: the design tokens are a curated
-// subset of the OC-2 semantic tokens in `packages/ui/src/styles/theme.css`, and
-// the wordmark is the same geometry as `packages/ui/src/components/logo.tsx`.
-// Keep this file in sync with those sources when the brand changes.
-
-export interface CallbackPageOptions {
-  /** Friendly integration name shown as a subtitle, e.g. "xAI", "Snowflake", "MCP". */
-  provider?: string
-  /** Attempt to close the window shortly after success. Defaults to true. */
-  autoClose?: boolean
-}
-
-export function success(options?: CallbackPageOptions) {
-  const provider = options?.provider
-  return renderDocument({
-    title: "Authorization successful",
-    body: renderCard({
-      status: "success",
-      headline: "Authorization successful",
-      message: provider ? `opencode is now connected to ${escapeHtml(provider)}.` : "opencode is now authorized.",
-      footnote: "You can close this window and return to opencode.",
-    }),
-    script: options?.autoClose === false ? undefined : AUTO_CLOSE_SCRIPT,
-  })
-}
-
-export function error(detail: string, options?: CallbackPageOptions) {
-  const provider = options?.provider
-  return renderDocument({
-    title: "Authorization failed",
-    body: renderCard({
-      status: "error",
-      headline: "Authorization failed",
-      message: provider
-        ? `opencode couldn't finish connecting to ${escapeHtml(provider)}.`
-        : "opencode couldn't complete authorization.",
-      detail,
-      footnote: "Close this window and try again from opencode.",
-    }),
-  })
-}
-
-export interface BootstrapOptions {
-  /** Same-origin path the in-browser script POSTs the parsed callback to. */
-  tokenPath: string
-  provider?: string
-}
-
-// For flows where the credential arrives in the URL fragment (implicit grant),
-// the browser must relay it back to the loopback server. This renders a pending
-// page whose script reads the fragment, POSTs it to `tokenPath`, then resolves
-// to the success or error state in place.
-export function bootstrap(options: BootstrapOptions) {
-  return renderDocument({
-    title: "Finishing sign-in",
-    body: renderCard({
-      status: "pending",
-      headline: "Finishing sign-in",
-      message: options.provider
-        ? `Completing your ${escapeHtml(options.provider)} authorization.`
-        : "Completing authorization.",
-      footnote: "You can close this window once sign-in finishes.",
-    }),
-    script: bootstrapScript(options),
-  })
-}
-
-export * as OauthCallbackPage from "./page"
-
-type Status = "pending" | "success" | "error"
-
-function renderCard(input: { status: Status; headline: string; message: string; detail?: string; footnote: string }) {
-  const detail = input.detail?.trim()
-  return `<main class="card" id="oc-card" data-status="${input.status}" role="status" aria-live="polite">
-      <div class="brand">${WORDMARK}</div>
-      <div class="status" aria-hidden="true">
-        <span class="icon icon-pending">${ICON_SPINNER}</span>
-        <span class="icon icon-success">${ICON_CHECK}</span>
-        <span class="icon icon-error">${ICON_CROSS}</span>
-      </div>
-      <h1 class="headline" id="oc-headline">${escapeHtml(input.headline)}</h1>
-      <p class="message" id="oc-message">${input.message}</p>
-      <pre class="detail" id="oc-detail"${detail ? "" : " hidden"}>${detail ? escapeHtml(detail) : ""}</pre>
-      <p class="footnote" id="oc-footnote">${escapeHtml(input.footnote)}</p>
-    </main>`
-}
-
-function renderDocument(input: { title: string; body: string; script?: string }) {
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="robots" content="noindex" />
-    <title>${escapeHtml(input.title)} · opencode</title>
-    <style>${STYLES}</style>
-  </head>
-  <body>
-    ${input.body}${input.script ? `\n    <script>${input.script}</script>` : ""}
-  </body>
-</html>`
-}
-
-const AUTO_CLOSE_SCRIPT = `setTimeout(function(){try{window.close()}catch(e){}},2500)`
-
-function bootstrapScript(options: BootstrapOptions) {
-  return `var PROVIDER=${scriptString(options.provider ?? "")};
-var TOKEN_URL=new URL(${scriptString(options.tokenPath)},window.location.origin).href;
-(function(){
-  var card=document.getElementById("oc-card"),headline=document.getElementById("oc-headline"),message=document.getElementById("oc-message"),detail=document.getElementById("oc-detail"),footnote=document.getElementById("oc-footnote");
-  function fail(text){card.dataset.status="error";headline.textContent="Authorization failed";message.textContent=PROVIDER?("opencode couldn't finish connecting to "+PROVIDER+"."):"opencode couldn't complete authorization.";if(text){detail.textContent=text;detail.hidden=false}footnote.textContent="Close this window and try again from opencode."}
-  function ok(){card.dataset.status="success";headline.textContent="Authorization successful";message.textContent=PROVIDER?("opencode is now connected to "+PROVIDER+"."):"opencode is now authorized.";detail.hidden=true;footnote.textContent="You can close this window and return to opencode.";setTimeout(function(){try{window.close()}catch(e){}},2500)}
-  try{
-    var hash=new URLSearchParams((window.location.hash||"").slice(1));
-    var search=new URLSearchParams(window.location.search||"");
-    var err=hash.get("error")||search.get("error");
-    var errDescription=hash.get("error_description")||search.get("error_description");
-    var body=err?{error:err,error_description:errDescription||""}:{access_token:hash.get("access_token")||"",expires_in:hash.get("expires_in")||"0",state:hash.get("state")||""};
-    fetch(TOKEN_URL,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(body)}).then(function(res){
-      if(!res.ok)return res.text().catch(function(){return""}).then(function(t){throw new Error(t||("callback failed ("+res.status+")"))});
-      if(err){fail(errDescription||err);return}
-      ok();
-    }).catch(function(e){fail(String(e&&e.message?e.message:e))});
-  }catch(e){fail(String(e&&e.message?e.message:e))}
-})()`
-}
-
-function scriptString(value: string) {
-  return JSON.stringify(value).replaceAll("<", "\\u003c")
-}
-
-function escapeHtml(value: string) {
-  return value
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&#39;")
-}
-
-// Curated subset of OC-2 tokens (packages/ui/src/styles/theme.css). Default is
-// light; dark applies via prefers-color-scheme. The [data-theme] selectors let a
-// host force a scheme without changing the default.
-const LIGHT_VARS = `
-    --oc-bg: #f8f8f8;
-    --oc-card: #fcfcfc;
-    --oc-text-strong: #171717;
-    --oc-text-base: #6f6f6f;
-    --oc-text-weak: #8f8f8f;
-    --oc-border-weak: #e5e5e5;
-    --oc-icon-strong: #171717;
-    --oc-icon-base: #8f8f8f;
-    --oc-icon-weak: #dbdbdb;
-    --oc-success: #2dba26;
-    --oc-error: #ed4831;
-    --oc-detail-bg: #fff8f6;
-    --oc-detail-border: #fdc3b7;
-    --oc-shadow: 0 16px 48px -6px rgba(0,0,0,.10), 0 6px 12px -2px rgba(0,0,0,.05), 0 1px 2px rgba(0,0,0,.06);`
-
-const DARK_VARS = `
-    --oc-bg: #101010;
-    --oc-card: #161616;
-    --oc-text-strong: rgba(255,255,255,.936);
-    --oc-text-base: rgba(255,255,255,.618);
-    --oc-text-weak: rgba(255,255,255,.422);
-    --oc-border-weak: #282828;
-    --oc-icon-strong: #ededed;
-    --oc-icon-base: #7e7e7e;
-    --oc-icon-weak: #343434;
-    --oc-success: #12c905;
-    --oc-error: #fc533a;
-    --oc-detail-bg: #28110c;
-    --oc-detail-border: #6a1206;
-    --oc-shadow: 0 16px 48px -6px rgba(0,0,0,.55), 0 6px 12px -2px rgba(0,0,0,.35), 0 1px 2px rgba(0,0,0,.4);`
-
-const STYLES = `
-  :root { color-scheme: light dark;${LIGHT_VARS}
-    --oc-font-sans: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-    --oc-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
-  }
-  @media (prefers-color-scheme: dark) { :root:not([data-theme="light"]) {${DARK_VARS} } }
-  :root[data-theme="dark"] {${DARK_VARS} }
-  :root[data-theme="light"] {${LIGHT_VARS} }
-
-  * { box-sizing: border-box; }
-  html, body { margin: 0; height: 100%; }
-  body {
-    min-height: 100vh;
-    display: grid;
-    place-items: center;
-    padding: 24px;
-    background: var(--oc-bg);
-    color: var(--oc-text-base);
-    font-family: var(--oc-font-sans);
-    line-height: 1.5;
-    -webkit-font-smoothing: antialiased;
-    text-rendering: optimizeLegibility;
-  }
-  .card {
-    width: min(100%, 25rem);
-    padding: 2.25rem 2rem 1.75rem;
-    background: var(--oc-card);
-    border: 1px solid var(--oc-border-weak);
-    border-radius: 14px;
-    box-shadow: var(--oc-shadow);
-    text-align: center;
-  }
-  .brand { display: flex; justify-content: center; margin-bottom: 1.75rem; }
-  .brand svg { height: 19px; width: auto; }
-  .status { display: flex; justify-content: center; margin-bottom: 1.125rem; }
-  .icon { display: none; line-height: 0; }
-  .icon svg { display: block; }
-  .card[data-status="pending"] .icon-pending,
-  .card[data-status="success"] .icon-success,
-  .card[data-status="error"] .icon-error { display: block; }
-  .icon-success { color: var(--oc-success); }
-  .icon-error { color: var(--oc-error); }
-  .icon-pending { color: var(--oc-text-weak); }
-  .headline { margin: 0; font-size: 1.1875rem; font-weight: 500; line-height: 1.3; letter-spacing: -0.012em; color: var(--oc-text-strong); }
-  .message { margin: 0.5rem 0 0; font-size: 0.9375rem; color: var(--oc-text-base); }
-  .detail {
-    margin: 1.25rem 0 0;
-    padding: 0.75rem 0.875rem;
-    text-align: left;
-    font-family: var(--oc-font-mono);
-    font-size: 0.8125rem;
-    line-height: 1.55;
-    color: var(--oc-text-strong);
-    background: var(--oc-detail-bg);
-    border: 1px solid var(--oc-detail-border);
-    border-radius: 8px;
-    white-space: pre-wrap;
-    word-break: break-word;
-    max-height: 9.5rem;
-    overflow: auto;
-  }
-  .detail[hidden] { display: none; }
-  .footnote { margin: 1.5rem 0 0; font-size: 0.8125rem; color: var(--oc-text-weak); }
-  .spinner { animation: oc-spin 0.8s linear infinite; transform-origin: center; }
-  @keyframes oc-spin { to { transform: rotate(360deg); } }
-  @media (prefers-reduced-motion: reduce) { .spinner { animation: none; } }
-`
-
-// opencode wordmark — same path geometry as packages/ui/src/components/logo.tsx (Logo).
-const WORDMARK = `<svg class="wordmark" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 234 42" fill="none" aria-label="opencode" role="img">
-        <path d="M18 30H6V18H18V30Z" fill="var(--oc-icon-weak)" />
-        <path d="M18 12H6V30H18V12ZM24 36H0V6H24V36Z" fill="var(--oc-icon-base)" />
-        <path d="M48 30H36V18H48V30Z" fill="var(--oc-icon-weak)" />
-        <path d="M36 30H48V12H36V30ZM54 36H36V42H30V6H54V36Z" fill="var(--oc-icon-base)" />
-        <path d="M84 24V30H66V24H84Z" fill="var(--oc-icon-weak)" />
-        <path d="M84 24H66V30H84V36H60V6H84V24ZM66 18H78V12H66V18Z" fill="var(--oc-icon-base)" />
-        <path d="M108 36H96V18H108V36Z" fill="var(--oc-icon-weak)" />
-        <path d="M108 12H96V36H90V6H108V12ZM114 36H108V12H114V36Z" fill="var(--oc-icon-base)" />
-        <path d="M144 30H126V18H144V30Z" fill="var(--oc-icon-weak)" />
-        <path d="M144 12H126V30H144V36H120V6H144V12Z" fill="var(--oc-icon-strong)" />
-        <path d="M168 30H156V18H168V30Z" fill="var(--oc-icon-weak)" />
-        <path d="M168 12H156V30H168V12ZM174 36H150V6H174V36Z" fill="var(--oc-icon-strong)" />
-        <path d="M198 30H186V18H198V30Z" fill="var(--oc-icon-weak)" />
-        <path d="M198 12H186V30H198V12ZM204 36H180V6H198V0H204V36Z" fill="var(--oc-icon-strong)" />
-        <path d="M234 24V30H216V24H234Z" fill="var(--oc-icon-weak)" />
-        <path d="M216 12V18H228V12H216ZM234 24H216V30H234V36H210V6H234V24Z" fill="var(--oc-icon-strong)" />
-      </svg>`
-
-const ICON_CHECK = `<svg viewBox="0 0 24 24" width="30" height="30" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9" /><path d="m8.5 12.5 2.4 2.4 4.6-5.4" /></svg>`
-
-const ICON_CROSS = `<svg viewBox="0 0 24 24" width="30" height="30" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9" /><path d="m9 9 6 6m0-6-6 6" /></svg>`
-
-const ICON_SPINNER = `<svg class="spinner" viewBox="0 0 24 24" width="30" height="30" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><circle cx="12" cy="12" r="9" opacity="0.2" /><path d="M21 12a9 9 0 0 0-9-9" /></svg>`

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

@@ -7,7 +7,6 @@ import { Credential } from "../../credential"
 import { InstallationVersion } from "../../installation/version"
 import { Integration } from "../../integration"
 import { ModelV2 } from "../../model"
-import { OauthCallbackPage } from "../../oauth/page"
 import { ProviderV2 } from "../../provider"
 import type { PluginInternal } from "../internal"
 
@@ -59,21 +58,17 @@ const browser = {
         const value = url.searchParams.get("code")
         if (error) {
           Effect.runFork(Deferred.fail(code, new Error(error)))
-          response
-            .writeHead(400, { "Content-Type": "text/html" })
-            .end(OauthCallbackPage.error(error, { provider: "ChatGPT" }))
+          response.writeHead(400, { "Content-Type": "text/html" }).end(errorPage(error))
           return
         }
         if (!value || url.searchParams.get("state") !== state) {
           const message = value ? "Invalid OAuth state" : "Missing authorization code"
           Effect.runFork(Deferred.fail(code, new Error(message)))
-          response
-            .writeHead(400, { "Content-Type": "text/html" })
-            .end(OauthCallbackPage.error(message, { provider: "ChatGPT" }))
+          response.writeHead(400, { "Content-Type": "text/html" }).end(errorPage(message))
           return
         }
         Effect.runFork(Deferred.succeed(code, value))
-        response.writeHead(200, { "Content-Type": "text/html" }).end(OauthCallbackPage.success({ provider: "ChatGPT" }))
+        response.writeHead(200, { "Content-Type": "text/html" }).end(successPage)
       })
       yield* Effect.callback<void, Error>((resume) => {
         server.once("error", (error) => resume(Effect.fail(error)))
@@ -290,3 +285,8 @@ function claim(token: string) {
     return
   }
 }
+
+const successPage =
+  "<!doctype html><title>OpenCode</title><h1>Authorization successful</h1><p>You can close this window.</p>"
+const errorPage = (message: string) =>
+  `<!doctype html><title>OpenCode</title><h1>Authorization failed</h1><p>${message.replace(/[&<>"']/g, "")}</p>`

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)

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/message-updater.ts

@@ -210,6 +210,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.time.completed = event.data.timestamp
           draft.finish = event.data.finish
+          draft.settlement = "completed"
           draft.cost = event.data.cost
           draft.tokens = event.data.tokens
           if (event.data.snapshot || event.data.files)
@@ -224,9 +225,16 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.time.completed = event.data.timestamp
           draft.finish = "error"
+          draft.settlement = "failed"
           draft.error = event.data.error
         })
       },
+      "session.next.step.interrupted": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          draft.time.completed = event.data.timestamp
+          draft.settlement = "interrupted"
+        })
+      },
       "session.next.text.started": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.content.push(

packages/core/src/session/projector.ts

@@ -381,6 +381,7 @@ export const layer = Layer.effectDiscard(
     yield* events.project(SessionEvent.Step.Started, (event) => run(db, event))
     yield* events.project(SessionEvent.Step.Ended, (event) => run(db, event))
     yield* events.project(SessionEvent.Step.Failed, (event) => run(db, event))
+    yield* events.project(SessionEvent.Step.Interrupted, (event) => run(db, event))
     yield* events.project(SessionEvent.Text.Started, (event) => run(db, event))
     yield* events.project(SessionEvent.Text.Ended, (event) => run(db, event))
     yield* events.project(SessionEvent.Tool.Input.Started, (event) => run(db, event))

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

@@ -290,6 +290,7 @@ export const layer = Layer.effect(
           if (settled._tag === "Failure" && isQuestionRejected(settled.cause)) {
             yield* FiberSet.clear(toolFibers)
             yield* withPublication(publisher.failUnsettledTools("Tool execution interrupted"))
+            yield* withPublication(publisher.interruptAssistant())
             return yield* Effect.interrupt
           }
           if (
@@ -298,8 +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("Provider turn interrupted"))
+            yield* withPublication(publisher.interruptAssistant())
           }
           if (settled._tag === "Failure" && !Cause.hasInterrupts(settled.cause)) {
             const failure = Cause.squash(settled.cause)
@@ -307,7 +307,7 @@ export const layer = Layer.effect(
             yield* withPublication(publisher.failUnsettledTools(`Tool execution failed: ${message}`))
           }
           const stepSettlement = publisher.stepSettlement()
-          if (stepSettlement && !publisher.hasProviderError()) {
+          if (stepSettlement && !publisher.hasProviderError() && !publisher.hasAssistantSettled()) {
             const endSnapshot = yield* snapshots.capture()
             const files =
               startSnapshot && endSnapshot

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

@@ -66,15 +66,13 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
   >()
   const timestamp = DateTime.now
   let assistantMessageID: SessionMessage.ID | undefined
-  let assistantActive = false
-  let assistantFailed = false
+  let assistantSettled = false
   let providerFailed = false
-  let stepSettlement: { readonly finish: string; readonly tokens: ReturnType<typeof tokens> } | undefined
+  let stepSettlement: { readonly finish: SessionMessage.Finish; readonly tokens: ReturnType<typeof tokens> } | undefined
 
   const startAssistant = Effect.fnUntraced(function* () {
     if (assistantMessageID !== undefined) return assistantMessageID
     assistantMessageID = SessionMessage.ID.create()
-    assistantActive = true
     yield* events.publish(SessionEvent.Step.Started, {
       ...input,
       assistantMessageID,
@@ -196,20 +194,39 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     yield* flushFragments()
   })
 
-  const failAssistant = Effect.fnUntraced(function* (message: string) {
-    if (assistantFailed) return
+  const settleAssistant = Effect.fnUntraced(function* (
+    publish: (assistantMessageID: SessionMessage.ID) => Effect.Effect<void>,
+  ) {
+    if (assistantSettled) 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: { type: "unknown", message },
-    })
+    assistantSettled = true
+    yield* publish(assistantMessageID)
   })
 
+  const failAssistant = (message: string) =>
+    settleAssistant((assistantMessageID) =>
+      Effect.gen(function* () {
+        yield* events.publish(SessionEvent.Step.Failed, {
+          sessionID: input.sessionID,
+          timestamp: yield* timestamp,
+          assistantMessageID,
+          error: { type: "unknown", message },
+        })
+      }),
+    )
+
+  const interruptAssistant = () =>
+    settleAssistant((assistantMessageID) =>
+      Effect.gen(function* () {
+        yield* events.publish(SessionEvent.Step.Interrupted, {
+          sessionID: input.sessionID,
+          timestamp: yield* timestamp,
+          assistantMessageID,
+        })
+      }),
+    )
+
   const failUnsettledTools = Effect.fn("SessionRunner.failUnsettledTools")(function* (
     message: string,
     hostedOnly = false,
@@ -395,7 +412,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
       }
       case "step-finish":
         yield* flush()
-        assistantActive = false
         if (stepSettlement) return yield* Effect.die("Duplicate step finish")
         stepSettlement = { finish: event.reason, tokens: tokens(event.usage) }
         return
@@ -412,9 +428,10 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     publish,
     flush,
     failAssistant,
+    interruptAssistant,
     failUnsettledTools,
-    hasActiveAssistant: () => assistantActive,
     hasAssistantStarted: () => assistantMessageID !== undefined,
+    hasAssistantSettled: () => assistantSettled,
     hasProviderError: () => providerFailed,
     stepSettlement: () => stepSettlement,
     startAssistant,

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

@@ -70,7 +70,7 @@ 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 reuseProviderMetadata = sameModel && message.error === undefined && message.settlement !== "interrupted"
   const content = message.content.flatMap((item): ContentPart[] => {
     if (item.type === "text") return [{ type: "text", text: item.text }]
     if (item.type === "reasoning")

packages/core/test/oauth-page.test.ts

@@ -1,15 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { OauthCallbackPage } from "../src/oauth/page"
-
-describe("OauthCallbackPage", () => {
-  test("escapes bootstrap options embedded in the inline script", () => {
-    const html = OauthCallbackPage.bootstrap({
-      provider: `xAI</script><script>alert("provider")</script>`,
-      tokenPath: `/token</script><script>alert("path")</script>`,
-    })
-
-    expect(html.match(/<\/script>/g)).toHaveLength(1)
-    expect(html).toContain(`xAI\\u003c/script>\\u003cscript>alert(\\\"provider\\\")\\u003c/script>`)
-    expect(html).toContain(`/token\\u003c/script>\\u003cscript>alert(\\\"path\\\")\\u003c/script>`)
-  })
-})

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,7 +327,7 @@ Recent work
     ])
   })
 
-  test("drops provider-native continuation metadata from failed assistant turns", () => {
+  test("drops provider-native continuation metadata from interrupted assistant turns", () => {
     const messages = toLLMMessages(
       [
         SessionMessage.Assistant.make({
@@ -361,8 +361,7 @@ Recent work
               time: { created, completed: created },
             }),
           ],
-          finish: "error",
-          error: { type: "unknown", message: "Provider turn interrupted" },
+          settlement: "interrupted",
           time: { created, completed: created },
         }),
       ],

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

@@ -254,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,6 +519,7 @@ const verifyPartialFlushOnFailure = (kind: FragmentKind) =>
       {
         type: "assistant",
         finish: "error",
+        settlement: "failed",
         error: { type: "unknown", message: "Provider unavailable" },
         content: [fixture.expectedContent],
       },
@@ -543,12 +543,28 @@ const verifyPartialFlushOnInterruption = (kind: FragmentKind) =>
     const fiber = yield* runner.run({ sessionID, force: true }).pipe(Effect.forkChild)
     yield* Deferred.await(streamed)
     yield* Fiber.interrupt(fiber)
+    const { db } = yield* Database.Service
+    const interruptedVersion = SessionEvent.Step.Interrupted.durable?.version
+    expect(interruptedVersion).toBe(2)
+    if (interruptedVersion === undefined) return yield* Effect.die("Step.Interrupted must be durable")
+    const settlements = yield* db
+      .select({ type: EventTable.type })
+      .from(EventTable)
+      .where(eq(EventTable.aggregate_id, sessionID))
+      .all()
+      .pipe(Effect.orDie)
+    expect(
+      settlements.filter(({ type }) =>
+        [SessionEvent.Step.Ended.type, SessionEvent.Step.Failed.type, SessionEvent.Step.Interrupted.type].some((settled) =>
+          type.startsWith(settled),
+        ),
+      ),
+    ).toEqual([{ type: EventV2.versionedType(SessionEvent.Step.Interrupted.type, interruptedVersion) }])
     expect(yield* session.context(sessionID)).toMatchObject([
       { type: "user", text: prompt },
       {
         type: "assistant",
-        finish: "error",
-        error: { type: "unknown", message: "Provider turn interrupted" },
+        settlement: "interrupted",
         content: [
           kind === "tool input"
             ? { type: "tool", id: fragmentID(kind, "interrupted"), state: { status: "error" } }
@@ -2654,6 +2670,7 @@ describe("SessionRunnerLLM", () => {
               state: { status: "error", error: { type: "unknown", message: "Tool execution interrupted" } },
             },
           ],
+          settlement: "interrupted",
         },
       ])
     }),
@@ -2798,6 +2815,7 @@ describe("SessionRunnerLLM", () => {
               state: { status: "error", error: { type: "unknown", message: "Tool execution interrupted" } },
             },
           ],
+          settlement: "interrupted",
         },
       ])
     }),

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

@@ -53,7 +53,7 @@ const OpenAIResponsesReasoningSummaryText = Schema.Struct({
 
 const OpenAIResponsesReasoningItem = Schema.Struct({
   type: Schema.tag("reasoning"),
-  id: Schema.optionalKey(Schema.String),
+  id: Schema.String,
   summary: Schema.Array(OpenAIResponsesReasoningSummaryText),
   encrypted_content: optionalNull(Schema.String),
 })
@@ -97,7 +97,7 @@ type OpenAIResponsesInputItem = Schema.Schema.Type<typeof OpenAIResponsesInputIt
 // multiple streamed summary parts into the same item before flushing.
 type OpenAIResponsesReasoningInput = {
   type: "reasoning"
-  id?: string
+  id: string
   summary: Array<{ type: "summary_text"; text: string }>
   encrypted_content?: string | null
 }
@@ -277,9 +277,7 @@ const lowerToolCall = (part: ToolCallPart): OpenAIResponsesInputItem => ({
   arguments: ProviderShared.encodeJson(part.input),
 })
 
-const lowerReasoning = (
-  part: ReasoningPart,
-): { readonly itemID: string; readonly item: OpenAIResponsesReasoningInput } | undefined => {
+const lowerReasoning = (part: ReasoningPart): OpenAIResponsesReasoningInput | undefined => {
   const openai = part.providerMetadata?.openai
   if (!ProviderShared.isRecord(openai) || typeof openai.itemId !== "string" || openai.itemId.length === 0)
     return undefined
@@ -290,12 +288,10 @@ const lowerReasoning = (
         ? null
         : undefined
   return {
-    itemID: openai.itemId,
-    item: {
-      type: "reasoning",
-      summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
-      encrypted_content: encryptedContent,
-    },
+    type: "reasoning",
+    id: openai.itemId,
+    summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
+    encrypted_content: encryptedContent,
   }
 }
 
@@ -387,20 +383,20 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
           flushText()
           const reasoning = lowerReasoning(part)
           if (!reasoning) continue
-          if (store !== false) {
-            if (!reasoningReferences.has(reasoning.itemID)) input.push({ type: "item_reference", id: reasoning.itemID })
-            reasoningReferences.add(reasoning.itemID)
+          if (store !== false && reasoning.id) {
+            if (!reasoningReferences.has(reasoning.id)) input.push({ type: "item_reference", id: reasoning.id })
+            reasoningReferences.add(reasoning.id)
             continue
           }
-          const existing = reasoningItems[reasoning.itemID]
+          const existing = reasoningItems[reasoning.id]
           if (existing) {
-            existing.summary.push(...reasoning.item.summary)
-            if (typeof reasoning.item.encrypted_content === "string")
-              existing.encrypted_content = reasoning.item.encrypted_content
+            existing.summary.push(...reasoning.summary)
+            if (typeof reasoning.encrypted_content === "string")
+              existing.encrypted_content = reasoning.encrypted_content
             continue
           }
-          reasoningItems[reasoning.itemID] = reasoning.item
-          input.push(reasoning.item)
+          reasoningItems[reasoning.id] = reasoning
+          input.push(reasoning)
           continue
         }
         if (part.type === "tool-call") {

packages/llm/test/fixtures/recordings/openai-responses/openai-responses-gpt-5-5-reasoning-continuation.json

@@ -44,7 +44,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]},{\"type\":\"reasoning\",\"summary\":[],\"encrypted_content\":\"gAAAAABqEjXoGMCw3WDXpoD9151PEr2Lt8raW7KBKefQhZJGWx5f8jy152bApO6oE-Mr1BhUtfZNq3OPBVfSL4ioQ9bHREfujIBXgk9LUDBAz2Sle7KjOr9HaUV16A4HBiaFIRFjsHPS9G8yEySp1m6F1CD_WR6apyUGgugRh_y39EcOJmxPOzmiac5DVM6fraA1VpcGbqrZ1x2ANHFDOfnYTycPtPNTgzE7LjkYjDDWbT03uN1YxfP4pqjDVRzY14pA8bSZ8ys-pDv5kUFCAsw-OlU4jYKUXp-M8_6KTaRQP71LPwppt__zG_NJPfy-qUil4pOU8_NoxtxerHgLLXbfExZdzfpoGinoEjn7nj7BJDEtl-LNeNEb5c-1ZymNfVMp-Cs3fLEPkAV8rtHFtZ0MhE_07GKbGo7hTrOmkM4DydxmHsdWGNbXAG35cprslEA5P7p3GHFKnRs5hGs2eq-XcZ3yki64ZBOU_Tv6UR7nUH09gF1rdrJo3dpre6M00COwwdZ02zUP5KxCuI8FKu2jsZu9zgMVXDALsdtM5orTCVLXsn4rddWd111zE-vMjNmMMmktW2cHMjH7j1ooA-9P083koNVYiLi4UhMA64gTqgyl8MxkZekl7eFSMa7qk295NaHOKtFxzYYcZ9jdioCwSPSZ0ZZWLoNgrK7SWfRh0uaTHNcMZ3wq8ae6CguktIeVTCPTQAqJLQqd7AU0oOCKCJ7BWnC-L8UC6m7Pm9ZS958uUVeWBhgKHzMAGq9UeQB7IEeAcbMn3EDgOSfd8qCb8iwU9iG9dcu9axQwWU7pd7kd-T-He61W7z5wWgpx1KehWCxrN6kuKSo6p-uUfwVnJukreOn8BJNAzADQgz68bhmN9VGih7YcKVnLgwDwKditrjSd6-tfE0Baarj3jWENvT6ohY17R9FDrKS-2v8IIX6tGjoKJw8SRhaWLNv4vWlmxRgR0gdac3qumd0GKqsWSveNz01naA==\"},{\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Hello!\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Now reply exactly with: Done.\"}]}],\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":40,\"stream\":true}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]},{\"type\":\"reasoning\",\"id\":\"rs_0a0794dab3b8ec7d016a1235e7ce3881958a5eca32a36a14c5\",\"summary\":[],\"encrypted_content\":\"gAAAAABqEjXoGMCw3WDXpoD9151PEr2Lt8raW7KBKefQhZJGWx5f8jy152bApO6oE-Mr1BhUtfZNq3OPBVfSL4ioQ9bHREfujIBXgk9LUDBAz2Sle7KjOr9HaUV16A4HBiaFIRFjsHPS9G8yEySp1m6F1CD_WR6apyUGgugRh_y39EcOJmxPOzmiac5DVM6fraA1VpcGbqrZ1x2ANHFDOfnYTycPtPNTgzE7LjkYjDDWbT03uN1YxfP4pqjDVRzY14pA8bSZ8ys-pDv5kUFCAsw-OlU4jYKUXp-M8_6KTaRQP71LPwppt__zG_NJPfy-qUil4pOU8_NoxtxerHgLLXbfExZdzfpoGinoEjn7nj7BJDEtl-LNeNEb5c-1ZymNfVMp-Cs3fLEPkAV8rtHFtZ0MhE_07GKbGo7hTrOmkM4DydxmHsdWGNbXAG35cprslEA5P7p3GHFKnRs5hGs2eq-XcZ3yki64ZBOU_Tv6UR7nUH09gF1rdrJo3dpre6M00COwwdZ02zUP5KxCuI8FKu2jsZu9zgMVXDALsdtM5orTCVLXsn4rddWd111zE-vMjNmMMmktW2cHMjH7j1ooA-9P083koNVYiLi4UhMA64gTqgyl8MxkZekl7eFSMa7qk295NaHOKtFxzYYcZ9jdioCwSPSZ0ZZWLoNgrK7SWfRh0uaTHNcMZ3wq8ae6CguktIeVTCPTQAqJLQqd7AU0oOCKCJ7BWnC-L8UC6m7Pm9ZS958uUVeWBhgKHzMAGq9UeQB7IEeAcbMn3EDgOSfd8qCb8iwU9iG9dcu9axQwWU7pd7kd-T-He61W7z5wWgpx1KehWCxrN6kuKSo6p-uUfwVnJukreOn8BJNAzADQgz68bhmN9VGih7YcKVnLgwDwKditrjSd6-tfE0Baarj3jWENvT6ohY17R9FDrKS-2v8IIX6tGjoKJw8SRhaWLNv4vWlmxRgR0gdac3qumd0GKqsWSveNz01naA==\"},{\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Hello!\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Now reply exactly with: Done.\"}]}],\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":40,\"stream\":true}"
       },
       "response": {
         "status": 200,

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

@@ -519,6 +519,7 @@ describe("OpenAI Responses route", () => {
           },
           {
             type: "reasoning",
+            id: "rs_continuation_1",
             encrypted_content: "encrypted-continuation-state",
             summary: [{ type: "summary_text", text: "I inspected the previous turn." }],
           },
@@ -924,12 +925,12 @@ describe("OpenAI Responses route", () => {
           dynamicResponse((input) =>
             Effect.gen(function* () {
               const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
-              const body = yield* Effect.promise(() => web.json())
-              expect(body).toMatchObject({
+              expect(yield* Effect.promise(() => web.json())).toMatchObject({
                 input: [
                   { role: "user", content: [{ type: "input_text", text: "What changed?" }] },
                   {
                     type: "reasoning",
+                    id: "rs_1",
                     encrypted_content: "encrypted-state",
                     summary: [{ type: "summary_text", text: "Checked the previous diff." }],
                   },
@@ -937,7 +938,6 @@ describe("OpenAI Responses route", () => {
                   { role: "user", content: [{ type: "input_text", text: "Summarize it." }] },
                 ],
               })
-              expect(body.input[1]).not.toHaveProperty("id")
               return input.respond(
                 sseEvents(
                   { type: "response.output_text.delta", item_id: "msg_1", delta: "Parser now round-trips reasoning." },
@@ -984,6 +984,7 @@ describe("OpenAI Responses route", () => {
         { role: "assistant", content: [{ type: "output_text", text: "Before." }] },
         {
           type: "reasoning",
+          id: "rs_1",
           encrypted_content: "encrypted-state",
           summary: [{ type: "summary_text", text: "Checked order." }],
         },
@@ -1077,6 +1078,7 @@ describe("OpenAI Responses route", () => {
       expect(prepared.body.input).toEqual([
         {
           type: "reasoning",
+          id: "rs_1",
           encrypted_content: "encrypted-state",
           summary: [
             { type: "summary_text", text: "First" },

packages/llm/test/tool-runtime.test.ts

@@ -598,7 +598,7 @@ describe("LLMClient tools", () => {
         include: ["reasoning.encrypted_content"],
         input: [
           { role: "user" },
-          { type: "reasoning", summary: [], encrypted_content: "encrypted-state" },
+          { type: "reasoning", id: "rs_1", summary: [], encrypted_content: "encrypted-state" },
           { type: "function_call", call_id: "call_1", name: "get_weather" },
           { type: "function_call_output", call_id: "call_1" },
         ],

packages/opencode/src/mcp/oauth-callback.ts

@@ -1,6 +1,6 @@
 import { createConnection } from "net"
 import { createServer } from "http"
-import { OauthCallbackPage } from "@opencode-ai/core/oauth/page"
+import { escapeHtml } from "@/util/html"
 import { OAUTH_CALLBACK_PORT, OAUTH_CALLBACK_PATH, parseRedirectUri } from "./oauth-provider"
 
 const OAUTH_CALLBACK_HOST = "127.0.0.1"
@@ -9,6 +9,47 @@ const OAUTH_CALLBACK_HOST = "127.0.0.1"
 let currentPort = OAUTH_CALLBACK_PORT
 let currentPath = OAUTH_CALLBACK_PATH
 
+const HTML_SUCCESS = `<!DOCTYPE html>
+<html>
+<head>
+  <title>OpenCode - Authorization Successful</title>
+  <style>
+    body { font-family: system-ui, -apple-system, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a2e; color: #eee; }
+    .container { text-align: center; padding: 2rem; }
+    h1 { color: #4ade80; margin-bottom: 1rem; }
+    p { color: #aaa; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Authorization Successful</h1>
+    <p>You can close this window and return to OpenCode.</p>
+  </div>
+  <script>setTimeout(() => window.close(), 2000);</script>
+</body>
+</html>`
+
+const HTML_ERROR = (error: string) => `<!DOCTYPE html>
+<html>
+<head>
+  <title>OpenCode - Authorization Failed</title>
+  <style>
+    body { font-family: system-ui, -apple-system, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a2e; color: #eee; }
+    .container { text-align: center; padding: 2rem; }
+    h1 { color: #f87171; margin-bottom: 1rem; }
+    p { color: #aaa; }
+    .error { color: #fca5a5; font-family: monospace; margin-top: 1rem; padding: 1rem; background: rgba(248,113,113,0.1); border-radius: 0.5rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Authorization Failed</h1>
+    <p>An error occurred during authorization.</p>
+    <div class="error">${escapeHtml(error)}</div>
+  </div>
+</body>
+</html>`
+
 interface PendingAuth {
   resolve: (code: string) => void
   reject: (error: Error) => void
@@ -57,7 +98,7 @@ function handleRequest(req: import("http").IncomingMessage, res: import("http").
   if (!state) {
     const errorMsg = "Missing required state parameter - potential CSRF attack"
     res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" })
-    res.end(OauthCallbackPage.error(errorMsg, { provider: "MCP" }))
+    res.end(HTML_ERROR(errorMsg))
     return
   }
 
@@ -71,14 +112,14 @@ function handleRequest(req: import("http").IncomingMessage, res: import("http").
       pending.reject(new Error(errorMsg))
     }
     res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" })
-    res.end(OauthCallbackPage.error(errorMsg, { provider: "MCP" }))
+    res.end(HTML_ERROR(errorMsg))
     stopIfIdle()
     return
   }
 
   if (!code) {
     res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" })
-    res.end(OauthCallbackPage.error("No authorization code provided", { provider: "MCP" }))
+    res.end(HTML_ERROR("No authorization code provided"))
     return
   }
 
@@ -86,7 +127,7 @@ function handleRequest(req: import("http").IncomingMessage, res: import("http").
   if (!pendingAuths.has(state)) {
     const errorMsg = "Invalid or expired state parameter - potential CSRF attack"
     res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" })
-    res.end(OauthCallbackPage.error(errorMsg, { provider: "MCP" }))
+    res.end(HTML_ERROR(errorMsg))
     return
   }
 
@@ -98,7 +139,7 @@ function handleRequest(req: import("http").IncomingMessage, res: import("http").
   pending.resolve(code)
 
   res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" })
-  res.end(OauthCallbackPage.success({ provider: "MCP" }))
+  res.end(HTML_SUCCESS)
   stopIfIdle()
 }
 

packages/opencode/src/plugin/digitalocean.ts

@@ -1,7 +1,6 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin"
 import type { Model } from "@opencode-ai/sdk/v2"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { OauthCallbackPage } from "@opencode-ai/core/oauth/page"
 import { createServer } from "http"
 import open from "open"
 
@@ -59,6 +58,65 @@ function buildAuthorizeUrl(state: string): string {
   return `${DO_AUTHORIZE_URL}?${params.toString()}`
 }
 
+const HTML_CALLBACK = `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>OpenCode - DigitalOcean Authorization</title>
+    <style>
+      body { font-family: system-ui, -apple-system, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0b1220; color: #e8eef9; }
+      .container { text-align: center; padding: 2rem; max-width: 32rem; }
+      h1 { color: #e8eef9; margin-bottom: 1rem; }
+      p { color: #9aa9c0; }
+      .error { color: #ff917b; font-family: monospace; margin-top: 1rem; padding: 1rem; background: #3c140d; border-radius: 0.5rem; }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1 id="title">Finishing sign-in...</h1>
+      <p id="msg">You can close this window once it says you're signed in.</p>
+    </div>
+    <script>
+      (async function() {
+        const params = new URLSearchParams((window.location.hash || "").slice(1))
+        const search = new URLSearchParams(window.location.search)
+        const error = params.get("error") || search.get("error")
+        const errorDescription = params.get("error_description") || search.get("error_description")
+        const titleEl = document.getElementById("title")
+        const msgEl = document.getElementById("msg")
+        const tokenUrl = new URL(${JSON.stringify(OAUTH_TOKEN_PATH)}, window.location.origin).href
+        try {
+          const body = error
+            ? { error, error_description: errorDescription || "" }
+            : { access_token: params.get("access_token") || "", expires_in: params.get("expires_in") || "0", state: params.get("state") || "" }
+          const res = await fetch(tokenUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+          })
+          if (!res.ok) {
+            const detail = await res.text().catch(function () { return "" })
+            throw new Error(detail || ("callback failed (" + res.status + ")"))
+          }
+          if (error) {
+            titleEl.textContent = "Authorization Failed"
+            msgEl.textContent = errorDescription || error
+            msgEl.className = "error"
+            return
+          }
+          titleEl.textContent = "Authorization Successful"
+          msgEl.textContent = "You can close this window and return to OpenCode."
+          setTimeout(function () { window.close() }, 2000)
+        } catch (e) {
+          titleEl.textContent = "Authorization Failed"
+          msgEl.textContent = String(e && e.message ? e.message : e)
+          msgEl.className = "error"
+        }
+      })()
+    </script>
+  </body>
+</html>`
+
 async function startOAuthServer(): Promise<void> {
   if (oauthServer) return
   oauthServer = createServer((req, res) => {
@@ -66,7 +124,7 @@ async function startOAuthServer(): Promise<void> {
 
     if (req.method === "GET" && url.pathname === OAUTH_REDIRECT_PATH) {
       res.writeHead(200, { "Content-Type": "text/html" })
-      res.end(OauthCallbackPage.bootstrap({ tokenPath: OAUTH_TOKEN_PATH, provider: "DigitalOcean" }))
+      res.end(HTML_CALLBACK)
       return
     }
 

packages/opencode/src/plugin/openai/codex.ts

@@ -5,7 +5,7 @@ import os from "os"
 import { setTimeout as sleep } from "node:timers/promises"
 import { createServer } from "http"
 import { OpenAIWebSocketPool } from "./ws-pool"
-import { OauthCallbackPage } from "@opencode-ai/core/oauth/page"
+import { escapeHtml } from "@/util/html"
 
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"
 const ISSUER = "https://auth.openai.com"
@@ -138,8 +138,95 @@ async function refreshAccessToken(refreshToken: string, issuer = ISSUER): Promis
   return response.json()
 }
 
-// Kept as a named export for plugin.codex tests; delegates to the shared branded page.
-export const renderOAuthError = (error: string) => OauthCallbackPage.error(error, { provider: "ChatGPT" })
+const HTML_SUCCESS = `<!doctype html>
+<html>
+  <head>
+    <title>OpenCode - Codex Authorization Successful</title>
+    <style>
+      body {
+        font-family:
+          system-ui,
+          -apple-system,
+          sans-serif;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        height: 100vh;
+        margin: 0;
+        background: #131010;
+        color: #f1ecec;
+      }
+      .container {
+        text-align: center;
+        padding: 2rem;
+      }
+      h1 {
+        color: #f1ecec;
+        margin-bottom: 1rem;
+      }
+      p {
+        color: #b7b1b1;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>Authorization Successful</h1>
+      <p>You can close this window and return to OpenCode.</p>
+    </div>
+    <script>
+      setTimeout(() => window.close(), 2000)
+    </script>
+  </body>
+</html>`
+
+export const renderOAuthError = (error: string) => `<!doctype html>
+<html>
+  <head>
+    <title>OpenCode - Codex Authorization Failed</title>
+    <style>
+      body {
+        font-family:
+          system-ui,
+          -apple-system,
+          sans-serif;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        height: 100vh;
+        margin: 0;
+        background: #131010;
+        color: #f1ecec;
+      }
+      .container {
+        text-align: center;
+        padding: 2rem;
+      }
+      h1 {
+        color: #fc533a;
+        margin-bottom: 1rem;
+      }
+      p {
+        color: #b7b1b1;
+      }
+      .error {
+        color: #ff917b;
+        font-family: monospace;
+        margin-top: 1rem;
+        padding: 1rem;
+        background: #3c140d;
+        border-radius: 0.5rem;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>Authorization Failed</h1>
+      <p>An error occurred during authorization.</p>
+      <div class="error">${escapeHtml(error)}</div>
+    </div>
+  </body>
+</html>`
 
 interface PendingOAuth {
   pkce: PkceCodes
@@ -200,7 +287,7 @@ async function startOAuthServer(): Promise<{ port: number; redirectUri: string }
         .catch((err) => current.reject(err))
 
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" })
-      res.end(OauthCallbackPage.success({ provider: "ChatGPT" }))
+      res.end(HTML_SUCCESS)
       return
     }
 

packages/opencode/src/plugin/snowflake-cortex.ts

@@ -1,7 +1,6 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin"
 import { OAUTH_DUMMY_KEY } from "../auth"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { OauthCallbackPage } from "@opencode-ai/core/oauth/page"
 import { createServer } from "http"
 import open from "open"
 
@@ -157,6 +156,29 @@ async function refreshAccessToken(account: string, refreshToken: string) {
   return token
 }
 
+const HTML_SUCCESS = `<!doctype html>
+<html>
+  <head><title>OpenCode - Snowflake Authorization Successful</title></head>
+  <body style="font-family: system-ui; display:flex; align-items:center; justify-content:center; height:100vh; margin:0; background:#111; color:#eee;">
+    <div style="text-align:center; max-width:36rem; padding:2rem;">
+      <h1 style="color:#7ee787;">Authorization Successful</h1>
+      <p>You can close this window and return to OpenCode.</p>
+    </div>
+    <script>setTimeout(() => window.close(), 1500)</script>
+  </body>
+</html>`
+
+const htmlError = (message: string) => `<!doctype html>
+<html>
+  <head><title>OpenCode - Snowflake Authorization Failed</title></head>
+  <body style="font-family: system-ui; display:flex; align-items:center; justify-content:center; height:100vh; margin:0; background:#111; color:#eee;">
+    <div style="text-align:center; max-width:48rem; padding:2rem;">
+      <h1 style="color:#ff7b72;">Authorization Failed</h1>
+      <pre style="white-space:pre-wrap; color:#ffb3ad; background:#2a1210; padding:1rem; border-radius:.5rem;">${message}</pre>
+    </div>
+  </body>
+</html>`
+
 async function startOAuthServer() {
   if (oauthServer) return
 
@@ -181,7 +203,7 @@ async function startOAuthServer() {
       pendingOAuth?.reject(new Error(message))
       pendingOAuth = undefined
       res.writeHead(400, { "Content-Type": "text/html" })
-      res.end(OauthCallbackPage.error(message, { provider: "Snowflake" }))
+      res.end(htmlError(message))
       return
     }
 
@@ -192,7 +214,7 @@ async function startOAuthServer() {
       const message = errorDescription || error
       current.reject(new Error(message))
       res.writeHead(200, { "Content-Type": "text/html" })
-      res.end(OauthCallbackPage.error(message, { provider: "Snowflake" }))
+      res.end(htmlError(message))
       return
     }
 
@@ -200,7 +222,7 @@ async function startOAuthServer() {
       const message = "Missing authorization code"
       current.reject(new Error(message))
       res.writeHead(400, { "Content-Type": "text/html" })
-      res.end(OauthCallbackPage.error(message, { provider: "Snowflake" }))
+      res.end(htmlError(message))
       return
     }
 
@@ -209,7 +231,7 @@ async function startOAuthServer() {
       .catch((err) => current.reject(err instanceof Error ? err : new Error(String(err))))
 
     res.writeHead(200, { "Content-Type": "text/html" })
-    res.end(OauthCallbackPage.success({ provider: "Snowflake" }))
+    res.end(HTML_SUCCESS)
   })
 
   await new Promise<void>((resolve, reject) => {

packages/opencode/src/plugin/xai.ts

@@ -2,7 +2,7 @@ import type { Hooks, PluginInput } from "@opencode-ai/plugin"
 import { OAUTH_DUMMY_KEY } from "../auth"
 import { createServer } from "http"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { OauthCallbackPage } from "@opencode-ai/core/oauth/page"
+import { escapeHtml } from "@/util/html"
 
 // Public Grok-CLI OAuth client. xAI's auth server rejects loopback OAuth from
 // non-allowlisted clients, so we reuse the Grok-CLI client_id that xAI ships
@@ -285,6 +285,96 @@ export async function pollDeviceCodeToken(
   throw new Error("xAI device authorization timed out")
 }
 
+const HTML_SUCCESS = `<!doctype html>
+<html>
+  <head>
+    <title>OpenCode - xAI Authorization Successful</title>
+    <style>
+      body {
+        font-family:
+          system-ui,
+          -apple-system,
+          sans-serif;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        height: 100vh;
+        margin: 0;
+        background: #131010;
+        color: #f1ecec;
+      }
+      .container {
+        text-align: center;
+        padding: 2rem;
+      }
+      h1 {
+        color: #f1ecec;
+        margin-bottom: 1rem;
+      }
+      p {
+        color: #b7b1b1;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>Authorization Successful</h1>
+      <p>You can close this window and return to OpenCode.</p>
+    </div>
+    <script>
+      setTimeout(() => window.close(), 2000)
+    </script>
+  </body>
+</html>`
+
+const HTML_ERROR = (error: string) => `<!doctype html>
+<html>
+  <head>
+    <title>OpenCode - xAI Authorization Failed</title>
+    <style>
+      body {
+        font-family:
+          system-ui,
+          -apple-system,
+          sans-serif;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        height: 100vh;
+        margin: 0;
+        background: #131010;
+        color: #f1ecec;
+      }
+      .container {
+        text-align: center;
+        padding: 2rem;
+      }
+      h1 {
+        color: #fc533a;
+        margin-bottom: 1rem;
+      }
+      p {
+        color: #b7b1b1;
+      }
+      .error {
+        color: #ff917b;
+        font-family: monospace;
+        margin-top: 1rem;
+        padding: 1rem;
+        background: #3c140d;
+        border-radius: 0.5rem;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>Authorization Failed</h1>
+      <p>An error occurred during authorization.</p>
+      <div class="error">${escapeHtml(error)}</div>
+    </div>
+  </body>
+</html>`
+
 // CORS allowlist for the loopback callback. The redirect_uri itself is
 // already bound to 127.0.0.1 and gated by PKCE+state, so we only accept
 // xAI's own auth origins for additional defense-in-depth on the OPTIONS
@@ -335,7 +425,7 @@ async function startOAuthServer(): Promise<{ port: number; redirectUri: string }
         pendingOAuth?.reject(new Error(errorMsg))
         pendingOAuth = undefined
         res.writeHead(200, { "Content-Type": "text/html" })
-        res.end(OauthCallbackPage.error(errorMsg, { provider: "xAI" }))
+        res.end(HTML_ERROR(errorMsg))
         return
       }
 
@@ -344,7 +434,7 @@ async function startOAuthServer(): Promise<{ port: number; redirectUri: string }
         pendingOAuth?.reject(new Error(errorMsg))
         pendingOAuth = undefined
         res.writeHead(400, { "Content-Type": "text/html" })
-        res.end(OauthCallbackPage.error(errorMsg, { provider: "xAI" }))
+        res.end(HTML_ERROR(errorMsg))
         return
       }
 
@@ -353,7 +443,7 @@ async function startOAuthServer(): Promise<{ port: number; redirectUri: string }
         pendingOAuth?.reject(new Error(errorMsg))
         pendingOAuth = undefined
         res.writeHead(400, { "Content-Type": "text/html" })
-        res.end(OauthCallbackPage.error(errorMsg, { provider: "xAI" }))
+        res.end(HTML_ERROR(errorMsg))
         return
       }
 
@@ -365,7 +455,7 @@ async function startOAuthServer(): Promise<{ port: number; redirectUri: string }
         .catch((err) => current.reject(err))
 
       res.writeHead(200, { "Content-Type": "text/html" })
-      res.end(OauthCallbackPage.success({ provider: "xAI" }))
+      res.end(HTML_SUCCESS)
       return
     }
 

packages/opencode/test/event-manifest.test.ts

@@ -9,7 +9,7 @@ describe("public event manifest", () => {
     expect(EventManifest.Definitions).toBe(SchemaEventManifest.Definitions)
     expect(EventManifest.Latest).toBe(SchemaEventManifest.Latest)
     expect(EventManifest.Durable).toBe(SchemaEventManifest.Durable)
-    expect(EventManifest.Latest.size).toBe(88)
+    expect(EventManifest.Latest.size).toBe(89)
     expect(EventManifest.Latest.get("session.next.step.ended")).toBe(SessionEvent.Step.Ended)
     expect(EventManifest.Latest.get("todo.updated")).toBe(Todo.Event.Updated)
     expect(EventManifest.Latest.has("ide.installed")).toBe(false)

packages/opencode/test/mcp/oauth-callback.test.ts

@@ -101,7 +101,7 @@ describe("McpOAuthCallback.ensureRunning", () => {
       `${redirectUri}?state=test&error=access_denied&error_description=${encodeURIComponent("The user denied access")}`,
     )
 
-    expect(await response.text()).toContain('<pre class="detail" id="oc-detail">The user denied access</pre>')
+    expect(await response.text()).toContain('<div class="error">The user denied access</div>')
   })
 
   test("binds the callback server to IPv4 loopback", async () => {

packages/opencode/test/server/httpapi-exercise/index.ts

@@ -964,7 +964,6 @@ const scenarios: Scenario[] = [
       headers: ctx.headers(),
     }))
     .status(400, undefined, "none"),
-  http.protected.get("/api/session/active", "v2.session.active").json(200, data(object), "none"),
   http.protected
     .post("/api/session", "v2.session.create")
     .at((ctx) => ({

packages/protocol/src/groups/session.ts

@@ -73,10 +73,6 @@ export const SessionsCursor = Schema.String.pipe(
 )
 export type SessionsCursor = typeof SessionsCursor.Type
 
-const SessionActive = Schema.Struct({
-  type: Schema.Literal("running"),
-}).annotate({ identifier: "SessionActive" })
-
 const SessionsQueryCursor = SessionsCursor.annotate({
   description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
 })
@@ -128,18 +124,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         }),
       ),
     )
-    .add(
-      HttpApiEndpoint.get("session.active", "/api/session/active", {
-        success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive) }),
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.session.active",
-          summary: "List active sessions",
-          description:
-            "Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.",
-        }),
-      ),
-    )
     .add(
       HttpApiEndpoint.get("session.get", "/api/session/:sessionID", {
         params: { sessionID: Session.ID },

packages/schema/src/session-event.ts

@@ -165,6 +165,7 @@ export namespace Step {
     schema: {
       ...Base,
       assistantMessageID: SessionMessage.ID,
+      // Step.Ended v2 was originally persisted with an open string schema.
       finish: Schema.String,
       cost: Schema.Finite,
       tokens: Schema.Struct({
@@ -192,6 +193,16 @@ export namespace Step {
     },
   })
   export type Failed = typeof Failed.Type
+
+  export const Interrupted = Event.define({
+    type: "session.next.step.interrupted",
+    ...stepSettlementOptions,
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessage.ID,
+    },
+  })
+  export type Interrupted = typeof Interrupted.Type
 }
 
 export namespace Text {
@@ -458,6 +469,7 @@ export const DurableDefinitions = Event.inventory(
   Step.Started,
   Step.Ended,
   Step.Failed,
+  Step.Interrupted,
   Text.Started,
   Text.Ended,
   Tool.Input.Started,
@@ -489,6 +501,7 @@ export const Definitions = Event.inventory(
   Step.Started,
   Step.Ended,
   Step.Failed,
+  Step.Interrupted,
   Text.Started,
   Text.Delta,
   Text.Ended,

packages/schema/src/session-message.ts

@@ -21,6 +21,19 @@ export const UnknownError = Schema.Struct({
   message: Schema.String,
 }).annotate({ identifier: "Session.Error.Unknown" })
 
+export const Finish = Schema.Literals([
+  "stop",
+  "length",
+  "tool-calls",
+  "content-filter",
+  "error",
+  "unknown",
+])
+export type Finish = typeof Finish.Type
+
+export const Settlement = Schema.Literals(["completed", "failed", "interrupted"])
+export type Settlement = typeof Settlement.Type
+
 const Base = {
   id: ID,
   metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
@@ -169,7 +182,9 @@ export const Assistant = Schema.Struct({
     end: Schema.String.pipe(optional),
     files: Schema.Array(RelativePath).pipe(optional),
   }).pipe(optional),
+  // Projected histories predate the typed provider finish model and may contain arbitrary values.
   finish: Schema.String.pipe(optional),
+  settlement: Settlement.pipe(optional),
   cost: Schema.Finite.pipe(optional),
   tokens: Schema.Struct({
     input: Schema.Finite,

packages/schema/test/event-manifest.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
 import { FileSystem, Integration, Permission, Project, Reference, Session, Workspace } from "../src"
 import { EventManifest } from "../src/event-manifest"
 import { IdeEvent } from "../src/ide-event"
@@ -9,8 +10,8 @@ import { WorkspaceEvent } from "../src/workspace-event"
 
 describe("public event manifest", () => {
   test("owns the complete public event surface", () => {
-    expect(EventManifest.ServerDefinitions.length).toBe(55)
-    expect(EventManifest.Definitions.length).toBe(85)
+    expect(EventManifest.ServerDefinitions.length).toBe(59)
+    expect(EventManifest.Definitions.length).toBe(89)
     expect(SessionV1.Event.Definitions).toEqual([
       SessionV1.Event.Created,
       SessionV1.Event.Updated,
@@ -23,8 +24,8 @@ describe("public event manifest", () => {
       SessionV1.Event.Diff,
       SessionV1.Event.Error,
     ])
-    expect(EventManifest.Latest.size).toBe(85)
-    expect(EventManifest.Durable.size).toBe(32)
+    expect(EventManifest.Latest.size).toBe(89)
+    expect(EventManifest.Durable.size).toBe(36)
   })
 
   test("uses canonical definitions for current public events", () => {
@@ -42,12 +43,28 @@ describe("public event manifest", () => {
     expect(Reference.Event.Definitions).toEqual([Reference.Event.Updated])
     expect(EventManifest.Latest.has("ide.installed")).toBe(false)
     expect(IdeEvent.Definitions).toEqual([IdeEvent.Installed])
-    expect(EventManifest.Definitions.slice(40, 43)).toEqual([
+    const partDelta = EventManifest.Definitions.indexOf(SessionV1.Event.PartDelta)
+    expect(partDelta).toBeGreaterThanOrEqual(0)
+    expect(EventManifest.Definitions.slice(partDelta, partDelta + 3)).toEqual([
       SessionV1.Event.PartDelta,
       SessionV1.Event.Diff,
       SessionV1.Event.Error,
     ])
+    expect(EventManifest.Latest.get("session.next.step.interrupted")).toBe(SessionEvent.Step.Interrupted)
     expect(EventManifest.Durable.has("session.next.step.ended.1")).toBe(false)
     expect(EventManifest.Durable.get("session.next.step.ended.2")).toBe(SessionEvent.Step.Ended)
   })
+
+  test("decodes legacy Step.Ended v2 finish strings", () => {
+    const event = Schema.decodeUnknownSync(SessionEvent.Step.Ended.data)({
+      sessionID: "ses_legacy",
+      timestamp: 0,
+      assistantMessageID: "msg_legacy",
+      finish: "legacy-provider-reason",
+      cost: 0,
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    })
+
+    expect(event.finish).toBe("legacy-provider-reason")
+  })
 })

packages/schema/test/session-message.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "bun:test"
+import { Schema } from "effect"
+import { SessionMessage } from "../src/session-message"
+
+test("does not model interruption as a provider finish reason", () => {
+  expect(() => Schema.decodeUnknownSync(SessionMessage.Finish)("interrupted")).toThrow()
+  expect(Schema.decodeUnknownSync(SessionMessage.Finish)("error")).toBe("error")
+})
+
+test("decodes projected assistant histories with arbitrary finish strings", () => {
+  const message = Schema.decodeUnknownSync(SessionMessage.Message)({
+    id: "msg_legacy",
+    type: "assistant",
+    agent: "build",
+    model: { id: "model", providerID: "provider" },
+    content: [],
+    finish: "legacy-provider-reason",
+    time: { created: 0, completed: 1 },
+  })
+
+  expect(message).toMatchObject({ type: "assistant", finish: "legacy-provider-reason" })
+})

packages/sdk-next/test/embedded.test.ts

@@ -33,7 +33,6 @@ test("embedded client uses the real router and handlers", async () => {
       yield* opencode.sessions.switchModel({ sessionID, model })
       const selected = yield* opencode.sessions.get({ sessionID })
       const page = yield* opencode.sessions.list({ directory: AbsolutePath.make(directory) })
-      const active = yield* opencode.sessions.active()
       const admitted = yield* opencode.sessions.prompt({
         sessionID,
         prompt: Prompt.make({ text: "Do not run" }),
@@ -82,7 +81,6 @@ test("embedded client uses the real router and handlers", async () => {
       expect(selected.model?.id).toBe(model.id)
       expect(selected.model?.providerID).toBe(model.providerID)
       expect(page.data.some((session) => session.id === sessionID)).toBe(true)
-      expect(active).toEqual({})
       expect(admitted.sessionID).toBe(sessionID)
       expect(prompted.type).toBe("session.next.prompted")
       expect(wakeContext).toContainEqual(expect.objectContaining({ id: wake.id, type: "user" }))

packages/sdk/js/src/v2/gen/sdk.gen.ts

@@ -333,8 +333,6 @@ import type {
   V2QuestionRequestListResponses,
   V2ReferenceListErrors,
   V2ReferenceListResponses,
-  V2SessionActiveErrors,
-  V2SessionActiveResponses,
   V2SessionCompactErrors,
   V2SessionCompactResponses,
   V2SessionContextErrors,
@@ -5503,18 +5501,6 @@ export class Session3 extends HeyApiClient {
     })
   }
 
-  /**
-   * List active sessions
-   *
-   * Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.
-   */
-  public active<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>) {
-    return (options?.client ?? this.client).get<V2SessionActiveResponses, V2SessionActiveErrors, ThrowOnError>({
-      url: "/api/session/active",
-      ...options,
-    })
-  }
-
   /**
    * Get session
    *

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -28,6 +28,7 @@ export type Event =
   | EventSessionNextStepStarted
   | EventSessionNextStepEnded
   | EventSessionNextStepFailed
+  | EventSessionNextStepInterrupted
   | EventSessionNextTextStarted
   | EventSessionNextTextDelta
   | EventSessionNextTextEnded
@@ -955,6 +956,15 @@ export type GlobalEvent = {
           error: SessionErrorUnknown
         }
       }
+    | {
+        id: string
+        type: "session.next.step.interrupted"
+        properties: {
+          timestamp: number
+          sessionID: string
+          assistantMessageID: string
+        }
+      }
     | {
         id: string
         type: "session.next.text.started"
@@ -1620,6 +1630,7 @@ export type GlobalEvent = {
     | SyncEventSessionNextStepStarted
     | SyncEventSessionNextStepEnded
     | SyncEventSessionNextStepFailed
+    | SyncEventSessionNextStepInterrupted
     | SyncEventSessionNextTextStarted
     | SyncEventSessionNextTextEnded
     | SyncEventSessionNextReasoningStarted
@@ -2690,10 +2701,6 @@ export type InvalidCursorError = {
   message: string
 }
 
-export type SessionActive = {
-  type: "running"
-}
-
 export type SessionNotFoundError = {
   _tag: "SessionNotFoundError"
   sessionID: string
@@ -2763,6 +2770,7 @@ export type V2Event =
   | V2EventSessionNextStepStarted
   | V2EventSessionNextStepEnded
   | V2EventSessionNextStepFailed
+  | V2EventSessionNextStepInterrupted
   | V2EventSessionNextTextStarted
   | V2EventSessionNextTextDelta
   | V2EventSessionNextTextEnded
@@ -3404,6 +3412,22 @@ export type SyncEventSessionNextStepFailed = {
   }
 }
 
+export type SyncEventSessionNextStepInterrupted = {
+  type: "sync"
+  id: string
+  syncEvent: {
+    type: "session.next.step.interrupted.2"
+    id: string
+    seq: number
+    aggregateID: string
+    data: {
+      timestamp: number
+      sessionID: string
+      assistantMessageID: string
+    }
+  }
+}
+
 export type SyncEventSessionNextTextStarted = {
   type: "sync"
   id: string
@@ -3999,6 +4023,7 @@ export type SessionMessageAssistant = {
     files?: Array<string>
   }
   finish?: string
+  settlement?: "completed" | "failed" | "interrupted"
   cost?: number
   tokens?: {
     input: number
@@ -4293,6 +4318,25 @@ export type SessionNextStepFailed = {
   }
 }
 
+export type SessionNextStepInterrupted = {
+  id: string
+  metadata?: {
+    [key: string]: unknown
+  }
+  type: "session.next.step.interrupted"
+  durable?: {
+    aggregateID: string
+    seq: number | "NaN" | "Infinity" | "-Infinity"
+    version: number | "NaN" | "Infinity" | "-Infinity"
+  }
+  location?: LocationRef
+  data: {
+    timestamp: number
+    sessionID: string
+    assistantMessageID: string
+  }
+}
+
 export type SessionNextTextStarted = {
   id: string
   metadata?: {
@@ -5348,6 +5392,25 @@ export type V2EventSessionNextStepFailed = {
   }
 }
 
+export type V2EventSessionNextStepInterrupted = {
+  id: string
+  metadata?: {
+    [key: string]: unknown
+  }
+  durable?: {
+    aggregateID: string
+    seq: number
+    version: number
+  }
+  location?: LocationRef
+  type: "session.next.step.interrupted"
+  data: {
+    timestamp: number
+    sessionID: string
+    assistantMessageID: string
+  }
+}
+
 export type V2EventSessionNextTextStarted = {
   id: string
   metadata?: {
@@ -6935,6 +6998,16 @@ export type EventSessionNextStepFailed = {
   }
 }
 
+export type EventSessionNextStepInterrupted = {
+  id: string
+  type: "session.next.step.interrupted"
+  properties: {
+    timestamp: number
+    sessionID: string
+    assistantMessageID: string
+  }
+}
+
 export type EventSessionNextTextStarted = {
   id: string
   type: "session.next.text.started"
@@ -11944,39 +12017,6 @@ export type V2SessionCreateResponses = {
 
 export type V2SessionCreateResponse = V2SessionCreateResponses[keyof V2SessionCreateResponses]
 
-export type V2SessionActiveData = {
-  body?: never
-  path?: never
-  query?: never
-  url: "/api/session/active"
-}
-
-export type V2SessionActiveErrors = {
-  /**
-   * InvalidRequestError
-   */
-  400: InvalidRequestError
-  /**
-   * UnauthorizedError
-   */
-  401: UnauthorizedError
-}
-
-export type V2SessionActiveError = V2SessionActiveErrors[keyof V2SessionActiveErrors]
-
-export type V2SessionActiveResponses = {
-  /**
-   * Success
-   */
-  200: {
-    data: {
-      [key: string]: unknown | SessionActive
-    }
-  }
-}
-
-export type V2SessionActiveResponse = V2SessionActiveResponses[keyof V2SessionActiveResponses]
-
 export type V2SessionGetData = {
   body?: never
   path: {

packages/sdk/openapi.json

@@ -10187,66 +10187,6 @@
         ]
       }
     },
-    "/api/session/active": {
-      "get": {
-        "tags": ["sessions"],
-        "operationId": "v2.session.active",
-        "parameters": [],
-        "security": [],
-        "responses": {
-          "200": {
-            "description": "Success",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "data": {
-                      "type": "object",
-                      "patternProperties": {
-                        "^ses": {
-                          "$ref": "#/components/schemas/SessionActive"
-                        }
-                      }
-                    }
-                  },
-                  "required": ["data"],
-                  "additionalProperties": false
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.",
-        "summary": "List active sessions",
-        "x-codeSamples": [
-          {
-            "lang": "js",
-            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.v2.session.active({\n  ...\n})"
-          }
-        ]
-      }
-    },
     "/api/session/{sessionID}": {
       "get": {
         "tags": ["sessions"],
@@ -23505,17 +23445,6 @@
         "required": ["_tag", "message"],
         "additionalProperties": false
       },
-      "SessionActive": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "enum": ["running"]
-          }
-        },
-        "required": ["type"],
-        "additionalProperties": false
-      },
       "SessionNotFoundError": {
         "type": "object",
         "properties": {

packages/server/src/handlers/session.ts

@@ -76,16 +76,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
-      .handle(
-        "session.active",
-        Effect.fn(function* () {
-          return {
-            data: Object.fromEntries(
-              Array.from(yield* session.active, (sessionID) => [sessionID, { type: "running" as const }]),
-            ),
-          }
-        }),
-      )
       .handle(
         "session.get",
         Effect.fn(function* (ctx) {

packages/tui/src/context/data.tsx

@@ -227,6 +227,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             if (!currentAssistant) return
             currentAssistant.time.completed = event.data.timestamp
             currentAssistant.finish = event.data.finish
+            currentAssistant.settlement = "completed"
             currentAssistant.cost = event.data.cost
             currentAssistant.tokens = event.data.tokens
             if (event.data.snapshot)
@@ -239,9 +240,18 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             if (!currentAssistant) return
             currentAssistant.time.completed = event.data.timestamp
             currentAssistant.finish = "error"
+            currentAssistant.settlement = "failed"
             currentAssistant.error = event.data.error
           })
           break
+        case "session.next.step.interrupted":
+          message.update(event.data.sessionID, (draft) => {
+            const currentAssistant = message.assistant(draft, event.data.assistantMessageID)
+            if (!currentAssistant) return
+            currentAssistant.time.completed = event.data.timestamp
+            currentAssistant.settlement = "interrupted"
+          })
+          break
         case "session.next.text.started":
           message.update(event.data.sessionID, (draft) => {
             message.assistant(draft, event.data.assistantMessageID)?.content.push({

packages/tui/test/cli/tui/data.test.tsx

@@ -370,6 +370,72 @@ test("settles pending tools when a live failure arrives", async () => {
   }
 })
 
+test("marks an interrupted assistant inactive without a finish reason", async () => {
+  const events = createEventSource()
+  const calls = createFetch(undefined, events)
+  let sync!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    sync = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    emitEvent(events, {
+      id: "evt_step_started_interrupted",
+      type: "session.next.step.started",
+      properties: {
+        sessionID: "session-interrupted",
+        assistantMessageID: "msg_interrupted",
+        timestamp: 1,
+        agent: "build",
+        model: { id: "model-1", providerID: "provider-1" },
+      },
+    })
+    emitEvent(events, {
+      id: "evt_step_interrupted",
+      type: "session.next.step.interrupted",
+      properties: {
+        sessionID: "session-interrupted",
+        assistantMessageID: "msg_interrupted",
+        timestamp: 2,
+      },
+    })
+
+    await wait(() => {
+      const message = sync.session.message.list("session-interrupted")?.[0]
+      return message?.type === "assistant" && message.time.completed === 2
+    })
+    const assistant = sync.session.message.list("session-interrupted")?.[0]
+    expect(assistant).toMatchObject({
+      type: "assistant",
+      settlement: "interrupted",
+      time: { completed: 2 },
+    })
+    expect(assistant).not.toHaveProperty("finish")
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
 test("renders admitted prompts only after they become model-visible", async () => {
   const events = createEventSource()
   const calls = createFetch(undefined, events)

packages/ui/src/v2/components/icon.tsx

@@ -49,10 +49,6 @@ const icons = {
     viewBox: "0 0 16 16",
     body: `<path d="M5 6.5L8 9.5L11 6.5" stroke="currentColor"/>`,
   },
-  check: {
-    viewBox: "0 0 16 16",
-    body: `<path d="M3.53613 8.17857L6.39328 11.75L12.4647 4.25" stroke="currentColor"/>`,
-  },
   close: {
     viewBox: "0 0 20 20",
     body: `<path d="M14.4446 5.55566L5.55566 14.4446M5.55566 5.55566L14.4446 14.4446" stroke="currentColor" stroke-linejoin="round"/>`,

specs/v2/session.md

@@ -25,11 +25,6 @@ sessions.interrupt(sessionID)
   -> clears a coalesced follow-up wake already registered with this coordinator
   -> preserves durable inbox rows for a later wake or resume
   -> idle or missing Session is a no-op
-
-sessions.active()
-  -> snapshots foreground Session drains owned by this process
-  -> returns only active Session IDs with { type: "running" }
-  -> absence means inactive; activity is not durable across process restarts
 ```
 
 `session_input` is the durable admission inbox. `PromptAdmitted` records and projects accepted input so pending queue state can be replayed, replicated, and observed by clients. Admitted inputs remain outside model-visible Session history until the serialized runner publishes `Prompted`. Its projector atomically writes the visible user message and marks the inbox row promoted in the same event transaction. The V1-to-V2 shadow bridge publishes the same `Prompted` event for already-visible V1 prompts.
@@ -166,8 +161,6 @@ Post-crash continuation recovery is intentionally deferred. A wake does not infe
 
 A process-global `SessionRunCoordinator` serializes execution for each local Session while allowing different Sessions to run concurrently. Resumes join active execution, overlapping wakes coalesce into one follow-up, and interruption stops current process-local execution without deleting durable inbox work. The runner enters the Session's current Location when execution starts and fences each new provider turn against that Location.
 
-The coordinator's active registry is also the source for `sessions.active()`. It represents only foreground Session drains owned by the current process; background subagents and tasks do not add parent Sessions to this registry. The snapshot is runtime state and is empty after a process restart.
-
 Inbox promotion coalesces pending steers in durable admission order. Once continuation would otherwise end, it promotes one queued input at a time in FIFO order. Add explicit inbox backlog and steering-batch limits before exposing broad multi-caller admission or untrusted queue growth.
 
 Eager local-tool execution is intentionally unbounded in the current local slice. This minimizes tool latency but does not increase SQLite settlement throughput: Session-event publication remains serialized per provider turn. Before broadening exposure, revisit per-turn call limits, output truncation, and operational backpressure using observed workloads. The `session.next.*` event schemas remain experimental and unshipped; databases created by earlier experimental builds are disposable rather than compatibility targets.