feat(tui): prototype tab scroll controls

bun.lock

@@ -83,7 +83,6 @@
         "@types/luxon": "catalog:",
         "@types/node": "catalog:",
         "@typescript/native-preview": "catalog:",
-        "tw-animate-css": "1.4.0",
         "typescript": "catalog:",
         "vite": "catalog:",
         "vite-plugin-icons-spritesheet": "3.0.1",
@@ -991,7 +990,6 @@
         "@typescript/native-preview": "catalog:",
         "solid-js": "catalog:",
         "tailwindcss": "catalog:",
-        "tw-animate-css": "1.4.0",
         "typescript": "catalog:",
         "vite": "catalog:",
         "vite-plugin-icons-spritesheet": "3.0.1",
@@ -5317,8 +5315,6 @@
 
     "turndown": ["turndown@7.2.0", "", { "dependencies": { "@mixmark-io/domino": "^2.2.0" } }, "sha512-eCZGBN4nNNqM9Owkv9HAtWRYfLA4h909E/WGAWWBpmB275ehNhZyk87/Tpvjbp0jjNl9XwCsbe6bm6CqFsgD+A=="],
 
-    "tw-animate-css": ["tw-animate-css@1.4.0", "", {}, "sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ=="],
-
     "tw-to-css": ["tw-to-css@0.0.12", "", { "dependencies": { "postcss": "8.4.31", "postcss-css-variables": "0.18.0", "tailwindcss": "3.3.2" } }, "sha512-rQAsQvOtV1lBkyCw+iypMygNHrShYAItES5r8fMsrhhaj5qrV2LkZyXc8ccEH+u5bFjHjQ9iuxe90I7Kykf6pw=="],
 
     "type-fest": ["type-fest@4.41.0", "", {}, "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA=="],

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-rB/CcrBUQVZ08nBFSYA8u2w88rQmTpKxKPkIreDEKgI=",
-    "aarch64-linux": "sha256-ZRTphtic8Ip96MnILteFgZAUxjK9O4YfJu2O6u/0H8k=",
-    "aarch64-darwin": "sha256-VK5XIzraP0HtqnPwPCejiDKer4ewtNtX1vxP5uuyjSk=",
-    "x86_64-darwin": "sha256-ZLPHqcCZB1EmxQk95cmUpiODTTKOyi7PSF0yr/rDk6Y="
+    "x86_64-linux": "sha256-OiWvZ57vuyHwiIKNtW1n1KX+MLmOXVG3x4fLKvUoGQw=",
+    "aarch64-linux": "sha256-RnPLxVEg/UsL5IeIFWmXMSLUOG6rVrajYxhyDYj1vTA=",
+    "aarch64-darwin": "sha256-KPIgcBA0pTFBPrCTSZgIbvEorbtWcMgXvyX9bFAypVs=",
+    "x86_64-darwin": "sha256-6jVU7/uVId0VD24MVQ8s8Ill5b6PsKdlBgHg+oceKRg="
   }
 }

packages/app/package.json

@@ -38,7 +38,6 @@
     "@types/luxon": "catalog:",
     "@types/node": "catalog:",
     "@typescript/native-preview": "catalog:",
-    "tw-animate-css": "1.4.0",
     "typescript": "catalog:",
     "vite": "catalog:",
     "vite-plugin-icons-spritesheet": "3.0.1",

packages/app/src/app.tsx

@@ -38,7 +38,7 @@ import { HighlightsProvider } from "@/context/highlights"
 import { LanguageProvider, type Locale, useLanguage } from "@/context/language"
 import { LayoutProvider } from "@/context/layout"
 import { ModelsProvider } from "@/context/models"
-import { NotificationProvider, useNotification } from "@/context/notification"
+import { NotificationProvider } from "@/context/notification"
 import { PermissionProvider } from "@/context/permission"
 import { PromptProvider } from "@/context/prompt"
 import { ServerConnection, ServerProvider, serverName, useServer } from "@/context/server"
@@ -316,7 +316,9 @@ function ServerScopedProviders(props: ServerScopedShellProps) {
   return (
     <PermissionProvider directory={props.directory}>
       <LayoutProvider>
-        <ModelsProvider directory={props.directory}>{props.children}</ModelsProvider>
+        <NotificationProvider directory={props.directory} sessionID={props.sessionID}>
+          <ModelsProvider directory={props.directory}>{props.children}</ModelsProvider>
+        </NotificationProvider>
       </LayoutProvider>
     </PermissionProvider>
   )
@@ -343,23 +345,13 @@ function NewAppLayout(props: ParentProps) {
 function TargetServerScopedProviders(props: ServerScopedShellProps) {
   return (
     <PermissionProvider directory={props.directory}>
-      <MarkSessionNotificationsViewed sessionID={props.sessionID} />
-      <ModelsProvider directory={props.directory}>{props.children}</ModelsProvider>
+      <NotificationProvider directory={props.directory} sessionID={props.sessionID}>
+        <ModelsProvider directory={props.directory}>{props.children}</ModelsProvider>
+      </NotificationProvider>
     </PermissionProvider>
   )
 }
 
-function MarkSessionNotificationsViewed(props: { sessionID?: () => string | undefined }) {
-  const notification = useNotification()
-  createEffect(() => {
-    const sessionID = props.sessionID?.()
-    if (!notification.ready() || !sessionID) return
-    if (notification.session.unseenCount(sessionID) === 0) return
-    notification.session.markViewed(sessionID)
-  })
-  return null
-}
-
 function SessionProviders(props: ParentProps) {
   return (
     <TerminalProvider>
@@ -568,13 +560,11 @@ export function AppInterface(props: {
                 component={props.router ?? Router}
                 root={(routerProps) => (
                   <TabsProvider>
-                    <NotificationProvider>
-                      <ServerShell>
-                        <Show when={useSettings().general.newLayoutDesigns()} fallback={routerProps.children}>
-                          <NewAppLayout>{routerProps.children}</NewAppLayout>
-                        </Show>
-                      </ServerShell>
-                    </NotificationProvider>
+                    <ServerShell>
+                      <Show when={useSettings().general.newLayoutDesigns()} fallback={routerProps.children}>
+                        <NewAppLayout>{routerProps.children}</NewAppLayout>
+                      </Show>
+                    </ServerShell>
                   </TabsProvider>
                 )}
               >

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

@@ -59,7 +59,6 @@ const ModelList: Component<{
           class="w-full"
           placement="right-start"
           gutter={12}
-          openDelay={0}
           value={<ModelTooltip model={item} latest={item.latest} free={isFree(item.provider.id, item.cost)} />}
         >
           {node}

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

@@ -1343,9 +1343,9 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
   }
 
   const agentsLoading = () => props.controls.agents.loading
-  const agentsShouldFadeIn = createMemo<boolean>((prev) => prev ?? agentsLoading())
+  const agentsShouldFadeIn = createMemo((prev) => prev ?? agentsLoading())
   const providersLoading = () => props.controls.model.loading
-  const providersShouldFadeIn = createMemo<boolean>((prev) => prev ?? providersLoading())
+  const providersShouldFadeIn = createMemo((prev) => prev ?? providersLoading())
 
   const [promptReady] = createResource(
     () => prompt.ready.promise,
@@ -1359,7 +1359,6 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
 
   const modelControlState = createMemo<ComposerModelControlState>(() => ({
     loading: providersLoading(),
-    shouldAnimate: providersShouldFadeIn(),
     paid: props.controls.model.paid,
     title: language.t("command.model.choose"),
     keybind: command.keybind("model.choose"),
@@ -1520,11 +1519,10 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                   </Show>
                   {props.toolbar}
                   <ComposerModelControl state={modelControlState()} />
-                  <Show when={!providersLoading() && store.mode !== "shell" && showVariantControl()}>
+                  <Show when={store.mode !== "shell" && showVariantControl()}>
                     <div
                       data-component="prompt-variant-control"
                       classList={{
-                        "animate-in fade-in": providersShouldFadeIn(),
                         "hidden group-hover/prompt-input:block group-focus-within/prompt-input:block":
                           !props.controls.model.selection.variant.current() && !store.variantOpen,
                       }}
@@ -1767,7 +1765,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                     <Show when={!agentsLoading()}>
                       <div
                         data-component="prompt-agent-control"
-                        classList={{ "animate-in fade-in duration-300": agentsShouldFadeIn() }}
+                        style={agentsShouldFadeIn() ? { animation: "fade-in 0.3s" } : undefined}
                       >
                         <TooltipKeybind
                           placement="top"
@@ -1796,7 +1794,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                       <Show when={store.mode !== "shell"}>
                         <div
                           data-component="prompt-model-control"
-                          classList={{ "animate-in fade-in duration-300": providersShouldFadeIn() }}
+                          style={providersShouldFadeIn() ? { animation: "fade-in 0.3s" } : undefined}
                         >
                           <Show
                             when={props.controls.model.paid}
@@ -1875,7 +1873,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                         <Show when={showVariantControl()}>
                           <div
                             data-component="prompt-variant-control"
-                            classList={{ "animate-in fade-in duration-300": providersShouldFadeIn() }}
+                            style={providersShouldFadeIn() ? { animation: "fade-in 0.3s" } : undefined}
                           >
                             <TooltipKeybind
                               placement="top"
@@ -1925,7 +1923,6 @@ type ComposerAgentControlState = {
 
 type ComposerModelControlState = {
   loading: boolean
-  shouldAnimate: boolean
   paid: boolean
   title: string
   keybind: string
@@ -1973,7 +1970,6 @@ function ComposerModelControl(props: { state: ComposerModelControlState }) {
               variant="ghost"
               size="normal"
               class="min-w-0 max-w-[220px] justify-start text-[13px] font-[440] leading-5 text-v2-text-text-faint group"
-              classList={{ "animate-in fade-in": props.state.shouldAnimate }}
               style={props.state.style}
               onClick={props.state.onUnpaidClick}
             >
@@ -2004,7 +2000,6 @@ function ComposerModelControl(props: { state: ComposerModelControlState }) {
               style: props.state.style,
               class:
                 "min-w-0 max-w-[220px] justify-start text-[13px] font-[440] leading-5 text-v2-text-text-faint group",
-              classList: { "animate-in fade-in": props.state.shouldAnimate },
               "data-action": "prompt-model",
             }}
             onClose={props.state.onClose}

packages/app/src/context/notification.tsx

@@ -1,9 +1,9 @@
 import { createStore, reconcile } from "solid-js/store"
-import { type Accessor, batch, createEffect, createMemo, createRoot, getOwner, onCleanup } from "solid-js"
-import { useParams, useSearchParams } from "@solidjs/router"
+import { type Accessor, batch, createEffect, createMemo, onCleanup } from "solid-js"
+import { useParams } from "@solidjs/router"
 import { createSimpleContext } from "@opencode-ai/ui/context"
-import type { ServerSDK } from "./server-sdk"
-import type { ServerSync } from "./server-sync"
+import { useServerSDK } from "./server-sdk"
+import { useServerSync } from "./server-sync"
 import { usePlatform } from "@/context/platform"
 import { useLanguage } from "@/context/language"
 import { useSettings } from "@/context/settings"
@@ -12,11 +12,6 @@ import { decode64 } from "@/utils/base64"
 import { EventSessionError } from "@opencode-ai/sdk/v2"
 import { Persist, persisted } from "@/utils/persist"
 import { playSoundById } from "@/utils/sound"
-import { useGlobal } from "./global"
-import { ServerConnection, useServer } from "./server"
-import { type DraftTab, useTabs } from "./tabs"
-import { requireServerKey } from "@/utils/session-route"
-import type { ServerScope } from "@/utils/server-scope"
 
 type NotificationBase = {
   directory?: string
@@ -112,360 +107,267 @@ function buildNotificationIndex(list: Notification[]) {
 export const { use: useNotification, provider: NotificationProvider } = createSimpleContext({
   name: "Notification",
   gate: false,
-  init: () => {
-    const params = useParams<{ serverKey?: string; dir?: string; id?: string }>()
-    const [search] = useSearchParams<{ draftId?: string }>()
-    const global = useGlobal()
-    const server = useServer()
-    const tabs = useTabs()
+  init: (props: { directory?: Accessor<string | undefined>; sessionID?: Accessor<string | undefined> }) => {
+    const params = useParams()
+    const serverSDK = useServerSDK()
+    const serverSync = useServerSync()
     const platform = usePlatform()
     const settings = useSettings()
     const language = useLanguage()
-    const owner = getOwner()
-    const states = new Map<ServerScope, { dispose: () => void; state: NotificationState }>()
 
-    const activeServer = createMemo(() => {
-      if (params.serverKey) return requireServerKey(params.serverKey)
-      if (search.draftId) {
-        const draft = tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)
-        if (draft) return draft.server
-      }
-      return server.key
+    const empty: Notification[] = []
+
+    const currentDirectory = createMemo(() => {
+      return props.directory?.() ?? decode64(params.dir)
     })
-    const activeDirectory = createMemo(() => decode64(params.dir))
-    const activeSession = createMemo(() => params.id)
 
-    const ensure = (key: ServerConnection.Key) => {
-      const conn = global.servers.list().find((item) => ServerConnection.key(item) === key)
-      if (!conn) throw new Error(`Notification server not found: ${key}`)
-      const ctx = global.ensureServerCtx(conn)
-      const existing = states.get(ctx.sdk.scope)
-      if (existing) return existing.state
-      const root = createRoot(
-        (dispose) => ({
-          dispose,
-          state: createServerNotificationState({
-            sdk: ctx.sdk,
-            sync: ctx.sync,
-            active: () => server.scope(activeServer()) === ctx.sdk.scope,
-            directory: activeDirectory,
-            sessionID: activeSession,
-            platform,
-            settings,
-            language,
-          }),
-        }),
-        owner ?? undefined,
+    const currentSession = createMemo(() => props.sessionID?.() ?? params.id)
+
+    const [store, setStore, _, ready] = persisted(
+      Persist.serverGlobal(serverSDK().scope, "notification", ["notification.v1"]),
+      createStore({
+        list: [] as Notification[],
+      }),
+    )
+    const [index, setIndex] = createStore<NotificationIndex>(buildNotificationIndex(store.list))
+
+    const meta = { pruned: false, disposed: false }
+
+    const updateUnseen = (scope: "session" | "project", key: string, unseen: Notification[]) => {
+      setIndex(scope, "unseen", key, unseen)
+      setIndex(scope, "unseenCount", key, unseen.length)
+      setIndex(
+        scope,
+        "unseenHasError",
+        key,
+        unseen.some((notification) => notification.type === "error"),
       )
-      states.set(ctx.sdk.scope, root)
-      return root.state
+    }
+
+    const appendToIndex = (notification: Notification) => {
+      if (notification.session) {
+        setIndex("session", "all", notification.session, (all = []) => [...all, notification])
+        if (!notification.viewed) {
+          setIndex("session", "unseen", notification.session, (unseen = []) => [...unseen, notification])
+          setIndex("session", "unseenCount", notification.session, (count = 0) => count + 1)
+          if (notification.type === "error") setIndex("session", "unseenHasError", notification.session, true)
+        }
+      }
+
+      if (notification.directory) {
+        setIndex("project", "all", notification.directory, (all = []) => [...all, notification])
+        if (!notification.viewed) {
+          setIndex("project", "unseen", notification.directory, (unseen = []) => [...unseen, notification])
+          setIndex("project", "unseenCount", notification.directory, (count = 0) => count + 1)
+          if (notification.type === "error") setIndex("project", "unseenHasError", notification.directory, true)
+        }
+      }
+    }
+
+    const removeFromIndex = (notification: Notification) => {
+      if (notification.session) {
+        setIndex("session", "all", notification.session, (all = []) => all.filter((n) => n !== notification))
+        if (!notification.viewed) {
+          const unseen = (index.session.unseen[notification.session] ?? empty).filter((n) => n !== notification)
+          updateUnseen("session", notification.session, unseen)
+        }
+      }
+
+      if (notification.directory) {
+        setIndex("project", "all", notification.directory, (all = []) => all.filter((n) => n !== notification))
+        if (!notification.viewed) {
+          const unseen = (index.project.unseen[notification.directory] ?? empty).filter((n) => n !== notification)
+          updateUnseen("project", notification.directory, unseen)
+        }
+      }
     }
 
     createEffect(() => {
-      global.servers.list().forEach((conn) => ensure(ServerConnection.key(conn)))
-    })
-
-    createEffect(() => {
-      const scopes = new Set(global.servers.list().map((conn) => server.scope(ServerConnection.key(conn))))
-      states.forEach((value, scope) => {
-        if (scopes.has(scope)) return
-        value.dispose()
-        states.delete(scope)
+      if (!ready()) return
+      if (meta.pruned) return
+      meta.pruned = true
+      const list = pruneNotifications(store.list)
+      batch(() => {
+        setStore("list", list)
+        setIndex(reconcile(buildNotificationIndex(list), { merge: false }))
       })
     })
 
-    onCleanup(() => states.forEach((value) => value.dispose()))
+    const append = (notification: Notification) => {
+      const list = pruneNotifications([...store.list, notification])
+      const keep = new Set(list)
+      const removed = store.list.filter((n) => !keep.has(n))
 
-    const selected = () => ensure(activeServer())
+      batch(() => {
+        if (keep.has(notification)) appendToIndex(notification)
+        removed.forEach((n) => removeFromIndex(n))
+        setStore("list", list)
+      })
+    }
+
+    const lookup = async (directory: string, sessionID?: string) => {
+      if (!sessionID) return undefined
+      const sync = serverSync().ensureDirSyncContext(directory)
+      const session = sync.session.get(sessionID)
+      if (session) return session
+      return sync.session
+        .sync(sessionID)
+        .then(() => sync.session.get(sessionID))
+        .catch(() => undefined)
+    }
+
+    const viewedInCurrentSession = (directory: string, sessionID?: string) => {
+      const activeDirectory = currentDirectory()
+      const activeSession = currentSession()
+      if (!activeDirectory) return false
+      if (!activeSession) return false
+      if (!sessionID) return false
+      if (directory !== activeDirectory) return false
+      return sessionID === activeSession
+    }
+
+    const handleSessionIdle = (directory: string, event: { properties: { sessionID?: string } }, time: number) => {
+      const sessionID = event.properties.sessionID
+      void lookup(directory, sessionID).then((session) => {
+        if (meta.disposed) return
+        if (!session) return
+        if (session.parentID) return
+
+        if (settings.sounds.agentEnabled()) {
+          void playSoundById(settings.sounds.agent())
+        }
+
+        append({
+          directory,
+          time,
+          viewed: viewedInCurrentSession(directory, sessionID),
+          type: "turn-complete",
+          session: sessionID,
+        })
+
+        const href = `/${base64Encode(directory)}/session/${sessionID}`
+        if (settings.notifications.agent()) {
+          void platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, href)
+        }
+      })
+    }
+
+    const handleSessionError = (
+      directory: string,
+      event: { properties: { sessionID?: string; error?: EventSessionError["properties"]["error"] } },
+      time: number,
+    ) => {
+      const sessionID = event.properties.sessionID
+      void lookup(directory, sessionID).then((session) => {
+        if (meta.disposed) return
+        if (session?.parentID) return
+
+        if (settings.sounds.errorsEnabled()) {
+          void playSoundById(settings.sounds.errors())
+        }
+
+        const error = "error" in event.properties ? event.properties.error : undefined
+        append({
+          directory,
+          time,
+          viewed: viewedInCurrentSession(directory, sessionID),
+          type: "error",
+          session: sessionID ?? "global",
+          error,
+        })
+        const description =
+          session?.title ??
+          (typeof error === "string" ? error : language.t("notification.session.error.fallbackDescription"))
+        const href = sessionID ? `/${base64Encode(directory)}/session/${sessionID}` : `/${base64Encode(directory)}`
+        if (settings.notifications.errors()) {
+          void platform.notify(language.t("notification.session.error.title"), description, href)
+        }
+      })
+    }
+
+    const unsub = serverSDK().event.listen((e) => {
+      const event = e.details
+      if (event.type !== "session.idle" && event.type !== "session.error") return
+
+      const directory = e.name
+      const time = Date.now()
+      if (event.type === "session.idle") {
+        handleSessionIdle(directory, event, time)
+        return
+      }
+      handleSessionError(directory, event, time)
+    })
+    onCleanup(() => {
+      meta.disposed = true
+      unsub()
+    })
 
     return {
-      ready: () => selected().ready(),
-      ensureServerState: ensure,
+      ready,
       session: {
-        all: (session: string) => selected().session.all(session),
-        unseen: (session: string) => selected().session.unseen(session),
-        unseenCount: (session: string) => selected().session.unseenCount(session),
-        unseenHasError: (session: string) => selected().session.unseenHasError(session),
-        markViewed: (session: string) => selected().session.markViewed(session),
+        all(session: string) {
+          return index.session.all[session] ?? empty
+        },
+        unseen(session: string) {
+          return index.session.unseen[session] ?? empty
+        },
+        unseenCount(session: string) {
+          return index.session.unseenCount[session] ?? 0
+        },
+        unseenHasError(session: string) {
+          return index.session.unseenHasError[session] ?? false
+        },
+        markViewed(session: string) {
+          const unseen = index.session.unseen[session] ?? empty
+          if (!unseen.length) return
+
+          const projects = [
+            ...new Set(unseen.flatMap((notification) => (notification.directory ? [notification.directory] : []))),
+          ]
+          batch(() => {
+            setStore("list", (n) => n.session === session && !n.viewed, "viewed", true)
+            updateUnseen("session", session, [])
+            projects.forEach((directory) => {
+              const next = (index.project.unseen[directory] ?? empty).filter(
+                (notification) => notification.session !== session,
+              )
+              updateUnseen("project", directory, next)
+            })
+          })
+        },
       },
       project: {
-        all: (directory: string) => selected().project.all(directory),
-        unseen: (directory: string) => selected().project.unseen(directory),
-        unseenCount: (directory: string) => selected().project.unseenCount(directory),
-        unseenHasError: (directory: string) => selected().project.unseenHasError(directory),
-        markViewed: (directory: string) => selected().project.markViewed(directory),
+        all(directory: string) {
+          return index.project.all[directory] ?? empty
+        },
+        unseen(directory: string) {
+          return index.project.unseen[directory] ?? empty
+        },
+        unseenCount(directory: string) {
+          return index.project.unseenCount[directory] ?? 0
+        },
+        unseenHasError(directory: string) {
+          return index.project.unseenHasError[directory] ?? false
+        },
+        markViewed(directory: string) {
+          const unseen = index.project.unseen[directory] ?? empty
+          if (!unseen.length) return
+
+          const sessions = [
+            ...new Set(unseen.flatMap((notification) => (notification.session ? [notification.session] : []))),
+          ]
+          batch(() => {
+            setStore("list", (n) => n.directory === directory && !n.viewed, "viewed", true)
+            updateUnseen("project", directory, [])
+            sessions.forEach((session) => {
+              const next = (index.session.unseen[session] ?? empty).filter(
+                (notification) => notification.directory !== directory,
+              )
+              updateUnseen("session", session, next)
+            })
+          })
+        },
       },
     }
   },
 })
-
-type NotificationState = ReturnType<typeof createServerNotificationState>
-
-function createServerNotificationState(input: {
-  sdk: ServerSDK
-  sync: ServerSync
-  active: Accessor<boolean>
-  directory: Accessor<string | undefined>
-  sessionID: Accessor<string | undefined>
-  platform: ReturnType<typeof usePlatform>
-  settings: ReturnType<typeof useSettings>
-  language: ReturnType<typeof useLanguage>
-}) {
-  const serverSDK = () => input.sdk
-  const serverSync = () => input.sync
-  const platform = input.platform
-  const settings = input.settings
-  const language = input.language
-
-  const empty: Notification[] = []
-
-  const currentDirectory = input.directory
-  const currentSession = input.sessionID
-
-  const [store, setStore, _, ready] = persisted(
-    Persist.serverGlobal(serverSDK().scope, "notification", ["notification.v1"]),
-    createStore({
-      list: [] as Notification[],
-    }),
-  )
-  const [index, setIndex] = createStore<NotificationIndex>(buildNotificationIndex(store.list))
-
-  const meta = { pruned: false, disposed: false }
-
-  const updateUnseen = (scope: "session" | "project", key: string, unseen: Notification[]) => {
-    setIndex(scope, "unseen", key, unseen)
-    setIndex(scope, "unseenCount", key, unseen.length)
-    setIndex(
-      scope,
-      "unseenHasError",
-      key,
-      unseen.some((notification) => notification.type === "error"),
-    )
-  }
-
-  const appendToIndex = (notification: Notification) => {
-    if (notification.session) {
-      setIndex("session", "all", notification.session, (all = []) => [...all, notification])
-      if (!notification.viewed) {
-        setIndex("session", "unseen", notification.session, (unseen = []) => [...unseen, notification])
-        setIndex("session", "unseenCount", notification.session, (count = 0) => count + 1)
-        if (notification.type === "error") setIndex("session", "unseenHasError", notification.session, true)
-      }
-    }
-
-    if (notification.directory) {
-      setIndex("project", "all", notification.directory, (all = []) => [...all, notification])
-      if (!notification.viewed) {
-        setIndex("project", "unseen", notification.directory, (unseen = []) => [...unseen, notification])
-        setIndex("project", "unseenCount", notification.directory, (count = 0) => count + 1)
-        if (notification.type === "error") setIndex("project", "unseenHasError", notification.directory, true)
-      }
-    }
-  }
-
-  const removeFromIndex = (notification: Notification) => {
-    if (notification.session) {
-      setIndex("session", "all", notification.session, (all = []) => all.filter((n) => n !== notification))
-      if (!notification.viewed) {
-        const unseen = (index.session.unseen[notification.session] ?? empty).filter((n) => n !== notification)
-        updateUnseen("session", notification.session, unseen)
-      }
-    }
-
-    if (notification.directory) {
-      setIndex("project", "all", notification.directory, (all = []) => all.filter((n) => n !== notification))
-      if (!notification.viewed) {
-        const unseen = (index.project.unseen[notification.directory] ?? empty).filter((n) => n !== notification)
-        updateUnseen("project", notification.directory, unseen)
-      }
-    }
-  }
-
-  createEffect(() => {
-    if (!ready()) return
-    if (meta.pruned) return
-    meta.pruned = true
-    const list = pruneNotifications(store.list)
-    batch(() => {
-      setStore("list", list)
-      setIndex(reconcile(buildNotificationIndex(list), { merge: false }))
-    })
-  })
-
-  const append = (notification: Notification) => {
-    const list = pruneNotifications([...store.list, notification])
-    const keep = new Set(list)
-    const removed = store.list.filter((n) => !keep.has(n))
-
-    batch(() => {
-      if (keep.has(notification)) appendToIndex(notification)
-      removed.forEach((n) => removeFromIndex(n))
-      setStore("list", list)
-    })
-  }
-
-  const lookup = async (directory: string, sessionID?: string) => {
-    if (!sessionID) return undefined
-    const sync = serverSync().ensureDirSyncContext(directory)
-    const session = sync.session.get(sessionID)
-    if (session) return session
-    return sync.session
-      .sync(sessionID)
-      .then(() => sync.session.get(sessionID))
-      .catch(() => undefined)
-  }
-
-  const viewedInCurrentSession = (directory: string, sessionID?: string) => {
-    if (!input.active()) return false
-    const activeDirectory = currentDirectory()
-    const activeSession = currentSession()
-    if (!activeSession) return false
-    if (!sessionID) return false
-    if (activeDirectory && directory !== activeDirectory) return false
-    return sessionID === activeSession
-  }
-
-  const handleSessionIdle = (directory: string, event: { properties: { sessionID?: string } }, time: number) => {
-    const sessionID = event.properties.sessionID
-    void lookup(directory, sessionID).then((session) => {
-      if (meta.disposed) return
-      if (!session) return
-      if (session.parentID) return
-
-      if (settings.sounds.agentEnabled()) {
-        void playSoundById(settings.sounds.agent())
-      }
-
-      append({
-        directory,
-        time,
-        viewed: viewedInCurrentSession(directory, sessionID),
-        type: "turn-complete",
-        session: sessionID,
-      })
-
-      const href = `/${base64Encode(directory)}/session/${sessionID}`
-      if (settings.notifications.agent()) {
-        void platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, href)
-      }
-    })
-  }
-
-  const handleSessionError = (
-    directory: string,
-    event: { properties: { sessionID?: string; error?: EventSessionError["properties"]["error"] } },
-    time: number,
-  ) => {
-    const sessionID = event.properties.sessionID
-    void lookup(directory, sessionID).then((session) => {
-      if (meta.disposed) return
-      if (session?.parentID) return
-
-      if (settings.sounds.errorsEnabled()) {
-        void playSoundById(settings.sounds.errors())
-      }
-
-      const error = "error" in event.properties ? event.properties.error : undefined
-      append({
-        directory,
-        time,
-        viewed: viewedInCurrentSession(directory, sessionID),
-        type: "error",
-        session: sessionID ?? "global",
-        error,
-      })
-      const description =
-        session?.title ??
-        (typeof error === "string" ? error : language.t("notification.session.error.fallbackDescription"))
-      const href = sessionID ? `/${base64Encode(directory)}/session/${sessionID}` : `/${base64Encode(directory)}`
-      if (settings.notifications.errors()) {
-        void platform.notify(language.t("notification.session.error.title"), description, href)
-      }
-    })
-  }
-
-  const unsub = serverSDK().event.listen((e) => {
-    const event = e.details
-    if (event.type !== "session.idle" && event.type !== "session.error") return
-
-    const directory = e.name
-    const time = Date.now()
-    if (event.type === "session.idle") {
-      handleSessionIdle(directory, event, time)
-      return
-    }
-    handleSessionError(directory, event, time)
-  })
-  onCleanup(() => {
-    meta.disposed = true
-    unsub()
-  })
-
-  return {
-    ready,
-    session: {
-      all(session: string) {
-        return index.session.all[session] ?? empty
-      },
-      unseen(session: string) {
-        return index.session.unseen[session] ?? empty
-      },
-      unseenCount(session: string) {
-        return index.session.unseenCount[session] ?? 0
-      },
-      unseenHasError(session: string) {
-        return index.session.unseenHasError[session] ?? false
-      },
-      markViewed(session: string) {
-        const unseen = index.session.unseen[session] ?? empty
-        if (!unseen.length) return
-
-        const projects = [
-          ...new Set(unseen.flatMap((notification) => (notification.directory ? [notification.directory] : []))),
-        ]
-        batch(() => {
-          setStore("list", (n) => n.session === session && !n.viewed, "viewed", true)
-          updateUnseen("session", session, [])
-          projects.forEach((directory) => {
-            const next = (index.project.unseen[directory] ?? empty).filter(
-              (notification) => notification.session !== session,
-            )
-            updateUnseen("project", directory, next)
-          })
-        })
-      },
-    },
-    project: {
-      all(directory: string) {
-        return index.project.all[directory] ?? empty
-      },
-      unseen(directory: string) {
-        return index.project.unseen[directory] ?? empty
-      },
-      unseenCount(directory: string) {
-        return index.project.unseenCount[directory] ?? 0
-      },
-      unseenHasError(directory: string) {
-        return index.project.unseenHasError[directory] ?? false
-      },
-      markViewed(directory: string) {
-        const unseen = index.project.unseen[directory] ?? empty
-        if (!unseen.length) return
-
-        const sessions = [
-          ...new Set(unseen.flatMap((notification) => (notification.session ? [notification.session] : []))),
-        ]
-        batch(() => {
-          setStore("list", (n) => n.directory === directory && !n.viewed, "viewed", true)
-          updateUnseen("project", directory, [])
-          sessions.forEach((session) => {
-            const next = (index.session.unseen[session] ?? empty).filter(
-              (notification) => notification.directory !== directory,
-            )
-            updateUnseen("session", session, next)
-          })
-        })
-      },
-    },
-  }
-}

packages/app/src/index.css

@@ -1,7 +1,6 @@
 @import "@opencode-ai/ui/styles/tailwind";
 @import "@opencode-ai/session-ui/styles";
 @import "@opencode-ai/ui/v2/styles/tailwind.css";
-@import "tw-animate-css";
 
 @font-face {
   font-family: "JetBrainsMono Nerd Font Mono";
@@ -132,4 +131,13 @@
       transform: rotate(360deg);
     }
   }
+
+  @keyframes fade-in {
+    from {
+      opacity: 0;
+    }
+    to {
+      opacity: 1;
+    }
+  }
 }

packages/app/src/pages/home.tsx

@@ -341,15 +341,15 @@ export function NewHome() {
   }
 
   function unseenCount(conn: ServerConnection.Any, project: LocalProject) {
-    const state = notification.ensureServerState(ServerConnection.key(conn))
-    return directories(project).reduce((total, directory) => total + state.project.unseenCount(directory), 0)
+    if (ServerConnection.key(conn) !== server.key) return 0
+    return directories(project).reduce((total, directory) => total + notification.project.unseenCount(directory), 0)
   }
 
   function clearNotifications(conn: ServerConnection.Any, project: LocalProject) {
-    const state = notification.ensureServerState(ServerConnection.key(conn))
+    if (ServerConnection.key(conn) !== server.key) return
     directories(project)
-      .filter((directory) => state.project.unseenCount(directory) > 0)
-      .forEach((directory) => state.project.markViewed(directory))
+      .filter((directory) => notification.project.unseenCount(directory) > 0)
+      .forEach((directory) => notification.project.markViewed(directory))
   }
 
   function openSession(session: Session) {

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

@@ -1,18 +1,26 @@
 import { createEffect, Suspense, type ParentProps } from "solid-js"
-import { useNavigate } from "@solidjs/router"
+import { useNavigate, useParams } from "@solidjs/router"
 import { DebugBar } from "@/components/debug-bar"
 import { HelpButton } from "@/components/help-button"
 import { Titlebar, type TitlebarUpdate } from "@/components/titlebar"
+import { useNotification } from "@/context/notification"
 import { usePlatform } from "@/context/platform"
 import { setNavigate } from "@/utils/notification-click"
 import { setV2Toast, ToastRegion } from "@/utils/toast"
 
 export default function NewLayout(props: ParentProps) {
   const platform = usePlatform()
+  const notification = useNotification()
   const navigate = useNavigate()
+  const params = useParams<{ id?: string }>()
   setNavigate(navigate)
 
   createEffect(() => setV2Toast(true))
+  createEffect(() => {
+    if (!notification.ready() || !params.id) return
+    if (notification.session.unseenCount(params.id) === 0) return
+    notification.session.markViewed(params.id)
+  })
 
   const update: TitlebarUpdate = {
     version: () => {

packages/client/script/build.ts

@@ -1,29 +1,20 @@
 import { NodeFileSystem } from "@effect/platform-node"
 import { compile, emitEffectImported, emitPromise, write } from "@opencode-ai/httpapi-codegen"
-import { ClientApi } from "../src/contract"
+import { Api } from "@opencode-ai/server/api"
 import { Effect } from "effect"
+import { HttpApi } from "effect/unstable/httpapi"
 import { fileURLToPath } from "url"
 
-const contract = compile(ClientApi, {
-  groupNames: { "server.session": "sessions", "server.event": "events" },
+const contract = compile(HttpApi.make("opencode-client").add(Api.groups["server.session"]), {
+  groupNames: { "server.session": "sessions" },
 })
 
 await Effect.runPromise(
   Effect.all(
     [
+      write(emitPromise(contract), fileURLToPath(new URL("../src/generated", import.meta.url))),
       write(
-        emitPromise(contract, {
-          outputTypes: {
-            "events.subscribe": {
-              name: "OpenCodeEventEncoded",
-              import: 'import type { OpenCodeEventEncoded } from "@opencode-ai/protocol/groups/event"',
-            },
-          },
-        }),
-        fileURLToPath(new URL("../src/generated", import.meta.url)),
-      ),
-      write(
-        emitEffectImported(contract, { module: "../contract", api: "ClientApi" }),
+        emitEffectImported(contract, { module: "../contract", group: "SessionGroup" }),
         fileURLToPath(new URL("../src/generated-effect", import.meta.url)),
       ),
     ],

packages/client/src/contract.ts

@@ -1,6 +1,6 @@
 import { makeDefaultApi } from "@opencode-ai/protocol/api"
 import { InvalidRequestError, SessionNotFoundError } from "@opencode-ai/protocol/errors"
-import { HttpApi, HttpApiMiddleware } from "effect/unstable/httpapi"
+import { HttpApiMiddleware } from "effect/unstable/httpapi"
 
 class LocationMiddleware extends HttpApiMiddleware.Service<LocationMiddleware>()(
   "@opencode-ai/client/LocationMiddleware",
@@ -17,5 +17,3 @@ const Api = makeDefaultApi({
 })
 
 export const SessionGroup = Api.groups["server.session"]
-export const EventGroup = Api.groups["server.event"]
-export const ClientApi = HttpApi.make("opencode-client").add(SessionGroup).add(EventGroup)

packages/client/src/effect.ts

@@ -10,4 +10,3 @@ export { Session } from "@opencode-ai/schema/session"
 export { SessionInput } from "@opencode-ai/schema/session-input"
 export { SessionMessage } from "@opencode-ai/schema/session-message"
 export { Prompt } from "@opencode-ai/schema/prompt"
-export type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"

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

@@ -2,11 +2,13 @@
 import { Effect, Stream, Schema } from "effect"
 import { Sse } from "effect/unstable/encoding"
 import { HttpClientError } from "effect/unstable/http"
-import { HttpApiClient } from "effect/unstable/httpapi"
-import { ClientApi } from "../contract"
+import { HttpApi, HttpApiClient } from "effect/unstable/httpapi"
+import { SessionGroup } from "../contract"
 import { ClientError } from "./client-error"
 
-type RawClient = HttpApiClient.ForApi<typeof ClientApi>
+const Api = HttpApi.make("generated").add(SessionGroup)
+
+type RawClient = HttpApiClient.ForApi<typeof Api>
 
 const mapClientError = <E>(error: E) =>
   HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error)
@@ -147,24 +149,12 @@ const Endpoint0_12 = (raw: RawClient["server.session"]) => (input: Endpoint0_12I
     Effect.map((value) => value.data),
   )
 
-type Endpoint0_13Request = Parameters<RawClient["server.session"]["session.history"]>[0]
+type Endpoint0_13Request = Parameters<RawClient["server.session"]["session.events"]>[0]
 type Endpoint0_13Input = {
   readonly sessionID: Endpoint0_13Request["params"]["sessionID"]
-  readonly limit?: Endpoint0_13Request["query"]["limit"]
   readonly after?: Endpoint0_13Request["query"]["after"]
 }
 const Endpoint0_13 = (raw: RawClient["server.session"]) => (input: Endpoint0_13Input) =>
-  raw["session.history"]({
-    params: { sessionID: input.sessionID },
-    query: { limit: input.limit, after: input.after },
-  }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint0_14Request = Parameters<RawClient["server.session"]["session.events"]>[0]
-type Endpoint0_14Input = {
-  readonly sessionID: Endpoint0_14Request["params"]["sessionID"]
-  readonly after?: Endpoint0_14Request["query"]["after"]
-}
-const Endpoint0_14 = (raw: RawClient["server.session"]) => (input: Endpoint0_14Input) =>
   Stream.unwrap(
     raw["session.events"]({ params: { sessionID: input.sessionID }, query: { after: input.after } }).pipe(
       Effect.mapError(mapClientError),
@@ -172,17 +162,17 @@ const Endpoint0_14 = (raw: RawClient["server.session"]) => (input: Endpoint0_14I
     ),
   )
 
-type Endpoint0_15Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint0_15Input = { readonly sessionID: Endpoint0_15Request["params"]["sessionID"] }
-const Endpoint0_15 = (raw: RawClient["server.session"]) => (input: Endpoint0_15Input) =>
+type Endpoint0_14Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint0_14Input = { readonly sessionID: Endpoint0_14Request["params"]["sessionID"] }
+const Endpoint0_14 = (raw: RawClient["server.session"]) => (input: Endpoint0_14Input) =>
   raw["session.interrupt"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint0_16Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint0_16Input = {
-  readonly sessionID: Endpoint0_16Request["params"]["sessionID"]
-  readonly messageID: Endpoint0_16Request["params"]["messageID"]
+type Endpoint0_15Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint0_15Input = {
+  readonly sessionID: Endpoint0_15Request["params"]["sessionID"]
+  readonly messageID: Endpoint0_15Request["params"]["messageID"]
 }
-const Endpoint0_16 = (raw: RawClient["server.session"]) => (input: Endpoint0_16Input) =>
+const Endpoint0_15 = (raw: RawClient["server.session"]) => (input: Endpoint0_15Input) =>
   raw["session.message"]({ params: { sessionID: input.sessionID, messageID: input.messageID } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
@@ -202,26 +192,12 @@ const adaptGroup0 = (raw: RawClient["server.session"]) => ({
   clear: Endpoint0_10(raw),
   commit: Endpoint0_11(raw),
   context: Endpoint0_12(raw),
-  history: Endpoint0_13(raw),
-  events: Endpoint0_14(raw),
-  interrupt: Endpoint0_15(raw),
-  message: Endpoint0_16(raw),
+  events: Endpoint0_13(raw),
+  interrupt: Endpoint0_14(raw),
+  message: Endpoint0_15(raw),
 })
 
-const Endpoint1_0 = (raw: RawClient["server.event"]) => () =>
-  Stream.unwrap(
-    raw["event.subscribe"]({}).pipe(
-      Effect.mapError(mapClientError),
-      Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))),
-    ),
-  )
-
-const adaptGroup1 = (raw: RawClient["server.event"]) => ({ subscribe: Endpoint1_0(raw) })
-
-const adaptClient = (raw: RawClient) => ({
-  sessions: adaptGroup0(raw["server.session"]),
-  events: adaptGroup1(raw["server.event"]),
-})
+const adaptClient = (raw: RawClient) => ({ sessions: adaptGroup0(raw["server.session"]) })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>
-  HttpApiClient.make(ClientApi, options).pipe(Effect.map(adaptClient))
+  HttpApiClient.make(Api, options).pipe(Effect.map(adaptClient))

packages/client/src/generated/client.ts

@@ -24,15 +24,12 @@ import type {
   SessionsCommitOutput,
   SessionsContextInput,
   SessionsContextOutput,
-  SessionsHistoryInput,
-  SessionsHistoryOutput,
   SessionsEventsInput,
   SessionsEventsOutput,
   SessionsInterruptInput,
   SessionsInterruptOutput,
   SessionsMessageInput,
   SessionsMessageOutput,
-  EventsSubscribeOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -327,18 +324,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      history: (input: SessionsHistoryInput, requestOptions?: RequestOptions) =>
-        request<SessionsHistoryOutput>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/history`,
-            query: { limit: input.limit, after: input.after },
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
       events: (input: SessionsEventsInput, requestOptions?: RequestOptions): AsyncIterable<SessionsEventsOutput> =>
         sse<SessionsEventsOutput>(
           {
@@ -374,13 +359,6 @@ export function make(options: ClientOptions) {
           requestOptions,
         ).then((value) => value.data),
     },
-    events: {
-      subscribe: (requestOptions?: RequestOptions): AsyncIterable<EventsSubscribeOutput> =>
-        sse<EventsSubscribeOutput>(
-          { method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
-          requestOptions,
-        ),
-    },
   }
 }
 

packages/client/src/generated/types.ts

@@ -1,5 +1,3 @@
-import type { OpenCodeEventEncoded } from "@opencode-ai/protocol/groups/event"
-
 export type JsonValue =
   | null
   | boolean
@@ -69,7 +67,7 @@ export const isUnknownError = (value: unknown): value is UnknownError =>
 export type SessionsListInput = {
   readonly workspace?: {
     readonly workspace?: string | undefined
-    readonly limit?: number | undefined
+    readonly limit?: string | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly search?: string | undefined
     readonly directory?: string | undefined
@@ -79,7 +77,7 @@ export type SessionsListInput = {
   }["workspace"]
   readonly limit?: {
     readonly workspace?: string | undefined
-    readonly limit?: number | undefined
+    readonly limit?: string | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly search?: string | undefined
     readonly directory?: string | undefined
@@ -89,7 +87,7 @@ export type SessionsListInput = {
   }["limit"]
   readonly order?: {
     readonly workspace?: string | undefined
-    readonly limit?: number | undefined
+    readonly limit?: string | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly search?: string | undefined
     readonly directory?: string | undefined
@@ -99,7 +97,7 @@ export type SessionsListInput = {
   }["order"]
   readonly search?: {
     readonly workspace?: string | undefined
-    readonly limit?: number | undefined
+    readonly limit?: string | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly search?: string | undefined
     readonly directory?: string | undefined
@@ -109,7 +107,7 @@ export type SessionsListInput = {
   }["search"]
   readonly directory?: {
     readonly workspace?: string | undefined
-    readonly limit?: number | undefined
+    readonly limit?: string | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly search?: string | undefined
     readonly directory?: string | undefined
@@ -119,7 +117,7 @@ export type SessionsListInput = {
   }["directory"]
   readonly project?: {
     readonly workspace?: string | undefined
-    readonly limit?: number | undefined
+    readonly limit?: string | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly search?: string | undefined
     readonly directory?: string | undefined
@@ -129,7 +127,7 @@ export type SessionsListInput = {
   }["project"]
   readonly subpath?: {
     readonly workspace?: string | undefined
-    readonly limit?: number | undefined
+    readonly limit?: string | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly search?: string | undefined
     readonly directory?: string | undefined
@@ -139,7 +137,7 @@ export type SessionsListInput = {
   }["subpath"]
   readonly cursor?: {
     readonly workspace?: string | undefined
-    readonly limit?: number | undefined
+    readonly limit?: string | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly search?: string | undefined
     readonly directory?: string | undefined
@@ -307,6 +305,7 @@ export type SessionsPromptInput = {
       readonly text: string
       readonly files?: ReadonlyArray<{
         readonly uri: string
+        readonly mime: string
         readonly name?: string
         readonly description?: string
         readonly source?: { readonly start: number; readonly end: number; readonly text: string }
@@ -325,6 +324,7 @@ export type SessionsPromptInput = {
       readonly text: string
       readonly files?: ReadonlyArray<{
         readonly uri: string
+        readonly mime: string
         readonly name?: string
         readonly description?: string
         readonly source?: { readonly start: number; readonly end: number; readonly text: string }
@@ -343,6 +343,7 @@ export type SessionsPromptInput = {
       readonly text: string
       readonly files?: ReadonlyArray<{
         readonly uri: string
+        readonly mime: string
         readonly name?: string
         readonly description?: string
         readonly source?: { readonly start: number; readonly end: number; readonly text: string }
@@ -361,6 +362,7 @@ export type SessionsPromptInput = {
       readonly text: string
       readonly files?: ReadonlyArray<{
         readonly uri: string
+        readonly mime: string
         readonly name?: string
         readonly description?: string
         readonly source?: { readonly start: number; readonly end: number; readonly text: string }
@@ -593,469 +595,9 @@ export type SessionsContextOutput = {
   >
 }["data"]
 
-export type SessionsHistoryInput = {
-  readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly limit?: { readonly limit?: number | undefined; readonly after?: number | undefined }["limit"]
-  readonly after?: { readonly limit?: number | undefined; readonly after?: number | undefined }["after"]
-}
-
-export type SessionsHistoryOutput = {
-  readonly data: ReadonlyArray<
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.agent.switched"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly agent: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.model.switched"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.moved"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly location: { readonly directory: string; readonly workspaceID?: string }
-          readonly subdirectory?: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.prompted"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly prompt: {
-            readonly text: string
-            readonly files?: ReadonlyArray<{
-              readonly uri: string
-              readonly mime: string
-              readonly name?: string
-              readonly description?: string
-              readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-            }>
-            readonly agents?: ReadonlyArray<{
-              readonly name: string
-              readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-            }>
-          }
-          readonly delivery: "steer" | "queue"
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.prompt.admitted"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly prompt: {
-            readonly text: string
-            readonly files?: ReadonlyArray<{
-              readonly uri: string
-              readonly mime: string
-              readonly name?: string
-              readonly description?: string
-              readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-            }>
-            readonly agents?: ReadonlyArray<{
-              readonly name: string
-              readonly source?: { readonly start: number; readonly end: number; readonly text: string }
-            }>
-          }
-          readonly delivery: "steer" | "queue"
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.context.updated"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly text: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.synthetic"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly text: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.shell.started"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly callID: string
-          readonly command: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.shell.ended"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly callID: string
-          readonly output: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.step.started"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly agent: string
-          readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-          readonly snapshot?: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.step.ended"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly finish: string
-          readonly cost: number
-          readonly tokens: {
-            readonly input: number
-            readonly output: number
-            readonly reasoning: number
-            readonly cache: { readonly read: number; readonly write: number }
-          }
-          readonly snapshot?: string
-          readonly files?: ReadonlyArray<string>
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.step.failed"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly error: { readonly type: "unknown"; readonly message: string }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.text.started"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly textID: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.text.ended"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly textID: string
-          readonly text: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.tool.input.started"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly callID: string
-          readonly name: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.tool.input.ended"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly callID: string
-          readonly text: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.tool.called"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly callID: string
-          readonly tool: string
-          readonly input: { readonly [x: string]: JsonValue }
-          readonly provider: {
-            readonly executed: boolean
-            readonly metadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-          }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.tool.progress"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly callID: string
-          readonly structured: { readonly [x: string]: JsonValue }
-          readonly content: ReadonlyArray<
-            | { readonly type: "text"; readonly text: string }
-            | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
-          >
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.tool.success"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly callID: string
-          readonly structured: { readonly [x: string]: JsonValue }
-          readonly content: ReadonlyArray<
-            | { readonly type: "text"; readonly text: string }
-            | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
-          >
-          readonly outputPaths?: ReadonlyArray<string>
-          readonly result?: JsonValue
-          readonly provider: {
-            readonly executed: boolean
-            readonly metadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-          }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.tool.failed"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly callID: string
-          readonly error: { readonly type: "unknown"; readonly message: string }
-          readonly result?: JsonValue
-          readonly provider: {
-            readonly executed: boolean
-            readonly metadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-          }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.reasoning.started"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly reasoningID: string
-          readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.reasoning.ended"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly assistantMessageID: string
-          readonly reasoningID: string
-          readonly text: string
-          readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.retried"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly attempt: number
-          readonly error: {
-            readonly message: string
-            readonly statusCode?: number
-            readonly isRetryable: boolean
-            readonly responseHeaders?: { readonly [x: string]: string }
-            readonly responseBody?: string
-            readonly metadata?: { readonly [x: string]: string }
-          }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.compaction.started"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly reason: "auto" | "manual"
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.compaction.ended"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly messageID: string
-          readonly reason: "auto" | "manual"
-          readonly text: string
-          readonly recent: string
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.revert.staged"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: {
-          readonly timestamp: number
-          readonly sessionID: string
-          readonly revert: {
-            readonly messageID: string
-            readonly partID?: string
-            readonly snapshot?: string
-            readonly diff?: string
-            readonly files?: ReadonlyArray<{
-              readonly path: string
-              readonly status: "added" | "modified" | "deleted"
-              readonly additions: number
-              readonly deletions: number
-              readonly patch: string
-            }>
-          }
-        }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.revert.cleared"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: { readonly timestamp: number; readonly sessionID: string }
-      }
-    | {
-        readonly id: string
-        readonly metadata?: { readonly [x: string]: JsonValue }
-        readonly type: "session.next.revert.committed"
-        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
-        readonly location?: { readonly directory: string; readonly workspaceID?: string }
-        readonly data: { readonly timestamp: number; readonly sessionID: string; readonly messageID: string }
-      }
-  >
-  readonly hasMore: boolean
-}
-
 export type SessionsEventsInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly after?: { readonly after?: number | undefined }["after"]
+  readonly after?: { readonly after?: string | undefined }["after"]
 }
 
 export type SessionsEventsOutput =
@@ -1668,5 +1210,3 @@ export type SessionsMessageOutput = {
         readonly time: { readonly created: number }
       }
 }["data"]
-
-export type EventsSubscribeOutput = OpenCodeEventEncoded

packages/client/src/index.ts

@@ -1,2 +1 @@
 export * from "./generated/index"
-export type { EventsSubscribeOutput as OpenCodeEvent } from "./generated/types"

packages/client/test/contract-identity.test.ts

@@ -20,7 +20,7 @@ import { Workspace } from "@opencode-ai/schema/workspace"
 import { Api } from "@opencode-ai/server/api"
 import { compile, emitPromise } from "@opencode-ai/httpapi-codegen"
 import { HttpApi } from "effect/unstable/httpapi"
-import { EventGroup, SessionGroup } from "../src/contract"
+import { SessionGroup } from "../src/contract"
 
 test("Core and Server reuse the authoritative Schema and Protocol values", () => {
   expect(AgentV2.ID).toBe(Agent.ID)
@@ -32,7 +32,6 @@ test("Core and Server reuse the authoritative Schema and Protocol values", () =>
   expect(CorePrompt).toBe(Prompt)
   expect(Api.groups["server.session"].identifier).toBe("server.session")
   expect(SessionGroup.identifier).toBe(Api.groups["server.session"].identifier)
-  expect(EventGroup.identifier).toBe(Api.groups["server.event"].identifier)
   expect(Session.ID.create()).toStartWith("ses_")
   expect(Project.ID.global).toBe("global")
   expect(Provider.ID.anthropic).toBe("anthropic")

packages/client/test/effect.test.ts

@@ -15,53 +15,7 @@ test("sessions.get returns the decoded Effect projection", async () => {
   expect(DateTime.toEpochMillis(result.time.created)).toBe(1_717_171_717_000)
 })
 
-test("events.subscribe exposes and decodes the native Effect event stream", async () => {
-  const httpClient = HttpClient.make((request) =>
-    Effect.succeed(
-      HttpClientResponse.fromWeb(
-        request,
-        new Response(
-          `data: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
-            `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
-          { headers: { "content-type": "text/event-stream" } },
-        ),
-      ),
-    ),
-  )
-  const events = await Effect.gen(function* () {
-    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
-    return yield* client.events.subscribe().pipe(Stream.runCollect)
-  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
-
-  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.next.model.switched"])
-  const durable = events[1]
-  if (durable?.type !== "session.next.model.switched") throw new Error("Expected model event")
-  expect(DateTime.toEpochMillis(durable.data.timestamp)).toBe(1_717_171_717_000)
-  expect(durable.durable).toEqual({ aggregateID: "ses_test", seq: 1, version: 1 })
-})
-
-test("events.subscribe terminates on Effect protocol decode failures", async () => {
-  const httpClient = HttpClient.make((request) =>
-    Effect.succeed(
-      HttpClientResponse.fromWeb(
-        request,
-        new Response(`data: {"type":"server.connected"}\n\n`, {
-          headers: { "content-type": "text/event-stream" },
-        }),
-      ),
-    ),
-  )
-  const error = await Effect.gen(function* () {
-    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
-    return yield* client.events.subscribe().pipe(Stream.runCollect, Effect.flip)
-  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
-
-  expect(error._tag).toBe("ClientError")
-})
-
 test("session methods retain decoded Effect inputs and outputs", async () => {
-  const historyQueries: Array<Record<string, string>> = []
-  let historyPage = 0
   const httpClient = HttpClient.make((request) => {
     const url = request.url
     if (url.includes("/event")) {
@@ -74,18 +28,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
         ),
       )
     }
-    if (url.includes("/history")) {
-      historyPage++
-      historyQueries.push(Object.fromEntries(request.urlParams.params))
-      return Effect.succeed(
-        HttpClientResponse.fromWeb(
-          request,
-          Response.json(
-            historyPage === 1 ? { data: [modelSwitchedEvent], hasMore: true } : { data: [], hasMore: false },
-          ),
-        ),
-      )
-    }
     if (url.includes("/prompt")) {
       return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(admission)))
     }
@@ -130,18 +72,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     yield* client.sessions.compact({ sessionID: Session.ID.make("ses_test") })
     yield* client.sessions.wait({ sessionID: Session.ID.make("ses_test") })
     const context = yield* client.sessions.context({ sessionID: Session.ID.make("ses_test") })
-    const history = yield* client.sessions.history({
-      sessionID: Session.ID.make("ses_test"),
-      after: 0,
-      limit: 1,
-    })
-    const historyNext = history.hasMore
-      ? yield* client.sessions.history({
-          sessionID: Session.ID.make("ses_test"),
-          after: history.data.at(-1)?.durable?.seq,
-          limit: 2,
-        })
-      : undefined
     const events = yield* client.sessions
       .events({ sessionID: Session.ID.make("ses_test"), after: 0 })
       .pipe(Stream.runCollect)
@@ -150,7 +80,7 @@ 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, history, historyNext, events, message }
+    return { page, active, 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)
@@ -162,39 +92,10 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   expect(Object.getPrototypeOf(result.admitted.prompt)).toBe(Object.prototype)
   expect(DateTime.toEpochMillis(result.admitted.timeCreated)).toBe(1_717_171_717_000)
   expect(result.context).toEqual([])
-  expect(DateTime.toEpochMillis(result.history.data[0].data.timestamp)).toBe(1_717_171_717_000)
-  expect(result.history).toEqual(expect.objectContaining({ hasMore: true }))
-  expect(result.historyNext).toEqual({ data: [], hasMore: false })
-  expect(historyQueries[0]).toEqual({ limit: "1", after: "0" })
-  expect(historyQueries[1]).toEqual({ limit: "2", after: "1" })
   expect(DateTime.toEpochMillis(result.events[0].data.timestamp)).toBe(1_717_171_717_000)
   expect(result.message).toEqual(expect.objectContaining({ id: "msg_model", type: "model-switched" }))
 })
 
-test("sessions.history retains the typed SessionNotFoundError", async () => {
-  const httpClient = HttpClient.make((request) =>
-    Effect.succeed(
-      HttpClientResponse.fromWeb(
-        request,
-        Response.json(
-          { _tag: "SessionNotFoundError", sessionID: "ses_missing", message: "Session not found" },
-          { status: 404 },
-        ),
-      ),
-    ),
-  )
-  const error = await Effect.gen(function* () {
-    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
-    return yield* client.sessions
-      .history({
-        sessionID: Session.ID.make("ses_missing"),
-      })
-      .pipe(Effect.flip)
-  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
-
-  expect(error._tag).toBe("SessionNotFoundError")
-})
-
 const session = {
   data: {
     id: "ses_test",

packages/client/test/promise.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test"
-import { isSessionNotFoundError, isUnauthorizedError, OpenCode } from "../src"
+import { isUnauthorizedError, OpenCode } from "../src"
 
 test("sessions.get returns the wire projection", async () => {
   const client = OpenCode.make({
@@ -17,38 +17,8 @@ test("sessions.get returns the wire projection", async () => {
   expect(result.time.created).toBe(1_717_171_717_000)
 })
 
-test("events.subscribe exposes the Promise event stream wire projection", async () => {
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async () =>
-      new Response(
-        `: heartbeat\n\ndata: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
-          `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
-        { headers: { "content-type": "text/event-stream" } },
-      ),
-  })
-  const events = []
-  for await (const event of client.events.subscribe()) events.push(event)
-
-  expect(events).toEqual([{ id: "evt_connected", type: "server.connected", data: {} }, modelSwitchedEvent])
-  expect(events[1]?.type === "session.next.model.switched" && events[1].data.timestamp).toBe(1_717_171_717_000)
-})
-
-test("events.subscribe terminates on malformed Promise SSE data", async () => {
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async () => new Response("data: {not-json}\n\n", { headers: { "content-type": "text/event-stream" } }),
-  })
-
-  await expect(client.events.subscribe()[Symbol.asyncIterator]().next()).rejects.toMatchObject({
-    name: "ClientError",
-    reason: "MalformedResponse",
-  })
-})
-
 test("session methods use the public HTTP contract", async () => {
   const requests: Array<{ url: string; init?: RequestInit }> = []
-  let historyPage = 0
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",
     fetch: async (input, init) => {
@@ -59,12 +29,6 @@ test("session methods use the public HTTP contract", async () => {
           headers: { "content-type": "text/event-stream" },
         })
       }
-      if (url.includes("/history")) {
-        historyPage++
-        return Response.json(
-          historyPage === 1 ? { data: [modelSwitchedEvent], hasMore: true } : { data: [], hasMore: false },
-        )
-      }
       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 })
@@ -75,7 +39,7 @@ test("session methods use the public HTTP contract", async () => {
     },
   })
 
-  const page = await client.sessions.list({ limit: 10, order: "desc" })
+  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" })
@@ -91,13 +55,8 @@ test("session methods use the public HTTP contract", async () => {
   await client.sessions.compact({ sessionID: "ses_test" })
   await client.sessions.wait({ sessionID: "ses_test" })
   const context = await client.sessions.context({ sessionID: "ses_test" })
-  const history = await client.sessions.history({ sessionID: "ses_test", after: 0, limit: 1 })
-  const historyAfter = history.data.at(-1)?.durable?.seq
-  const historyNext = history.hasMore
-    ? await client.sessions.history({ sessionID: "ses_test", after: historyAfter, limit: 2 })
-    : undefined
   const events = []
-  for await (const event of client.sessions.events({ sessionID: "ses_test", after: 0 })) events.push(event)
+  for await (const event of client.sessions.events({ sessionID: "ses_test", after: "0" })) events.push(event)
   await client.sessions.interrupt({ sessionID: "ses_test" })
   const message = await client.sessions.message({ sessionID: "ses_test", messageID: "msg_model" })
 
@@ -106,8 +65,6 @@ test("session methods use the public HTTP contract", async () => {
   expect(created.id).toBe("ses_test")
   expect(admitted.id).toBe("msg_test")
   expect(context).toEqual([])
-  expect(history).toEqual({ data: [modelSwitchedEvent], hasMore: true })
-  expect(historyNext).toEqual({ data: [], hasMore: false })
   expect(events).toEqual([modelSwitchedEvent])
   expect(message).toEqual(modelSwitchedMessage)
   expect(requests.map((request) => [request.init?.method, request.url])).toEqual([
@@ -120,8 +77,6 @@ test("session methods use the public HTTP contract", async () => {
     ["POST", "http://localhost:3000/api/session/ses_test/compact"],
     ["POST", "http://localhost:3000/api/session/ses_test/wait"],
     ["GET", "http://localhost:3000/api/session/ses_test/context"],
-    ["GET", "http://localhost:3000/api/session/ses_test/history?limit=1&after=0"],
-    ["GET", "http://localhost:3000/api/session/ses_test/history?limit=2&after=1"],
     ["GET", "http://localhost:3000/api/session/ses_test/event?after=0"],
     ["POST", "http://localhost:3000/api/session/ses_test/interrupt"],
     ["GET", "http://localhost:3000/api/session/ses_test/message/msg_model"],
@@ -149,24 +104,6 @@ test("middleware errors remain declared client errors", async () => {
   }
 })
 
-test("sessions.history decodes SessionNotFoundError", async () => {
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async () =>
-      Response.json(
-        { _tag: "SessionNotFoundError", sessionID: "ses_missing", message: "Session not found" },
-        { status: 404 },
-      ),
-  })
-
-  try {
-    await client.sessions.history({ sessionID: "ses_missing" })
-    throw new Error("Expected request to fail")
-  } catch (error) {
-    expect(isSessionNotFoundError(error)).toBe(true)
-  }
-})
-
 const session = {
   data: {
     id: "ses_test",

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

@@ -215,16 +215,6 @@ export async function handler(
         body: reqBody,
       })
 
-      if (providerInfo.id.startsWith("console.")) {
-        const resEndpointId = res.headers.get("x-opencode-endpoint-id")
-        const resEndpointModelId = res.headers.get("x-opencode-upstream-model-id")
-        if (resEndpointId && resEndpointModelId)
-          logger.metric({
-            provider: resEndpointId,
-            "provider.model": resEndpointModelId,
-          })
-      }
-
       if (res.status !== 200) {
         logger.metric({
           "llm.error.code": res.status,

packages/core/src/event.ts

@@ -1,9 +1,9 @@
 export * as EventV2 from "./event"
 
-import { Cause, Context, Effect, Layer, Option, PubSub, Queue, Schema, Stream } from "effect"
+import { Cause, Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
 import { Event } from "@opencode-ai/schema/event"
 import type { Data, Definition, Payload } from "@opencode-ai/schema/event"
-import { and, asc, eq, gt, inArray } from "drizzle-orm"
+import { and, asc, eq, gt } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
@@ -47,71 +47,6 @@ export class InvalidDurableEventError extends Schema.TaggedErrorClass<InvalidDur
   },
 ) {}
 
-const decodeSerializedEvent = (event: SerializedEvent): Payload => {
-  const definition = Durable.get(event.type)
-  if (!definition?.durable) {
-    throw new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` })
-  }
-  return {
-    id: event.id,
-    type: definition.type,
-    durable: { aggregateID: event.aggregateID, seq: event.seq, version: definition.durable.version },
-    data: Schema.decodeUnknownSync(definition.data)(event.data),
-  }
-}
-
-export const readAggregate = Effect.fn("EventV2.readAggregate")(function* <A>(
-  db: Database.Interface["db"],
-  input: {
-    readonly aggregateID: string
-    readonly after?: number
-    readonly limit: number
-    readonly manifest: {
-      readonly definitions: ReadonlyMap<string, Definition>
-      readonly schema: Schema.Decoder<A, never>
-    }
-  },
-) {
-  const after = input.after ?? -1
-  const rows = yield* db
-    .select()
-    .from(EventTable)
-    .where(
-      and(
-        eq(EventTable.aggregate_id, input.aggregateID),
-        gt(EventTable.seq, after),
-        inArray(EventTable.type, Array.from(input.manifest.definitions.keys())),
-      ),
-    )
-    .orderBy(asc(EventTable.seq))
-    .limit(input.limit + 1)
-    .all()
-    .pipe(Effect.orDie)
-  const page = rows.slice(0, input.limit)
-  const decode = Schema.decodeUnknownSync(input.manifest.schema)
-  const events = page.map((event) =>
-    decode({
-      id: event.id,
-      type: input.manifest.definitions.get(event.type)?.type ?? event.type,
-      durable: {
-        aggregateID: event.aggregate_id,
-        seq: event.seq,
-        version: input.manifest.definitions.get(event.type)?.durable?.version,
-      },
-      data: event.data,
-    }),
-  )
-  return {
-    events,
-    hasMore: rows.length > input.limit,
-  }
-})
-
-export class SubscriberOverflowError extends Schema.TaggedErrorClass<SubscriberOverflowError>()(
-  "EventV2.SubscriberOverflow",
-  { capacity: Schema.Int },
-) {}
-
 export const define = Event.define
 export const versionedType = Event.versionedType
 
@@ -149,20 +84,6 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Event") {}
 
-export const allBounded = (events: Interface, capacity: number) =>
-  Effect.gen(function* () {
-    const queue = yield* Queue.dropping<Payload, SubscriberOverflowError>(capacity)
-    const unsubscribe = yield* events.listen((event) =>
-      Queue.offer(queue, event).pipe(
-        Effect.flatMap((accepted) =>
-          accepted ? Effect.void : Queue.fail(queue, new SubscriberOverflowError({ capacity })).pipe(Effect.asVoid),
-        ),
-      ),
-    )
-    yield* Effect.addFinalizer(() => unsubscribe.pipe(Effect.andThen(Queue.shutdown(queue)), Effect.asVoid))
-    return Stream.fromQueue(queue)
-  })
-
 export interface LayerOptions {
   readonly beforeAggregateRead?: (aggregateID: string) => Effect.Effect<void>
 }
@@ -538,6 +459,19 @@ export const layerWith = (options?: LayerOptions) =>
 
       const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(pubsub.all)
 
+      const decodeSerializedEvent = (event: SerializedEvent) => {
+        const definition = Durable.get(event.type)
+        if (!definition?.durable) {
+          throw new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` })
+        }
+        return {
+          id: event.id,
+          type: definition.type,
+          durable: { aggregateID: event.aggregateID, seq: event.seq, version: definition.durable.version },
+          data: Schema.decodeUnknownSync(definition.data)(event.data),
+        }
+      }
+
       const readAfter = (aggregateID: string, after: number) =>
         (options?.beforeAggregateRead?.(aggregateID) ?? Effect.void).pipe(
           Effect.andThen(

packages/core/src/flag/flag.ts

@@ -48,6 +48,7 @@ export const Flag = {
 
   OPENCODE_WORKSPACE_ID: process.env["OPENCODE_WORKSPACE_ID"],
   OPENCODE_EXPERIMENTAL_WORKSPACES: enabledByExperimental("OPENCODE_EXPERIMENTAL_WORKSPACES"),
+  OPENCODE_EXPERIMENTAL_TAB_SCROLL: enabledByExperimental("OPENCODE_EXPERIMENTAL_TAB_SCROLL"),
 
   // Evaluated at access time (not module load) because tests, the CLI, and
   // external tooling set these env vars at runtime.

packages/core/src/session.ts

@@ -10,7 +10,6 @@ import { ModelV2 } from "./model"
 import { Location } from "./location"
 import { SessionMessage } from "./session/message"
 import { Prompt } from "./session/prompt"
-import { PromptInput } from "@opencode-ai/schema/prompt-input"
 import { EventV2 } from "./event"
 import { Database } from "./database/database"
 import { SessionProjector } from "./session/projector"
@@ -33,8 +32,6 @@ import { SessionInput } from "./session/input"
 import { Snapshot } from "./snapshot"
 import { SessionRevert } from "./session/revert"
 import { Revert } from "@opencode-ai/schema/revert"
-import { FSUtil } from "./fs-util"
-import { SessionDurable } from "@opencode-ai/schema/durable-event-manifest"
 
 export const RevertState = Revert.State
 export type RevertState = Revert.State
@@ -132,11 +129,6 @@ export interface Interface {
     sessionID: SessionSchema.ID
     after?: number
   }) => Stream.Stream<SessionEvent.DurableEvent, NotFoundError>
-  readonly history: (input: {
-    sessionID: SessionSchema.ID
-    after?: number
-    limit: number
-  }) => Effect.Effect<{ events: ReadonlyArray<SessionEvent.DurableEvent>; hasMore: boolean }, NotFoundError>
   readonly switchAgent: (input: { sessionID: SessionSchema.ID; agent: string }) => Effect.Effect<void, NotFoundError>
   readonly switchModel: (input: {
     sessionID: SessionSchema.ID
@@ -145,7 +137,7 @@ export interface Interface {
   readonly prompt: (input: {
     id?: SessionMessage.ID
     sessionID: SessionSchema.ID
-    prompt: PromptInput.Prompt
+    prompt: Prompt
     delivery?: SessionInput.Delivery
     resume?: boolean
   }) => Effect.Effect<SessionInput.Admitted, NotFoundError | PromptConflictError>
@@ -353,26 +345,17 @@ export const layer = Layer.unwrap(
                   .get(input.sessionID)
                   .pipe(Effect.as(events.durable({ aggregateID: input.sessionID, after: input.after }))),
               ).pipe(Stream.filter((event): event is SessionEvent.DurableEvent => isDurableSessionEvent(event))),
-            history: Effect.fn("V2Session.history")(function* (input) {
-              yield* result.get(input.sessionID)
-              return yield* EventV2.readAggregate(db, {
-                ...input,
-                aggregateID: input.sessionID,
-                manifest: SessionDurable,
-              })
-            }),
             prompt: Effect.fn("V2Session.prompt")((input) =>
               Effect.uninterruptible(
                 Effect.gen(function* () {
                   yield* result.get(input.sessionID)
-                  const prompt = resolvePrompt(input.prompt)
                   const messageID = input.id ?? SessionMessage.ID.create()
                   const delivery = input.delivery ?? "steer"
-                  const expected = { sessionID: input.sessionID, messageID, prompt, delivery }
+                  const expected = { sessionID: input.sessionID, messageID, prompt: input.prompt, delivery }
                   const admitted = yield* SessionInput.admit(db, events, {
                     id: messageID,
                     sessionID: input.sessionID,
-                    prompt,
+                    prompt: input.prompt,
                     delivery,
                   }).pipe(
                     Effect.catchDefect((defect) =>
@@ -469,17 +452,3 @@ export const defaultLayer = layer.pipe(
   Layer.provide(ProjectV2.defaultLayer),
   Layer.orDie,
 )
-
-const resolvePrompt = (input: PromptInput.Prompt) =>
-  Prompt.make({
-    text: input.text,
-    agents: input.agents,
-    files: input.files?.map((file) => {
-      const dataMime = file.uri.match(/^data:([^;,]+)[;,]/i)?.[1]
-      const target = URL.canParse(file.uri) ? new URL(file.uri).pathname : (file.name ?? file.uri)
-      return {
-        ...file,
-        mime: dataMime ?? (target.endsWith("/") ? "application/x-directory" : FSUtil.mimeType(target)),
-      }
-    }),
-  })

packages/core/src/tool/read.ts

@@ -1,10 +1,12 @@
 export * as ReadTool from "./read"
 
 import { ToolFailure } from "@opencode-ai/llm"
+import path from "path"
 import { Effect, Layer, Schema } from "effect"
 import { FileSystem } from "../filesystem"
+import { FSUtil } from "../fs-util"
 import { Image } from "../image"
-import { LocationMutation } from "../location-mutation"
+import { Location } from "../location"
 import { PermissionV2 } from "../permission"
 import { AbsolutePath } from "../schema"
 import { ReadToolFileSystem } from "./read-filesystem"
@@ -28,8 +30,9 @@ const Output = Schema.Union([FileSystem.Content, ReadToolFileSystem.TextPage, Re
 export const layer = Layer.effectDiscard(
   Effect.gen(function* () {
     const tools = yield* Tools.Service
+    const fs = yield* FSUtil.Service
     const reader = yield* ReadToolFileSystem.Service
-    const mutation = yield* LocationMutation.Service
+    const location = yield* Location.Service
     const image = yield* Image.Service
     const permission = yield* PermissionV2.Service
 
@@ -37,7 +40,7 @@ export const layer = Layer.effectDiscard(
       .register({
         [name]: Tool.make({
           description:
-            "Read a text file or supported image, page through a large UTF-8 text file by line offset, or list a directory page. Relative paths resolve from the current location; absolute paths inside it are accepted, while external absolute paths require external_directory approval.",
+            "Read a text file or supported image, page through a large UTF-8 text file by line offset, or list a directory page. Relative paths resolve from the current location; absolute paths are read directly.",
           input: Input,
           output: Output,
           toModelOutput: ({ input, output }) => {
@@ -50,34 +53,27 @@ export const layer = Layer.effectDiscard(
           },
           execute: (input, context) => {
             return Effect.gen(function* () {
-              const source = {
-                type: "tool" as const,
-                messageID: context.assistantMessageID,
-                callID: context.toolCallID,
-              }
-              const target = yield* mutation.resolve({ path: input.path, kind: "directory" })
-              const external = target.externalDirectory
-              if (external)
-                yield* permission.assert({
-                  ...LocationMutation.externalDirectoryPermission(external),
-                  sessionID: context.sessionID,
-                  agent: context.agent,
-                  source,
-                })
-              const resource = target.resource
-              const absolute = AbsolutePath.make(target.canonical)
-              const type = yield* reader.inspect(absolute)
+              const absolute = path.resolve(location.directory, input.path)
+              const selected = path.isAbsolute(input.path) ? path.dirname(absolute) : location.directory
+              if (!path.isAbsolute(input.path) && !FSUtil.contains(location.directory, absolute))
+                return yield* Effect.die(new Error("Path escapes the allowed read root"))
+              const real = yield* fs.realPath(absolute)
+              const root = yield* fs.realPath(selected)
+              if (!FSUtil.contains(root, real))
+                return yield* Effect.die(new Error("Path escapes the allowed read root"))
+              const resource = path.relative(root, real).replaceAll("\\", "/") || "."
+              const target = AbsolutePath.make(real)
+              const type = yield* reader.inspect(target)
               yield* permission.assert({
                 action: name,
                 resources: [resource],
                 save: ["*"],
                 sessionID: context.sessionID,
                 agent: context.agent,
-                source,
+                source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
               })
-              if (type === "directory")
-                return yield* reader.list(absolute, { offset: input.offset, limit: input.limit })
-              const content = yield* reader.read(absolute, resource, {
+              if (type === "directory") return yield* reader.list(target, { offset: input.offset, limit: input.limit })
+              const content = yield* reader.read(target, resource, {
                 offset: input.offset,
                 limit: input.limit,
               })

packages/core/test/event.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect } from "bun:test"
-import { Cause, DateTime, Deferred, Effect, Exit, Fiber, Layer, Option, Schema, Stream } from "effect"
+import { Cause, DateTime, Deferred, Effect, Exit, Fiber, Layer, Schema, Stream } from "effect"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Event } from "@opencode-ai/schema/event"
 import { Session } from "@opencode-ai/schema/session"
@@ -285,69 +285,6 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("notifies global listeners only after a durable event is committed", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-      const observed = new Array<{ id: string; seq: number }>()
-      yield* events.listen((event) =>
-        event.type !== SyncMessage.type
-          ? Effect.void
-          : db
-              .select({ id: EventTable.id, seq: EventTable.seq })
-              .from(EventTable)
-              .where(eq(EventTable.id, event.id))
-              .get()
-              .pipe(
-                Effect.orDie,
-                Effect.tap((row) =>
-                  Effect.sync(() => {
-                    if (row) observed.push(row)
-                  }),
-                ),
-                Effect.asVoid,
-              ),
-      )
-
-      const event = yield* events.publish(SyncMessage, { id: aggregateID, text: "committed" })
-      if (!event.durable) throw new Error("Expected durable event metadata")
-
-      expect(observed).toEqual([{ id: event.id, seq: event.durable.seq }])
-    }),
-  )
-
-  it.effect("ends only an overflowing bounded subscriber without blocking other listeners", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const consuming = yield* Deferred.make<void>()
-      const release = yield* Deferred.make<void>()
-      const slowStream = yield* EventV2.allBounded(events, 1)
-      const fastStream = yield* EventV2.allBounded(events, 8)
-      const slow = yield* slowStream.pipe(
-        Stream.runForEach(() => Deferred.succeed(consuming, undefined).pipe(Effect.andThen(Deferred.await(release)))),
-        Effect.forkScoped,
-      )
-      const fast = yield* fastStream.pipe(Stream.take(4), Stream.runCollect, Effect.forkScoped)
-
-      yield* events.publish(Message, { text: "one" })
-      yield* Deferred.await(consuming)
-      yield* events.publish(Message, { text: "two" })
-      yield* events.publish(Message, { text: "overflow" })
-      const last = yield* events.publish(Message, { text: "still delivered" })
-      yield* Deferred.succeed(release, undefined)
-
-      const slowExit = yield* Fiber.await(slow)
-      expect(Exit.findErrorOption(slowExit).pipe(Option.getOrUndefined)).toBeInstanceOf(EventV2.SubscriberOverflowError)
-      expect(Array.from(yield* Fiber.join(fast))).toEqual([
-        expect.objectContaining({ data: { text: "one" } }),
-        expect.objectContaining({ data: { text: "two" } }),
-        expect.objectContaining({ data: { text: "overflow" } }),
-        last,
-      ])
-    }),
-  )
-
   it.effect("preserves observer interruption", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service

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

@@ -1,174 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer, Schema } from "effect"
-import { Database } from "@opencode-ai/core/database/database"
-import { EventV2 } from "@opencode-ai/core/event"
-import { Location } from "@opencode-ai/core/location"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
-import { ProjectV2 } from "@opencode-ai/core/project"
-import { ProjectTable } from "@opencode-ai/core/project/sql"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { SessionV2 } from "@opencode-ai/core/session"
-import { SessionExecution } from "@opencode-ai/core/session/execution"
-import { SessionProjector } from "@opencode-ai/core/session/projector"
-import { SessionStore } from "@opencode-ai/core/session/store"
-import { SessionTable } from "@opencode-ai/core/session/sql"
-import { testEffect } from "./lib/effect"
-
-const projects = Layer.succeed(
-  ProjectV2.Service,
-  ProjectV2.Service.of({
-    resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
-    directories: () => Effect.succeed([]),
-    commit: () => Effect.void,
-  }),
-)
-const sessions = SessionV2.layer.pipe(
-  Layer.provide(LocationServiceMap.layer),
-  Layer.provide(EventV2.defaultLayer),
-  Layer.provide(Database.defaultLayer),
-  Layer.provide(SessionStore.defaultLayer),
-  Layer.provide(projects),
-  Layer.provide(SessionExecution.noopLayer),
-)
-const it = testEffect(
-  Layer.mergeAll(
-    Database.defaultLayer,
-    EventV2.defaultLayer,
-    projects,
-    SessionProjector.defaultLayer,
-    SessionStore.defaultLayer,
-    SessionExecution.noopLayer,
-    sessions,
-  ),
-)
-const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
-
-const GapEvent = EventV2.define({
-  type: "test.session.history.gap",
-  durable: { aggregate: "sessionID", version: 1 },
-  schema: { sessionID: SessionV2.ID, value: Schema.String },
-})
-
-describe("SessionV2.history", () => {
-  it.effect("returns an exhausted page for a migrated Session with no event sequence", () =>
-    Effect.gen(function* () {
-      const db = (yield* Database.Service).db
-      const session = yield* SessionV2.Service
-      const sessionID = SessionV2.ID.make("ses_empty_history")
-      yield* db
-        .insert(ProjectTable)
-        .values({ id: ProjectV2.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
-        .onConflictDoNothing()
-        .run()
-      yield* db
-        .insert(SessionTable)
-        .values({
-          id: sessionID,
-          project_id: ProjectV2.ID.global,
-          slug: "empty-history",
-          directory: "/project",
-          title: "Empty history",
-          version: "test",
-        })
-        .run()
-
-      const first = yield* session.history({ sessionID, limit: 10 })
-
-      expect(first).toEqual({ events: [], hasMore: false })
-    }),
-  )
-
-  it.effect("treats after as an exclusive aggregate sequence", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionV2.Service
-      const created = yield* session.create({ location })
-      yield* session.switchAgent({ sessionID: created.id, agent: "one" })
-      yield* session.switchAgent({ sessionID: created.id, agent: "two" })
-
-      const page = yield* session.history({ sessionID: created.id, after: 1, limit: 10 })
-
-      expect(page.events.map((event) => event.durable?.seq)).toEqual([2])
-      expect(page.hasMore).toBe(false)
-    }),
-  )
-
-  it.effect("paginates public events in aggregate order across filtered gaps without duplicates", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionV2.Service
-      const events = yield* EventV2.Service
-      const created = yield* session.create({ location })
-      yield* session.switchAgent({ sessionID: created.id, agent: "one" })
-      yield* events.publish(GapEvent, { sessionID: created.id, value: "filtered" })
-      yield* session.switchAgent({ sessionID: created.id, agent: "two" })
-      yield* session.switchAgent({ sessionID: created.id, agent: "three" })
-
-      const first = yield* session.history({ sessionID: created.id, limit: 2 })
-      const after = first.events.at(-1)?.durable?.seq
-      const second = yield* session.history({
-        sessionID: created.id,
-        after,
-        limit: 2,
-      })
-      const sequence = [...first.events, ...second.events].map((event) => event.durable?.seq)
-
-      expect(first.hasMore).toBe(true)
-      expect(second.hasMore).toBe(false)
-      expect(sequence).toEqual([1, 3, 4])
-      expect(new Set(sequence).size).toBe(sequence.length)
-    }),
-  )
-
-  it.effect("includes events committed between pages", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionV2.Service
-      const created = yield* session.create({ location })
-      yield* session.switchAgent({ sessionID: created.id, agent: "one" })
-      yield* session.switchAgent({ sessionID: created.id, agent: "two" })
-
-      const first = yield* session.history({ sessionID: created.id, limit: 1 })
-      yield* session.switchAgent({ sessionID: created.id, agent: "later" })
-      const second = yield* session.history({
-        sessionID: created.id,
-        after: first.events.at(-1)?.durable?.seq,
-        limit: 10,
-      })
-
-      expect(first.hasMore).toBe(true)
-      expect([...first.events, ...second.events].map((event) => event.durable?.seq)).toEqual([1, 2, 3])
-      expect(second.hasMore).toBe(false)
-    }),
-  )
-
-  it.effect("reports exhaustion for exact-limit and limit-plus-one pages", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionV2.Service
-      const created = yield* session.create({ location })
-      yield* session.switchAgent({ sessionID: created.id, agent: "one" })
-      yield* session.switchAgent({ sessionID: created.id, agent: "two" })
-
-      const exact = yield* session.history({ sessionID: created.id, limit: 2 })
-      const oneMore = yield* session.history({ sessionID: created.id, limit: 1 })
-      const exhausted = yield* session.history({
-        sessionID: created.id,
-        after: oneMore.events.at(-1)?.durable?.seq,
-        limit: 1,
-      })
-
-      expect(exact.events).toHaveLength(2)
-      expect(exact.hasMore).toBe(false)
-      expect(oneMore.events).toHaveLength(1)
-      expect(oneMore.hasMore).toBe(true)
-      expect(exhausted.events).toHaveLength(1)
-      expect(exhausted.hasMore).toBe(false)
-    }),
-  )
-
-  it.effect("fails with NotFoundError for a missing Session", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionV2.Service
-      const error = yield* session.history({ sessionID: SessionV2.ID.make("ses_missing"), limit: 10 }).pipe(Effect.flip)
-
-      expect(error._tag).toBe("Session.NotFoundError")
-    }),
-  )
-})

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

@@ -173,27 +173,6 @@ describe("SessionV2.prompt", () => {
     }),
   )
 
-  it.effect("resolves attachment MIME before admission", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* SessionV2.Service
-
-      const message = yield* session.prompt({
-        sessionID,
-        prompt: {
-          text: "Inspect this image",
-          files: [{ uri: "data:image/png;base64,aGVsbG8=", name: "image.png" }],
-        },
-        resume: false,
-      })
-
-      expect(message.prompt.files).toEqual([
-        { uri: "data:image/png;base64,aGVsbG8=", name: "image.png", mime: "image/png" },
-      ])
-      expect((yield* admitted(message.id))?.prompt.files).toEqual(message.prompt.files)
-    }),
-  )
-
   it.effect("streams durable Session events after an aggregate sequence", () =>
     Effect.gen(function* () {
       yield* setup

packages/core/test/tool-read.test.ts

@@ -11,7 +11,6 @@ import { PermissionV2 } from "@opencode-ai/core/permission"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Global } from "@opencode-ai/core/global"
-import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { location } from "./fixture/location"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { ReadTool } from "@opencode-ai/core/tool/read"
@@ -98,32 +97,6 @@ const infrastructure = Layer.mergeAll(
   Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(process.cwd()) }))),
   Global.layerWith({ data: Global.Path.data }),
 )
-const mutation = Layer.succeed(
-  LocationMutation.Service,
-  LocationMutation.Service.of({
-    resolve: (input) => {
-      if (input.path === missingPath)
-        return Effect.fail(new LocationMutation.PathError({ path: input.path, reason: "non_directory_ancestor" }))
-      const canonical = path.resolve(process.cwd(), input.path)
-      const external = path.isAbsolute(input.path) && !FSUtil.contains(process.cwd(), canonical)
-      const resource = external ? canonical.replaceAll("\\", "/") : path.relative(process.cwd(), canonical) || "."
-      const directory = path.dirname(canonical)
-      const externalResource = path.join(directory, "*").replaceAll("\\", "/")
-      return Effect.succeed({
-        canonical,
-        resource,
-        externalDirectory: external
-          ? {
-              action: "external_directory" as const,
-              directory,
-              resource: externalResource,
-              save: externalResource,
-            }
-          : undefined,
-      })
-    },
-  }),
-)
 const unavailableImage = Layer.succeed(
   Image.Service,
   Image.Service.of({ normalize: () => Effect.fail(new Image.ResizerUnavailableError()) }),
@@ -134,21 +107,19 @@ const read = ReadTool.layer.pipe(
   Layer.provide(permission),
   Layer.provide(config),
   Layer.provide(image),
-  Layer.provide(mutation),
   Layer.provide(infrastructure),
 )
-const it = testEffect(Layer.mergeAll(registry, reader, permission, config, image, mutation, infrastructure, read))
+const it = testEffect(Layer.mergeAll(registry, reader, permission, config, image, infrastructure, read))
 const unavailableRead = ReadTool.layer.pipe(
   Layer.provide(registry),
   Layer.provide(reader),
   Layer.provide(permission),
   Layer.provide(config),
   Layer.provide(unavailableImage),
-  Layer.provide(mutation),
   Layer.provide(infrastructure),
 )
 const itWithoutResizer = testEffect(
-  Layer.mergeAll(registry, reader, permission, config, unavailableImage, mutation, infrastructure, unavailableRead),
+  Layer.mergeAll(registry, reader, permission, config, unavailableImage, infrastructure, unavailableRead),
 )
 const sessionID = SessionV2.ID.make("ses_read_tool_test")
 
@@ -203,30 +174,6 @@ describe("ReadTool", () => {
     }),
   )
 
-  it.effect("asks for external_directory approval before reading an external absolute path", () =>
-    Effect.gen(function* () {
-      const registry = yield* ToolRegistry.Service
-      const external = path.join(path.parse(process.cwd()).root, "external-read", "notes.txt")
-
-      expect(
-        yield* executeTool(registry, {
-          sessionID,
-          ...toolIdentity,
-          call: { type: "tool-call", id: "call-external-read", name: "read", input: { path: external } },
-        }),
-      ).toMatchObject({ type: "json" })
-      expect(assertions).toMatchObject([
-        {
-          sessionID,
-          action: "external_directory",
-          resources: [path.join(path.dirname(external), "*").replaceAll("\\", "/")],
-        },
-        { sessionID, action: "read", resources: [external.replaceAll("\\", "/")], save: ["*"] },
-      ])
-      expect(readCalls).toEqual([{ input: AbsolutePath.make(external), page: { offset: undefined, limit: undefined } }])
-    }),
-  )
-
   it.effect("returns a small PNG as native media instead of durable base64 text", () =>
     Effect.gen(function* () {
       const png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="

packages/httpapi-codegen/src/index.ts

@@ -230,12 +230,7 @@ export function emitEffectImported(
   }
 }
 
-export function emitPromise(
-  contract: Contract,
-  options?: {
-    readonly outputTypes?: Readonly<Record<string, { readonly name: string; readonly import: string }>>
-  },
-): Output {
+export function emitPromise(contract: Contract): Output {
   const groups = contract.groups
   for (const group of groups) {
     for (const endpoint of group.endpoints) assertPromiseEndpoint(endpoint)
@@ -243,7 +238,7 @@ export function emitPromise(
   return {
     operations: operations(groups),
     files: [
-      { path: "types.ts", content: renderPromiseTypes(groups, options?.outputTypes) },
+      { path: "types.ts", content: renderPromiseTypes(groups) },
       {
         path: "client-error.ts",
         content: `export type ClientErrorReason = "Transport" | "UnexpectedStatus" | "UnsupportedContentType" | "MalformedResponse"\n\nexport class ClientError extends Error {\n  override readonly name = "ClientError"\n  constructor(readonly reason: ClientErrorReason, options?: ErrorOptions) {\n    super(reason, options)\n  }\n}\n`,
@@ -413,17 +408,14 @@ function renderImportedProjection(groups: ReadonlyArray<Group>, endpoints: Reado
   return { imports: [...new Set(imports)], source }
 }
 
-function renderPromiseTypes(
-  groups: ReadonlyArray<Group>,
-  outputTypes?: Readonly<Record<string, { readonly name: string; readonly import: string }>>,
-) {
+function renderPromiseTypes(groups: ReadonlyArray<Group>) {
   const types = new Map<SchemaAST.AST, string>()
-  const typeOf = (schema: Schema.Top, decoded = false) => {
-    const projected = decoded ? Schema.toType(schema) : Schema.toEncoded(schema)
-    const cached = types.get(projected.ast)
+  const typeOf = (schema: Schema.Top) => {
+    const encoded = Schema.toEncoded(schema)
+    const cached = types.get(encoded.ast)
     if (cached !== undefined) return cached
-    const type = structuralType(projected)
-    types.set(projected.ast, type)
+    const type = structuralType(encoded)
+    types.set(encoded.ast, type)
     return type
   }
   const errors = new Map(
@@ -457,19 +449,17 @@ function renderPromiseTypes(
             const schema = schemas[field.source]
             if (schema === undefined)
               throw new GenerationError({ reason: `Missing input schema: ${prefix}.${field.name}` })
-            return `readonly ${JSON.stringify(field.name)}${field.optional ? "?" : ""}: (${typeOf(schema, field.source === "query")})[${JSON.stringify(field.name)}]`
+            return `readonly ${JSON.stringify(field.name)}${field.optional ? "?" : ""}: (${typeOf(schema)})[${JSON.stringify(field.name)}]`
           })
           .join("; ")
         const successSchema = endpoint.successes[0]
-        const success =
-          outputTypes?.[`${group.identifier}.${endpoint.operation.name}`]?.name ??
-          typeOf(
-            isStreamSchema(successSchema) && successSchema._tag === "StreamSse"
-              ? successSchema.sseMode === "data"
-                ? streamEncodedDataSchema(successSchema)
-                : successSchema.events
-              : successSchema,
-          )
+        const success = typeOf(
+          isStreamSchema(successSchema) && successSchema._tag === "StreamSse"
+            ? successSchema.sseMode === "data"
+              ? streamEncodedDataSchema(successSchema)
+              : successSchema.events
+            : successSchema,
+        )
         return [
           ...(endpoint.operation.inputMode === "none" ? [] : [`export type ${prefix}Input = { ${input} }`]),
           `export type ${prefix}Output = ${endpoint.unwrapData ? `(${success})["data"]` : success}`,
@@ -480,8 +470,7 @@ function renderPromiseTypes(
   const json = operations.includes("JsonValue")
     ? "export type JsonValue = null | boolean | number | string | ReadonlyArray<JsonValue> | { readonly [key: string]: JsonValue }"
     : ""
-  const imports = [...new Set(Object.values(outputTypes ?? {}).map((override) => override.import))]
-  return [...imports, json, ...errorTypes, operations].filter(Boolean).join("\n\n")
+  return [json, ...errorTypes, operations].filter(Boolean).join("\n\n")
 }
 
 function renderPromiseClient(groups: ReadonlyArray<Group>) {

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

@@ -48,24 +48,6 @@ describe("HttpApiCodegen.generate", () => {
     )
   })
 
-  test("allows Promise outputs to use an authoritative imported wire type", () => {
-    const contract = compileContract(
-      api(HttpApiEndpoint.get("events", "/event", { success: HttpApiSchema.StreamSse({ data: Schema.Unknown }) })),
-    )
-    const output = emitPromise(contract, {
-      outputTypes: {
-        "session.events": {
-          name: "EventWire",
-          import: 'import type { EventWire } from "./event-wire"',
-        },
-      },
-    })
-    const types = output.files.find((file) => file.path === "types.ts")?.content
-
-    expect(types).toContain('import type { EventWire } from "./event-wire"')
-    expect(types).toContain("export type SessionEventsOutput = EventWire")
-  })
-
   test("emits an Effect client against an imported authoritative API", () => {
     const output = emitEffectImported(
       compileContract(

packages/llm/src/protocols/gemini.ts

@@ -407,35 +407,21 @@ const step = (state: ParserState, event: GeminiEvent) => {
     if ("thoughtSignature" in part && part.thoughtSignature && "thought" in part && part.thought)
       reasoningSignature = part.thoughtSignature
     if ("text" in part && part.text.length > 0) {
-      if (part.thought) {
-        lifecycle = Lifecycle.reasoningDelta(
-          lifecycle,
-          events,
-          "reasoning-0",
-          part.text,
-          part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
-        )
-        continue
-      }
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", part.text)
+      lifecycle = part.thought
+        ? Lifecycle.reasoningDelta(
+            lifecycle,
+            events,
+            "reasoning-0",
+            part.text,
+            part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
+          )
+        : Lifecycle.textDelta(lifecycle, events, "text-0", part.text)
       continue
     }
 
     if ("functionCall" in part) {
       const input = part.functionCall.args
       const id = `tool_${nextToolCallId++}`
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
-      )
       lifecycle = Lifecycle.stepStart(lifecycle, events)
       events.push(
         LLMEvent.toolCall({

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

@@ -411,12 +411,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     if (delta?.reasoning_content)
       lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", delta.reasoning_content)
 
-    if (delta?.content) {
-      lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0")
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
-    }
-
-    if (toolDeltas.length) lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0")
+    if (delta?.content) lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
 
     for (const tool of toolDeltas) {
       const result = ToolStream.appendOrStart(

packages/llm/test/provider/gemini.test.ts

@@ -347,10 +347,10 @@ describe("Gemini route", () => {
         { type: "step-start", index: 0 },
         { type: "reasoning-start", id: "reasoning-0" },
         { type: "reasoning-delta", id: "reasoning-0", text: "thinking" },
-        { type: "reasoning-end", id: "reasoning-0" },
         { type: "text-start", id: "text-0" },
         { type: "text-delta", id: "text-0", text: "Hello" },
         { type: "text-delta", id: "text-0", text: "!" },
+        { type: "reasoning-end", id: "reasoning-0" },
         { type: "text-end", id: "text-0" },
         { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
         {
@@ -399,9 +399,6 @@ describe("Gemini route", () => {
         providerMetadata: { google: { thoughtSignature: "thought_sig" } },
       })
       expect(toolCall).toMatchObject({ providerMetadata: { google: { thoughtSignature: "tool_sig" } } })
-      expect(response.events.findIndex((event) => event.type === "reasoning-end")).toBeLessThan(
-        response.events.findIndex((event) => event.type === "tool-call"),
-      )
 
       const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
         LLM.request({

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

@@ -542,9 +542,9 @@ describe("OpenAI Chat route", () => {
         { type: "step-start", index: 0 },
         { type: "reasoning-start", id: "reasoning-0" },
         { type: "reasoning-delta", id: "reasoning-0", text: "thinking" },
-        { type: "reasoning-end", id: "reasoning-0" },
         { type: "text-start", id: "text-0" },
         { type: "text-delta", id: "text-0", text: "Hello" },
+        { type: "reasoning-end", id: "reasoning-0" },
         { type: "text-end", id: "text-0" },
         { type: "step-finish", index: 0, reason: "stop" },
         { type: "finish", reason: "stop" },

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

@@ -1067,40 +1067,6 @@ const scenarios: Scenario[] = [
       headers: ctx.headers(),
     }))
     .status(400, undefined, "none"),
-  http.protected
-    .get("/api/session/{sessionID}/history", "v2.session.history")
-    .seeded((ctx) => ctx.session({ title: "Session history" }))
-    .at((ctx) => ({
-      path: `${route("/api/session/{sessionID}/history", { sessionID: ctx.state.id })}?${new URLSearchParams({
-        after: "0",
-        limit: "2",
-      })}`,
-      headers: ctx.headers(),
-    }))
-    .json(
-      200,
-      (body) => {
-        object(body)
-        array(body.data)
-        check(typeof body.hasMore === "boolean", "Expected a history exhaustion signal")
-      },
-      "none",
-    ),
-  http.protected
-    .get("/api/session/{sessionID}/history", "v2.session.history.missing")
-    .at((ctx) => ({
-      path: route("/api/session/{sessionID}/history", { sessionID: "ses_httpapi_missing" }),
-      headers: ctx.headers(),
-    }))
-    .json(404, object, "status"),
-  http.protected
-    .get("/api/session/{sessionID}/history", "v2.session.history.invalid")
-    .seeded((ctx) => ctx.session({ title: "Invalid history sequence" }))
-    .at((ctx) => ({
-      path: `${route("/api/session/{sessionID}/history", { sessionID: ctx.state.id })}?after=-1`,
-      headers: ctx.headers(),
-    }))
-    .json(400, object, "status"),
   http.protected
     .get("/api/session/{sessionID}/event", "v2.session.events.missing")
     .at((ctx) => ({

packages/opencode/test/server/httpapi-v2-location.test.ts

@@ -27,44 +27,13 @@ const Event = Schema.Struct({
   data: Schema.Unknown,
 })
 
-async function* eventStream(body: ReadableStream<Uint8Array>) {
-  const reader = body.getReader()
-  const decoder = new TextDecoder()
-  let buffer = ""
-  try {
-    while (true) {
-      const boundary = buffer.match(/(?:\r\n|\r|\n){2}/)
-      if (!boundary || boundary.index === undefined) {
-        const value = await reader.read()
-        if (value.done) return
-        buffer += decoder.decode(value.value, { stream: true })
-        continue
-      }
-
-      const record = buffer.slice(0, boundary.index)
-      buffer = buffer.slice(boundary.index + boundary[0].length)
-      const data = record
-        .split(/\r\n|\r|\n/)
-        .filter((line) => line.startsWith("data:"))
-        .map((line) => line.slice(5).replace(/^ /, ""))
-      if (data.length) yield Schema.decodeUnknownSync(Event)(JSON.parse(data.join("\n")))
-    }
-  } finally {
-    try {
-      await reader.cancel()
-    } finally {
-      reader.releaseLock()
-    }
-  }
-}
-
-async function readEvent(reader: AsyncIterator<typeof Event.Type>) {
-  const value = await reader.next()
+async function readEvent(reader: ReadableStreamDefaultReader<Uint8Array>) {
+  const value = await reader.read()
   if (value.done) throw new Error("event stream closed")
-  return value.value
+  return Schema.decodeUnknownSync(Event)(JSON.parse(new TextDecoder().decode(value.value).replace(/^data: /, "")))
 }
 
-async function readEventType(reader: AsyncIterator<typeof Event.Type>, type: string) {
+async function readEventType(reader: ReadableStreamDefaultReader<Uint8Array>, type: string) {
   for (let index = 0; index < 20; index++) {
     const event = await readEvent(reader)
     if (event.type === type) return event
@@ -109,7 +78,7 @@ describe("v2 location HttpApi", () => {
     await using subscriber = await tmpdir({ git: true })
     await using publisher = await tmpdir({ git: true })
     const response = await request("/api/event", subscriber.path)
-    const reader = eventStream(response.body!)
+    const reader = response.body!.getReader()
     const connected = await readEvent(reader)
     expect(connected.type).toBe("server.connected")
     expect(connected.location).toBeUndefined()
@@ -121,6 +90,6 @@ describe("v2 location HttpApi", () => {
       location: { directory: publisher.path },
       data: { sessionID: expect.any(String) },
     })
-    await reader.return(undefined)
+    await reader.cancel()
   })
 })

packages/protocol/src/groups/event.ts

@@ -3,7 +3,7 @@ import { EventManifest } from "@opencode-ai/schema/event-manifest"
 import { Location } from "@opencode-ai/schema/location"
 import type { Definition } from "@opencode-ai/schema/event"
 import { Schema } from "effect"
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 
 const fields = {
   id: Event.ID,
@@ -12,9 +12,15 @@ const fields = {
   location: Schema.optional(Location.Ref),
 }
 
-const schema = <const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) =>
+const schema = (definitions: ReadonlyArray<Definition>) =>
   Schema.Union([
-    ...definitions,
+    ...definitions.map((definition) =>
+      Schema.Struct({
+        ...fields,
+        type: Schema.Literal(definition.type),
+        data: definition.data,
+      }).annotate({ identifier: `V2Event.${definition.type}` }),
+    ),
     ...(definitions.some((definition) => definition.type === "server.connected")
       ? []
       : [
@@ -26,14 +32,14 @@ const schema = <const Definitions extends ReadonlyArray<Definition>>(definitions
         ]),
   ]).annotate({ identifier: "V2Event" })
 
-const make = <const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) => {
+const make = (definitions: ReadonlyArray<Definition>) => {
   const EventSchema = schema(definitions)
   return {
     schema: EventSchema,
     group: HttpApiGroup.make("server.event")
       .add(
         HttpApiEndpoint.get("event.subscribe", "/api/event", {
-          success: HttpApiSchema.StreamSse({ data: EventSchema }),
+          success: EventSchema,
         }).annotateMerge(
           OpenApi.annotations({
             identifier: "v2.event.subscribe",
@@ -46,11 +52,8 @@ const make = <const Definitions extends ReadonlyArray<Definition>>(definitions:
   }
 }
 
-export const makeEventGroup = <const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) =>
-  make(definitions).group
+export const makeEventGroup = (definitions: ReadonlyArray<Definition>) => make(definitions).group
 
 const event = make(EventManifest.ServerDefinitions)
 export const EventGroup = event.group
-export const OpenCodeEvent = event.schema
-export type OpenCodeEvent = typeof OpenCodeEvent.Type
-export type OpenCodeEventEncoded = typeof OpenCodeEvent.Encoded
+export type Event = typeof event.schema.Type

packages/protocol/src/groups/session.ts

@@ -1,11 +1,11 @@
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { SessionInput } from "@opencode-ai/schema/session-input"
-import { PromptInput } from "@opencode-ai/schema/prompt-input"
+import { Prompt } from "@opencode-ai/schema/prompt"
 import { Session } from "@opencode-ai/schema/session"
 import { Project } from "@opencode-ai/schema/project"
 import { AbsolutePath, NonNegativeInt, PositiveInt, RelativePath, statics } from "@opencode-ai/schema/schema"
 import { Workspace } from "@opencode-ai/schema/workspace"
-import { Context, Effect, Encoding, Result, Schema, Struct } from "effect"
+import { Context, Encoding, Result, Schema, Struct } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
 import {
   ConflictError,
@@ -60,7 +60,6 @@ const SessionsCursorInput = Schema.Union([
 const SessionsCursorJson = Schema.fromJsonString(SessionsCursorInput)
 const encodeSessionsCursor = Schema.encodeSync(SessionsCursorJson)
 const decodeSessionsCursor = Schema.decodeUnknownEffect(SessionsCursorJson)
-const invalidCursor = "Invalid cursor" as const
 
 export const SessionsCursor = Schema.String.pipe(
   Schema.brand("SessionsCursor"),
@@ -68,13 +67,7 @@ export const SessionsCursor = Schema.String.pipe(
     const make = schema.make.bind(schema)
     return {
       make: (input: typeof SessionsCursorInput.Type) => make(Encoding.encodeBase64Url(encodeSessionsCursor(input))),
-      parse: (input: string) =>
-        Effect.suspend(() => {
-          const result = Encoding.decodeBase64UrlString(input)
-          return Result.isFailure(result)
-            ? Effect.fail(invalidCursor)
-            : decodeSessionsCursor(result.success).pipe(Effect.mapError(() => invalidCursor))
-        }),
+      parse: (input: string) => decodeSessionsCursor(Result.getOrThrow(Encoding.decodeBase64UrlString(input))),
     }
   }),
 )
@@ -84,13 +77,6 @@ const SessionActive = Schema.Struct({
   type: Schema.Literal("running"),
 }).annotate({ identifier: "SessionActive" })
 
-const SessionHistoryLimit = PositiveInt.check(Schema.isLessThanOrEqualTo(100))
-
-export const SessionHistoryQuery = Schema.Struct({
-  limit: Schema.NumberFromString.pipe(Schema.decodeTo(SessionHistoryLimit), Schema.optional),
-  after: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional),
-})
-
 const SessionsQueryCursor = SessionsCursor.annotate({
   description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
 })
@@ -206,7 +192,7 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         params: { sessionID: Session.ID },
         payload: Schema.Struct({
           id: SessionMessage.ID.pipe(Schema.optional),
-          prompt: PromptInput.Prompt,
+          prompt: Prompt,
           delivery: SessionInput.Delivery.pipe(Schema.optional),
           resume: Schema.Boolean.pipe(Schema.optional),
         }),
@@ -303,26 +289,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
           }),
         ),
     )
-    .add(
-      HttpApiEndpoint.get("session.history", "/api/session/:sessionID/history", {
-        params: { sessionID: Session.ID },
-        query: SessionHistoryQuery,
-        success: Schema.Struct({
-          data: Schema.Array(SessionEvent.Durable),
-          hasMore: Schema.Boolean,
-        }).annotate({ identifier: "SessionHistory" }),
-        error: SessionNotFoundError,
-      })
-        .middleware(sessionLocationMiddleware)
-        .annotateMerge(
-          OpenApi.annotations({
-            identifier: "v2.session.history",
-            summary: "Get session history",
-            description:
-              "Read one finite page of public durable Session events after an exclusive aggregate sequence. Newly committed events may appear on later pages.",
-          }),
-        ),
-    )
     .add(
       HttpApiEndpoint.get("session.events", "/api/session/:sessionID/event", {
         params: { sessionID: Session.ID },

packages/protocol/test/session-cursor.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { Effect, Schema } from "effect"
-import { SessionHistoryQuery, SessionsCursor } from "../src/groups/session"
+import { Effect } from "effect"
+import { SessionsCursor } from "../src/groups/session"
 import { Session } from "@opencode-ai/schema/session"
 
 describe("SessionsCursor", () => {
@@ -16,11 +16,3 @@ describe("SessionsCursor", () => {
     expect(await Effect.runPromise(SessionsCursor.parse(cursor))).toEqual(input)
   })
 })
-
-describe("SessionHistoryQuery", () => {
-  test("decodes numeric paging inputs", async () => {
-    const query = await Effect.runPromise(Schema.decodeUnknownEffect(SessionHistoryQuery)({ after: "3", limit: "10" }))
-
-    expect(query).toEqual({ after: 3, limit: 10 })
-  })
-})

packages/schema/src/durable-event-manifest.ts

@@ -4,11 +4,6 @@ import { Event } from "./event"
 import { SessionEvent } from "./session-event"
 import { SessionV1 } from "./session-v1"
 
-export const SessionDurable = {
-  definitions: Event.durable(SessionEvent.DurableDefinitions),
-  schema: SessionEvent.Durable,
-} as const
-
 export const Durable = Event.durable([
   ...SessionV1.Event.Definitions.filter((definition) => definition.durable !== undefined),
   ...SessionEvent.DurableDefinitions,

packages/schema/src/event.ts

@@ -55,7 +55,7 @@ export function define<
     id: ID,
     metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
     type: Schema.Literal(input.type),
-    durable: optional(Schema.Struct({ aggregateID: Schema.String, seq: Schema.Int, version: Schema.Int })),
+    durable: optional(Schema.Struct({ aggregateID: Schema.String, seq: Schema.Number, version: Schema.Number })),
     location: optional(Location.Ref),
     data,
   })
@@ -95,7 +95,7 @@ export function versionedType(type: string, version: number) {
   return `${type}.${version}`
 }
 
-export function durable<const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) {
+export function durable(definitions: ReadonlyArray<Definition>) {
   return readonlyMap(
     definitions.reduce((result, definition) => {
       if (!definition.durable) return result
@@ -103,7 +103,7 @@ export function durable<const Definitions extends ReadonlyArray<Definition>>(def
       if (result.has(key)) throw new Error(`Duplicate durable event definition for ${key}`)
       result.set(key, definition)
       return result
-    }, new Map<string, Definitions[number]>()),
+    }, new Map<string, Definition>()),
   )
 }
 

packages/schema/src/index.ts

@@ -24,5 +24,4 @@ export { PtyTicket } from "./pty-ticket"
 export { Question } from "./question"
 export { Workspace } from "./workspace"
 export { Prompt, Source, FileAttachment, AgentAttachment } from "./prompt"
-export { PromptInput } from "./prompt-input"
 export * from "./schema"

packages/schema/src/prompt-input.ts

@@ -1,26 +0,0 @@
-export * as PromptInput from "./prompt-input"
-
-import { Schema } from "effect"
-import { AgentAttachment, Source } from "./prompt"
-import { optional, statics } from "./schema"
-
-export interface FileAttachment extends Schema.Schema.Type<typeof FileAttachment> {}
-export const FileAttachment = Schema.Struct({
-  uri: Schema.String,
-  name: Schema.String.pipe(optional),
-  description: Schema.String.pipe(optional),
-  source: Source.pipe(optional),
-})
-  .annotate({ identifier: "PromptInput.FileAttachment" })
-  .pipe(
-    statics((schema) => ({
-      create: (input: FileAttachment) => schema.make(input),
-    })),
-  )
-
-export interface Prompt extends Schema.Schema.Type<typeof Prompt> {}
-export const Prompt = Schema.Struct({
-  text: Schema.String,
-  files: Schema.Array(FileAttachment).pipe(optional),
-  agents: Schema.Array(AgentAttachment).pipe(optional),
-}).annotate({ identifier: "PromptInput" })

packages/schema/src/session-event.ts

@@ -511,9 +511,7 @@ export const Definitions = Event.inventory(
   RevertEvent.Committed,
 )
 
-export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" })
-  .pipe(Schema.toTaggedUnion("type"))
-  .annotate({ identifier: "SessionDurableEvent" })
+export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" }).pipe(Schema.toTaggedUnion("type"))
 export type DurableEvent = typeof Durable.Type
 
 export const All = Schema.Union(Definitions, { mode: "oneOf" }).pipe(Schema.toTaggedUnion("type"))

packages/sdk-next/src/index.ts

@@ -14,4 +14,3 @@ export {
   SessionInput,
   SessionMessage,
 } from "@opencode-ai/client/effect"
-export type { OpenCodeEvent } from "@opencode-ai/client/effect"

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

@@ -3,8 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { Deferred, Effect, Latch, Option, Schema, Stream } from "effect"
-import type { OpenCodeEvent } from "../src"
+import { Effect, Option, Schema, Stream } from "effect"
 
 test("embedded client uses the real router and handlers", async () => {
   const directory = await mkdtemp(join(tmpdir(), "opencode-embedded-"))
@@ -104,88 +103,6 @@ test("embedded client uses the real router and handlers", async () => {
   }
 })
 
-test("Location-owned runner events reach the ready global client", async () => {
-  const directory = await mkdtemp(join(tmpdir(), "opencode-embedded-events-"))
-  const database = Flag.OPENCODE_DB
-  Flag.OPENCODE_DB = join(directory, "opencode.sqlite")
-  const { AbsolutePath, Location, OpenCode, Prompt, Session } = await import("../src")
-  const sessionID = Session.ID.make(`ses_embedded_${crypto.randomUUID()}`)
-
-  try {
-    const program = Effect.gen(function* () {
-      const opencode = yield* OpenCode.create()
-      const connected = yield* Latch.make(false)
-      const prompted = yield* Deferred.make<OpenCodeEvent>()
-      yield* opencode.events.subscribe().pipe(
-        Stream.runForEach((event) =>
-          event.type === "server.connected"
-            ? connected.open
-            : event.type === "session.next.prompted" && event.data.sessionID === sessionID
-              ? Deferred.succeed(prompted, event).pipe(Effect.asVoid)
-              : Effect.void,
-        ),
-        Effect.forkScoped,
-      )
-      yield* connected.await
-      yield* opencode.sessions.create({
-        id: sessionID,
-        location: Location.Ref.make({ directory: AbsolutePath.make(directory) }),
-      })
-      yield* opencode.sessions.prompt({ sessionID, prompt: Prompt.make({ text: "Observe this input" }) })
-
-      const event = yield* Deferred.await(prompted).pipe(Effect.timeout("4 seconds"))
-      expect(event.durable).toEqual(expect.objectContaining({ aggregateID: sessionID, seq: expect.any(Number) }))
-    })
-    await Effect.runPromise(Effect.scoped(program))
-  } finally {
-    Flag.OPENCODE_DB = database
-    await rm(directory, { recursive: true, force: true })
-  }
-}, 10_000)
-
-test("independent embedded hosts do not share live notifications", async () => {
-  const directory = await mkdtemp(join(tmpdir(), "opencode-embedded-hosts-"))
-  const database = Flag.OPENCODE_DB
-  Flag.OPENCODE_DB = join(directory, "opencode.sqlite")
-  const { AbsolutePath, Agent, Location, OpenCode, Session } = await import("../src")
-  const sessionID = Session.ID.make(`ses_embedded_${crypto.randomUUID()}`)
-
-  try {
-    const program = Effect.gen(function* () {
-      const first = yield* OpenCode.create()
-      const second = yield* OpenCode.create()
-      const firstReady = yield* Latch.make(false)
-      const secondReady = yield* Latch.make(false)
-      const firstEvent = yield* Latch.make(false)
-      const secondEvent = yield* Latch.make(false)
-      const observe = (ready: Latch.Latch, event: Latch.Latch) =>
-        Stream.runForEach((notification: OpenCodeEvent) =>
-          notification.type === "server.connected"
-            ? ready.open
-            : notification.type === "session.next.agent.switched" && notification.data.sessionID === sessionID
-              ? event.open
-              : Effect.void,
-        )
-
-      yield* first.events.subscribe().pipe(observe(firstReady, firstEvent), Effect.forkScoped)
-      yield* second.events.subscribe().pipe(observe(secondReady, secondEvent), Effect.forkScoped)
-      yield* Effect.all([firstReady.await, secondReady.await], { discard: true })
-      yield* first.sessions.create({
-        id: sessionID,
-        location: Location.Ref.make({ directory: AbsolutePath.make(directory) }),
-      })
-      yield* first.sessions.switchAgent({ sessionID, agent: Agent.ID.make("plan") })
-
-      yield* firstEvent.await.pipe(Effect.timeout("2 seconds"))
-      expect(Option.isNone(yield* secondEvent.await.pipe(Effect.timeoutOption("100 millis")))).toBe(true)
-    })
-    await Effect.runPromise(Effect.scoped(program))
-  } finally {
-    Flag.OPENCODE_DB = database
-    await rm(directory, { recursive: true, force: true })
-  }
-}, 10_000)
-
 test("embedded client is available as a Layer service", async () => {
   const directory = await mkdtemp(join(tmpdir(), "opencode-embedded-layer-"))
   const database = Flag.OPENCODE_DB

packages/sdk/js/package.json

@@ -5,7 +5,6 @@
   "type": "module",
   "license": "MIT",
   "scripts": {
-    "test": "bun test",
     "typecheck": "tsgo --noEmit",
     "build": "bun ./script/build.ts"
   },

packages/sdk/js/script/build.ts

@@ -13,37 +13,6 @@ const opencode = path.resolve(dir, "../../opencode")
 
 await $`bun dev generate > ${dir}/openapi.json`.cwd(opencode)
 
-const document = (await Bun.file("./openapi.json").json()) as {
-  components?: { schemas?: Record<string, unknown> }
-  [key: string]: unknown
-}
-const schemas = document.components?.schemas
-if (schemas) {
-  const reachable = new Set<string>()
-  const visit = (value: unknown) => {
-    if (Array.isArray(value)) {
-      value.forEach(visit)
-      return
-    }
-    if (typeof value !== "object" || value === null) return
-    for (const [key, child] of Object.entries(value)) {
-      if (key === "$ref" && typeof child === "string" && child.startsWith("#/components/schemas/")) {
-        const name = child.slice("#/components/schemas/".length)
-        if (reachable.has(name)) continue
-        reachable.add(name)
-        visit(schemas[name])
-      } else {
-        visit(child)
-      }
-    }
-  }
-  visit({ ...document, components: { ...document.components, schemas: undefined } })
-  for (const name of Object.keys(schemas)) {
-    if (/^SessionNext\w+1$/.test(name) && !reachable.has(name)) delete schemas[name]
-  }
-  await Bun.write("./openapi.json", JSON.stringify(document))
-}
-
 await createClient({
   input: "./openapi.json",
   output: {
@@ -71,29 +40,6 @@ await createClient({
   ],
 })
 
-const generatedTypes = await Bun.file("./src/v2/gen/types.gen.ts").text()
-if (/export type SessionNext\w+1 =/.test(generatedTypes)) {
-  throw new Error("Session history generated duplicate Session event variants")
-}
-const historyTypesPatched = generatedTypes.replace(
-  /(export type V2SessionHistoryData = \{[\s\S]*?query\?: \{\s*limit\?: )string([;,]\s*after\?: )string/,
-  "$1number$2number",
-)
-if (historyTypesPatched === generatedTypes) {
-  throw new Error("Session history numeric query patch did not apply")
-}
-await Bun.write("./src/v2/gen/types.gen.ts", historyTypesPatched)
-
-const generatedSdk = await Bun.file("./src/v2/gen/sdk.gen.ts").text()
-const historySdkPatched = generatedSdk.replace(
-  /(Get session history[\s\S]*?parameters: \{\s*sessionID: string[;,]\s*limit\?: )string([;,]\s*after\?: )string/,
-  "$1number$2number",
-)
-if (historySdkPatched === generatedSdk) {
-  throw new Error("Session history numeric SDK patch did not apply")
-}
-await Bun.write("./src/v2/gen/sdk.gen.ts", historySdkPatched)
-
 // Patch a @hey-api/openapi-ts codegen bug: SseFn incorrectly passes the
 // endpoint's TError into the second generic of ServerSentEventsResult, which
 // is the AsyncGenerator's TReturn slot. Iterator return values have nothing

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

@@ -142,7 +142,7 @@ import type {
   ProjectListResponses,
   ProjectUpdateErrors,
   ProjectUpdateResponses,
-  PromptInput,
+  Prompt,
   ProviderAuthErrors,
   ProviderAuthResponses,
   ProviderListErrors,
@@ -345,8 +345,6 @@ import type {
   V2SessionEventsResponses,
   V2SessionGetErrors,
   V2SessionGetResponses,
-  V2SessionHistoryErrors,
-  V2SessionHistoryResponses,
   V2SessionInterruptErrors,
   V2SessionInterruptResponses,
   V2SessionListErrors,
@@ -5623,7 +5621,7 @@ export class Session3 extends HeyApiClient {
     parameters: {
       sessionID: string
       id?: string
-      prompt?: PromptInput
+      prompt?: Prompt
       delivery?: "steer" | "queue"
       resume?: boolean
     },
@@ -5712,38 +5710,6 @@ export class Session3 extends HeyApiClient {
     })
   }
 
-  /**
-   * Get session history
-   *
-   * Read one finite page of public durable Session events after an exclusive aggregate sequence. Newly committed events may appear on later pages.
-   */
-  public history<ThrowOnError extends boolean = false>(
-    parameters: {
-      sessionID: string
-      limit?: number
-      after?: number
-    },
-    options?: Options<never, ThrowOnError>,
-  ) {
-    const params = buildClientParams(
-      [parameters],
-      [
-        {
-          args: [
-            { in: "path", key: "sessionID" },
-            { in: "query", key: "limit" },
-            { in: "query", key: "after" },
-          ],
-        },
-      ],
-    )
-    return (options?.client ?? this.client).get<V2SessionHistoryResponses, V2SessionHistoryErrors, ThrowOnError>({
-      url: "/api/session/{sessionID}/history",
-      ...options,
-      ...params,
-    })
-  }
-
   /**
    * Subscribe to session events
    *

packages/sdk/js/test/session-history.test.ts

@@ -1,12 +0,0 @@
-import { expect, test } from "bun:test"
-import type { V2SessionHistoryData } from "../src/v2/gen/types.gen"
-
-test("uses numeric Session history positions", () => {
-  const input = {
-    path: { sessionID: "ses_test" },
-    query: { after: 1, limit: 50 },
-    url: "/api/session/{sessionID}/history",
-  } satisfies V2SessionHistoryData
-
-  expect(input.query.after).toBe(1)
-})

packages/server/src/handlers/event.ts

@@ -1,19 +1,16 @@
 import { EventV2 } from "@opencode-ai/core/event"
-import { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
-import { Effect, Schema, Stream } from "effect"
+import { Effect, Stream } from "effect"
 import { HttpServerResponse } from "effect/unstable/http"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import * as Sse from "effect/unstable/encoding/Sse"
 import { Api } from "../api"
 
-const subscriberCapacity = 256
-
 function eventData(data: unknown): Sse.Event {
   return {
     _tag: "Event",
     event: "message",
     id: undefined,
-    data: JSON.stringify(Schema.encodeUnknownSync(OpenCodeEvent)(data)),
+    data: JSON.stringify(data),
   }
 }
 
@@ -27,16 +24,13 @@ export const EventHandler = HttpApiBuilder.group(Api, "server.event", (handlers)
           type: "server.connected",
           data: {},
         }
-        const output = Stream.unwrap(
-          Effect.gen(function* () {
-            // Acquiring the bounded stream installs its listener before readiness is observable.
-            const live = yield* EventV2.allBounded(events, subscriberCapacity)
-            return Stream.make(connected).pipe(Stream.concat(live))
-          }),
-        ).pipe(Stream.map(eventData), Stream.pipeThroughChannel(Sse.encode()))
-        const heartbeat = Stream.tick("15 seconds").pipe(Stream.map(() => ": heartbeat\n\n"))
         return HttpServerResponse.stream(
-          output.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }), Stream.encodeText),
+          Stream.make(connected).pipe(
+            Stream.concat(events.all()),
+            Stream.map(eventData),
+            Stream.pipeThroughChannel(Sse.encode()),
+            Stream.encodeText,
+          ),
           {
             contentType: "text/event-stream",
             headers: {

packages/server/src/handlers/session.ts

@@ -14,7 +14,6 @@ import {
 import { AbsolutePath } from "@opencode-ai/core/schema"
 
 const DefaultSessionsLimit = 50
-const DefaultSessionHistoryLimit = 50
 
 export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handlers) =>
   Effect.gen(function* () {
@@ -329,31 +328,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
-      .handle(
-        "session.history",
-        Effect.fn(function* (ctx) {
-          return yield* session
-            .history({
-              sessionID: ctx.params.sessionID,
-              after: ctx.query.after,
-              limit: ctx.query.limit ?? DefaultSessionHistoryLimit,
-            })
-            .pipe(
-              Effect.map((page) => ({
-                data: page.events,
-                hasMore: page.hasMore,
-              })),
-              Effect.catchTag(
-                "Session.NotFoundError",
-                (error) =>
-                  new SessionNotFoundError({
-                    sessionID: error.sessionID,
-                    message: `Session not found: ${error.sessionID}`,
-                  }),
-              ),
-            )
-        }),
-      )
       .handle(
         "session.events",
         Effect.fn((ctx) =>

packages/stats/app/src/i18n.ts

@@ -240,7 +240,6 @@ const en = {
   "model.noPeersDescription": "Peer rankings appear after usage lands.",
   "model.noUsageLastWeek": "No usage last week",
   "model.newThisWeek": "New this week",
-  "model.sameAsPreviousWeek": "Same as previous week",
   "model.vsPreviousWeek": "{{change}} vs previous week",
   "model.pdf": "PDF",
   "format.users": "users",

packages/stats/app/src/i18n/ar.ts

@@ -221,7 +221,6 @@ export const dict = {
   "model.noPeersDescription": "تظهر ترتيبات النماذج المشابهة بعد وصول الاستخدام.",
   "model.noUsageLastWeek": "لا يوجد استخدام الأسبوع الماضي",
   "model.newThisWeek": "جديد هذا الأسبوع",
-  "model.sameAsPreviousWeek": "دون تغيير عن الأسبوع السابق",
   "model.vsPreviousWeek": "{{change}} مقارنة بالأسبوع السابق",
   "model.pdf": "PDF",
   "format.users": "مستخدمون",

packages/stats/app/src/i18n/br.ts

@@ -223,7 +223,6 @@ export const dict = {
   "model.noPeersDescription": "Os rankings de pares aparecem depois que o uso chega.",
   "model.noUsageLastWeek": "Sem uso na semana passada",
   "model.newThisWeek": "Novo esta semana",
-  "model.sameAsPreviousWeek": "Igual à semana anterior",
   "model.vsPreviousWeek": "{{change}} vs semana anterior",
   "model.pdf": "PDF",
   "format.users": "usuários",

packages/stats/app/src/i18n/da.ts

@@ -222,7 +222,6 @@ export const dict = {
   "model.noPeersDescription": "Ranglister over lignende modeller vises, når brug lander.",
   "model.noUsageLastWeek": "Ingen brug sidste uge",
   "model.newThisWeek": "Ny denne uge",
-  "model.sameAsPreviousWeek": "Samme som forrige uge",
   "model.vsPreviousWeek": "{{change}} vs forrige uge",
   "model.pdf": "PDF",
   "format.users": "brugere",

packages/stats/app/src/i18n/de.ts

@@ -223,7 +223,6 @@ export const dict = {
   "model.noPeersDescription": "Vergleichsrankings erscheinen, nachdem Nutzung eingegangen ist.",
   "model.noUsageLastWeek": "Keine Nutzung letzte Woche",
   "model.newThisWeek": "Neu diese Woche",
-  "model.sameAsPreviousWeek": "Unverändert zur vorherigen Woche",
   "model.vsPreviousWeek": "{{change}} ggü. vorheriger Woche",
   "model.pdf": "PDF",
   "format.users": "Nutzer",

packages/stats/app/src/i18n/es.ts

@@ -222,7 +222,6 @@ export const dict = {
   "model.noPeersDescription": "Las clasificaciones de modelos similares aparecen después de que llegue uso.",
   "model.noUsageLastWeek": "Sin uso la semana pasada",
   "model.newThisWeek": "Nuevo esta semana",
-  "model.sameAsPreviousWeek": "Igual que la semana anterior",
   "model.vsPreviousWeek": "{{change}} vs semana anterior",
   "model.pdf": "PDF",
   "format.users": "usuarios",

packages/stats/app/src/i18n/fr.ts

@@ -224,7 +224,6 @@ export const dict = {
   "model.noPeersDescription": "Les classements de modèles proches apparaissent après l'arrivée de l'utilisation.",
   "model.noUsageLastWeek": "Aucune utilisation la semaine dernière",
   "model.newThisWeek": "Nouveau cette semaine",
-  "model.sameAsPreviousWeek": "Identique à la semaine précédente",
   "model.vsPreviousWeek": "{{change}} vs semaine précédente",
   "model.pdf": "PDF",
   "format.users": "utilisateurs",

packages/stats/app/src/i18n/it.ts

@@ -223,7 +223,6 @@ export const dict = {
   "model.noPeersDescription": "Le classifiche dei modelli simili appaiono dopo l'arrivo dell'utilizzo.",
   "model.noUsageLastWeek": "Nessun utilizzo la scorsa settimana",
   "model.newThisWeek": "Nuovo questa settimana",
-  "model.sameAsPreviousWeek": "Uguale alla settimana precedente",
   "model.vsPreviousWeek": "{{change}} vs settimana precedente",
   "model.pdf": "PDF",
   "format.users": "utenti",

packages/stats/app/src/i18n/ja.ts

@@ -224,7 +224,6 @@ export const dict = {
   "model.noPeersDescription": "使用量が届くと類似モデルのランキングが表示されます。",
   "model.noUsageLastWeek": "先週の使用量なし",
   "model.newThisWeek": "今週新規",
-  "model.sameAsPreviousWeek": "前週と同じ",
   "model.vsPreviousWeek": "前週比 {{change}}",
   "model.pdf": "PDF",
   "format.users": "ユーザー",

packages/stats/app/src/i18n/ko.ts

@@ -224,7 +224,6 @@ export const dict = {
   "model.noPeersDescription": "사용량이 들어오면 비슷한 모델 순위가 표시됩니다.",
   "model.noUsageLastWeek": "지난주 사용량 없음",
   "model.newThisWeek": "이번 주 신규",
-  "model.sameAsPreviousWeek": "지난주와 동일",
   "model.vsPreviousWeek": "지난주 대비 {{change}}",
   "model.pdf": "PDF",
   "format.users": "사용자",

packages/stats/app/src/i18n/no.ts

@@ -222,7 +222,6 @@ export const dict = {
   "model.noPeersDescription": "Rangeringer for lignende modeller vises etter at bruk lander.",
   "model.noUsageLastWeek": "Ingen bruk forrige uke",
   "model.newThisWeek": "Ny denne uken",
-  "model.sameAsPreviousWeek": "Samme som forrige uke",
   "model.vsPreviousWeek": "{{change}} mot forrige uke",
   "model.pdf": "PDF",
   "format.users": "brukere",

packages/stats/app/src/i18n/pl.ts

@@ -221,7 +221,6 @@ export const dict = {
   "model.noPeersDescription": "Rankingi podobnych modeli pojawią się po nadejściu użycia.",
   "model.noUsageLastWeek": "Brak użycia w zeszłym tygodniu",
   "model.newThisWeek": "Nowy w tym tygodniu",
-  "model.sameAsPreviousWeek": "Tak samo jak w poprzednim tygodniu",
   "model.vsPreviousWeek": "{{change}} vs poprzedni tydzień",
   "model.pdf": "PDF",
   "format.users": "użytkownicy",

packages/stats/app/src/i18n/ru.ts

@@ -223,7 +223,6 @@ export const dict = {
   "model.noPeersDescription": "Рейтинги похожих моделей появятся после использования.",
   "model.noUsageLastWeek": "Нет использования на прошлой неделе",
   "model.newThisWeek": "Новая на этой неделе",
-  "model.sameAsPreviousWeek": "Без изменений к предыдущей неделе",
   "model.vsPreviousWeek": "{{change}} к предыдущей неделе",
   "model.pdf": "PDF",
   "format.users": "пользователи",

packages/stats/app/src/i18n/th.ts

@@ -223,7 +223,6 @@ export const dict = {
   "model.noPeersDescription": "อันดับโมเดลใกล้เคียงจะแสดงหลังจากมีการใช้งานเข้ามา",
   "model.noUsageLastWeek": "ไม่มีการใช้งานเมื่อสัปดาห์ที่แล้ว",
   "model.newThisWeek": "ใหม่ในสัปดาห์นี้",
-  "model.sameAsPreviousWeek": "เท่าเดิมจากสัปดาห์ก่อน",
   "model.vsPreviousWeek": "{{change}} เทียบกับสัปดาห์ก่อน",
   "model.pdf": "PDF",
   "format.users": "ผู้ใช้",

packages/stats/app/src/i18n/tr.ts

@@ -223,7 +223,6 @@ export const dict = {
   "model.noPeersDescription": "Benzer model sıralamaları kullanım geldikten sonra görünür.",
   "model.noUsageLastWeek": "Geçen hafta kullanım yok",
   "model.newThisWeek": "Bu hafta yeni",
-  "model.sameAsPreviousWeek": "Önceki haftayla aynı",
   "model.vsPreviousWeek": "önceki haftaya göre {{change}}",
   "model.pdf": "PDF",
   "format.users": "kullanıcı",

packages/stats/app/src/i18n/uk.ts

@@ -223,7 +223,6 @@ export const dict = {
   "model.noPeersDescription": "Рейтинги схожих моделей з'являться після використання.",
   "model.noUsageLastWeek": "Немає використання минулого тижня",
   "model.newThisWeek": "Нова цього тижня",
-  "model.sameAsPreviousWeek": "Без змін відносно попереднього тижня",
   "model.vsPreviousWeek": "{{change}} до попереднього тижня",
   "model.pdf": "PDF",
   "format.users": "користувачі",

packages/stats/app/src/i18n/zh.ts

@@ -222,7 +222,6 @@ export const dict = {
   "model.noPeersDescription": "使用量到达后会显示同类模型排名。",
   "model.noUsageLastWeek": "上周无使用量",
   "model.newThisWeek": "本周新增",
-  "model.sameAsPreviousWeek": "与上周相同",
   "model.vsPreviousWeek": "较上周 {{change}}",
   "model.pdf": "PDF",
   "format.users": "用户",

packages/stats/app/src/i18n/zht.ts

@@ -222,7 +222,6 @@ export const dict = {
   "model.noPeersDescription": "使用量到達後會顯示同類模型排名。",
   "model.noUsageLastWeek": "上週無使用量",
   "model.newThisWeek": "本週新增",
-  "model.sameAsPreviousWeek": "與上週相同",
   "model.vsPreviousWeek": "較上週 {{change}}",
   "model.pdf": "PDF",
   "format.users": "使用者",

packages/stats/app/src/routes/[lab]/[model].tsx

@@ -30,7 +30,6 @@ import {
   type ModelCatalogCost,
   type ModelCatalogEntry,
 } from "../model-catalog"
-import { SectionHeading } from "../section-heading"
 import { runStatsEffect } from "../../stats-runtime"
 import { setStatsPageCacheHeaders } from "../stats-cache"
 import {
@@ -206,11 +205,7 @@ function ModelLoading() {
             <a data-slot="model-back-link" href={language.route(import.meta.env.BASE_URL)}>
               {i18n.t("footer.modelData")}
             </a>
-            <h1>
-              <a data-slot="heading-link" href="#overview">
-                {i18n.t("model.loadingTitle")}
-              </a>
-            </h1>
+            <h1>{i18n.t("model.loadingTitle")}</h1>
             <p>{i18n.t("model.loadingDescription")}</p>
           </div>
         </div>
@@ -233,11 +228,7 @@ function ModelNotFound(props: { lab: string; model: string }) {
             <a data-slot="model-back-link" href={language.route(import.meta.env.BASE_URL)}>
               {i18n.t("footer.modelData")}
             </a>
-            <h1>
-              <a data-slot="heading-link" href="#overview">
-                {props.model || i18n.t("model.fallback")}
-              </a>
-            </h1>
+            <h1>{props.model || i18n.t("model.fallback")}</h1>
             <p>{i18n.t("model.noMatched", { id: props.lab ? `${props.lab}/${props.model}` : props.model })}</p>
           </div>
         </div>
@@ -269,11 +260,7 @@ function ModelHero(props: { data: StatsModelData | null; catalog: ModelCatalogEn
             </a>
             <span data-slot="model-id-tag">{modelId()}</span>
           </div>
-          <h1>
-            <a data-slot="heading-link" href="#overview">
-              {props.catalog?.name ?? props.data?.model ?? i18n.t("model.fallback")}
-            </a>
-          </h1>
+          <h1>{props.catalog?.name ?? props.data?.model ?? i18n.t("model.fallback")}</h1>
           <Show when={props.data} fallback={<p>{i18n.t("model.catalogFallback")}</p>}>
             {(data) => (
               <p>
@@ -365,12 +352,8 @@ function CatalogDatum(props: { label: string; value: string }) {
 function ModelOverview(props: { data: StatsModelData | null }) {
   const i18n = useI18n()
   return (
-    <section id="model-overview" data-section="model-panel">
-      <SectionTitle
-        href="#model-overview"
-        title={i18n.t("nav.overview")}
-        description={i18n.t("model.overviewDescription")}
-      />
+    <section data-section="model-panel">
+      <SectionTitle title={i18n.t("nav.overview")} description={i18n.t("model.overviewDescription")} />
       <Show
         when={props.data}
         fallback={
@@ -416,7 +399,7 @@ function ModelUsageSection(props: { data: ModelUsagePoint[] }) {
   const i18n = useI18n()
   return (
     <section id="usage" data-section="model-panel">
-      <SectionTitle href="#usage" title={i18n.t("nav.usage")} description={i18n.t("model.usageDescription")} />
+      <SectionTitle title={i18n.t("nav.usage")} description={i18n.t("model.usageDescription")} />
       <Show
         when={props.data.some((item) => item.tokens > 0)}
         fallback={
@@ -433,7 +416,7 @@ function ModelUsersSection(props: { data: ModelUsagePoint[] }) {
   const i18n = useI18n()
   return (
     <section id="users" data-section="model-panel">
-      <SectionTitle href="#users" title={i18n.t("model.uniqueUsers")} description={i18n.t("model.usersDescription")} />
+      <SectionTitle title={i18n.t("model.uniqueUsers")} description={i18n.t("model.usersDescription")} />
       <Show
         when={props.data.some((item) => item.users > 0)}
         fallback={
@@ -567,11 +550,7 @@ function ModelEfficiencySection(props: { data: StatsModelData | null; catalog: M
   const i18n = useI18n()
   return (
     <section id="efficiency" data-section="model-panel">
-      <SectionTitle
-        href="#efficiency"
-        title={i18n.t("nav.efficiency")}
-        description={i18n.t("model.efficiencyDescription")}
-      />
+      <SectionTitle title={i18n.t("nav.efficiency")} description={i18n.t("model.efficiencyDescription")} />
       <Show
         when={props.data}
         fallback={
@@ -644,11 +623,7 @@ function ModelGeoBreakdownSection(props: { data: Record<UsageRange, CountryEntry
         setActiveCountry(undefined)
       }}
     >
-      <SectionTitle
-        href="#geo-breakdown"
-        title={i18n.t("nav.geoBreakdown")}
-        description={i18n.t("model.geoDescription")}
-      />
+      <SectionTitle title={i18n.t("nav.geoBreakdown")} description={i18n.t("model.geoDescription")} />
       <Show
         when={data().length > 0}
         fallback={<ModelEmptyState title={i18n.t("model.noGeoTitle")} description={i18n.t("model.noGeoDescription")} />}
@@ -813,7 +788,7 @@ function ModelPeersSection(props: { data: StatsModelData | null }) {
   const i18n = useI18n()
   return (
     <section id="peers" data-section="model-panel">
-      <SectionTitle href="#peers" title={i18n.t("nav.peers")} description={i18n.t("model.peersDescription")} />
+      <SectionTitle title={i18n.t("nav.peers")} description={i18n.t("model.peersDescription")} />
       <Show
         when={props.data?.peers.length}
         fallback={
@@ -858,8 +833,12 @@ function PeerRow(props: { peer: ModelPeerEntry; active: boolean }) {
   )
 }
 
-function SectionTitle(props: { href: string; title: string; description: string }) {
-  return <SectionHeading href={props.href} title={props.title} description={props.description} />
+function SectionTitle(props: { title: string; description: string }) {
+  return (
+    <p data-slot="section-title">
+      <strong>{props.title}.</strong> <span>{props.description}</span>
+    </p>
+  )
 }
 
 function ModelEmptyState(props: { title: string; description: string; compact?: boolean }) {
@@ -933,17 +912,17 @@ function isModelUsageLabelHidden(index: number, count: number) {
   return index !== count - 1 && index % interval !== 0
 }
 
-function formatRankMove(change: number) {
+function formatRankMove(previousRank: number, rank: number) {
+  const change = previousRank - rank
   if (change > 0) return `+${change}`
-  return `${change}`
+  if (change < 0) return `${change}`
+  return "0"
 }
 
 function formatModelRankMoveLabel(data: StatsModelData, i18n: ReturnType<typeof useI18n>) {
   if (data.rank === null) return i18n.t("model.noUsageLastWeek")
   if (data.previousRank === null) return i18n.t("model.newThisWeek")
-  const change = data.previousRank - data.rank
-  if (change === 0) return i18n.t("model.sameAsPreviousWeek")
-  return i18n.t("model.vsPreviousWeek", { change: formatRankMove(change) })
+  return i18n.t("model.vsPreviousWeek", { change: formatRankMove(data.previousRank, data.rank) })
 }
 
 function formatTokens(value: number) {

packages/stats/app/src/routes/[lab]/index.tsx

@@ -20,7 +20,6 @@ import {
   type ModelCatalogEntry,
   type ModelCatalogLab,
 } from "../model-catalog"
-import { SectionHeading } from "../section-heading"
 import { runStatsEffect } from "../../stats-runtime"
 import { setStatsPageCacheHeaders } from "../stats-cache"
 import {
@@ -149,11 +148,7 @@ function LabLoading() {
           <a data-slot="model-back-link" href={language.route(import.meta.env.BASE_URL)}>
             {i18n.t("footer.modelData")}
           </a>
-          <h1>
-            <a data-slot="heading-link" href="#overview">
-              {i18n.t("lab.loadingTitle")}
-            </a>
-          </h1>
+          <h1>{i18n.t("lab.loadingTitle")}</h1>
           <p>{i18n.t("lab.loadingDescription")}</p>
         </div>
       </div>
@@ -171,11 +166,7 @@ function LabNotFound(props: { lab: string }) {
           <a data-slot="model-back-link" href={language.route(import.meta.env.BASE_URL)}>
             {i18n.t("footer.modelData")}
           </a>
-          <h1>
-            <a data-slot="heading-link" href="#overview">
-              {formatCatalogLabName(props.lab)}
-            </a>
-          </h1>
+          <h1>{formatCatalogLabName(props.lab)}</h1>
           <p>{i18n.t("lab.notFound")}</p>
         </div>
       </div>
@@ -202,11 +193,7 @@ function LabHero(props: { lab: ModelCatalogLab; stats: StatsLabData | null }) {
       </a>
       <div data-slot="model-hero-grid">
         <div data-slot="model-hero-copy">
-          <h1>
-            <a data-slot="heading-link" href="#overview">
-              {props.lab.name}
-            </a>
-          </h1>
+          <h1>{props.lab.name}</h1>
           <div data-slot="model-hero-pattern" aria-hidden="true" />
           <p>
             {i18n.t("lab.heroPrefix", { count: props.lab.models.length, lab: props.lab.name })}
@@ -248,11 +235,10 @@ function LabUsageSection(props: { lab: ModelCatalogLab; data: StatsLabData | nul
 
   return (
     <section id="usage" data-section="model-panel">
-      <SectionHeading
-        href="#usage"
-        title={i18n.t("lab.usageTitle", { lab: props.lab.name })}
-        description={i18n.t("lab.usageDescription")}
-      />
+      <p data-slot="section-title">
+        <strong>{i18n.t("lab.usageTitle", { lab: props.lab.name })}.</strong>{" "}
+        <span>{i18n.t("lab.usageDescription")}</span>
+      </p>
       <Show
         when={usage().some((item) => item.tokens > 0)}
         fallback={<LabEmptyState title={i18n.t("lab.noUsageTitle")} description={i18n.t("lab.noUsageDescription")} />}
@@ -350,11 +336,10 @@ function LabModelsSection(props: { lab: ModelCatalogLab; usage: LabUsageModelEnt
   const usageBySlug = createMemo(() => new Map(props.usage.map((item) => [item.slug, item])))
   return (
     <section id="models" data-section="model-panel">
-      <SectionHeading
-        href="#models"
-        title={i18n.t("lab.modelsTitle", { lab: props.lab.name })}
-        description={i18n.t("lab.recentUsageAndLimits")}
-      />
+      <p data-slot="section-title">
+        <strong>{i18n.t("lab.modelsTitle", { lab: props.lab.name })}.</strong>{" "}
+        <span>{i18n.t("lab.recentUsageAndLimits")}</span>
+      </p>
       <div data-component="lab-model-grid">
         <For each={props.lab.models}>
           {(model) => <LabModelCard model={model} usage={usageBySlug().get(model.slug)} />}

packages/stats/app/src/routes/index.css

@@ -87,11 +87,6 @@
   display: none !important;
 }
 
-[data-page="stats"] section[id],
-[data-page="stats"] [data-component="leaderboard"][id] {
-  scroll-margin-top: 88px;
-}
-
 [data-page="stats"] [data-component="content"] {
   color: var(--stats-text);
   font-family:
@@ -1786,35 +1781,6 @@
   font-weight: 400;
 }
 
-[data-page="stats"] [data-slot="heading-link"] {
-  position: relative;
-  color: inherit;
-  text-decoration: none;
-}
-
-[data-page="stats"] [data-slot="heading-link"]:hover {
-  text-decoration: none;
-}
-
-[data-page="stats"] [data-slot="heading-link"]:focus-visible {
-  outline: 1px solid var(--stats-accent);
-  outline-offset: 4px;
-}
-
-[data-page="stats"] [data-slot="heading-anchor"] {
-  position: absolute;
-  top: -0.08em;
-  right: 100%;
-  margin-right: 0.48em;
-  color: var(--stats-accent);
-  opacity: 0;
-}
-
-[data-page="stats"] [data-slot="heading-link"]:hover [data-slot="heading-anchor"],
-[data-page="stats"] [data-slot="heading-link"]:focus-visible [data-slot="heading-anchor"] {
-  opacity: 1;
-}
-
 [data-page="stats"] [data-component="leaderboard"],
 [data-page="stats"] [data-slot="leaderboard-featured"],
 [data-page="stats"] [data-slot="leaderboard-compact"],

packages/stats/app/src/routes/index.tsx

@@ -32,7 +32,6 @@ import { useI18n } from "../context/i18n"
 import { useLanguage } from "../context/language"
 import { localizedUrl } from "../lib/language"
 import { findModelCatalogEntry, getModelCatalog, type ModelCatalog } from "./model-catalog"
-import { SectionHeading } from "./section-heading"
 import { setStatsPageCacheHeaders } from "./stats-cache"
 import {
   applyThemePreference,
@@ -274,11 +273,7 @@ function Hero(props: { updatedAt: string | null }) {
       </p>
       <div data-slot="hero-canvas">
         <div data-slot="hero-pattern" aria-hidden="true" />
-        <h1>
-          <a data-slot="heading-link" href="#overview">
-            {i18n.t("footer.modelData")}
-          </a>
-        </h1>
+        <h1>{i18n.t("footer.modelData")}</h1>
         <p data-slot="hero-copy">{i18n.t("home.heroCopy")}</p>
       </div>
     </section>
@@ -301,7 +296,7 @@ function StatsLoading() {
   return (
     <>
       <Hero updatedAt={null} />
-      <ChartSection id="top-models" title={i18n.t("home.usageTitle")}>
+      <ChartSection title={i18n.t("home.usageTitle")}>
         <EmptyState title={i18n.t("home.loadingTitle")} description={i18n.t("home.loadingDescription")} />
       </ChartSection>
     </>
@@ -319,15 +314,7 @@ function ChartSection(props: {
     <section id={props.id} data-section="chart">
       <div data-slot="section-header">
         <div>
-          <h2>
-            <Show when={props.id} fallback={props.title}>
-              {(id) => (
-                <a data-slot="heading-link" href={`#${id()}`}>
-                  {props.title}
-                </a>
-              )}
-            </Show>
-          </h2>
+          <h2>{props.title}</h2>
           {props.description && <p>{props.description}</p>}
         </div>
         {props.controls}
@@ -337,8 +324,12 @@ function ChartSection(props: {
   )
 }
 
-function SectionTitle(props: { id: string; title: string; description: string }) {
-  return <SectionHeading href={`#${props.id}`} title={props.title} description={props.description} />
+function SectionTitle(props: { title: string; description: string }) {
+  return (
+    <p data-slot="section-title">
+      <strong>{props.title}.</strong> <span>{props.description}</span>
+    </p>
+  )
 }
 
 function SectionBridge(props: { label: string; href: string }) {
@@ -414,13 +405,9 @@ function TopModelsSection(props: { data: StatsHomeData["usage"]; leaderboard: St
 
   return (
     <section id="top-models" data-section="top-models">
-      <SectionHeading
-        as="h2"
-        slot="top-models-title"
-        href="#top-models"
-        title={i18n.t("nav.topModels")}
-        description={i18n.t("home.topModelsDescription")}
-      />
+      <h2 data-slot="top-models-title">
+        <strong>{i18n.t("nav.topModels")}.</strong> <span>{i18n.t("home.topModelsDescription")}</span>
+      </h2>
       <Show
         when={data().some((item) => usageTotal(item) > 0)}
         fallback={<EmptyState title={i18n.t("home.noUsageTitle")} description={i18n.t("home.noUsageDescription")} />}
@@ -815,11 +802,7 @@ function UniqueUsersSection(props: { data: StatsHomeData["users"] }) {
   return (
     <section id="unique-users" data-section="unique-users">
       <SectionBridge label={i18n.t("nav.topModels").toUpperCase()} href="#top-models" />
-      <SectionTitle
-        id="unique-users"
-        title={i18n.t("home.uniqueUsersTitle")}
-        description={i18n.t("home.uniqueUsersDescription")}
-      />
+      <SectionTitle title={i18n.t("home.uniqueUsersTitle")} description={i18n.t("home.uniqueUsersDescription")} />
       <Show
         when={data().some((item) => usageTotal(item) > 0)}
         fallback={
@@ -1090,11 +1073,7 @@ function MarketShareSection(props: { data: StatsHomeData["market"] }) {
       }}
     >
       <SectionBridge label={i18n.t("nav.cacheRatio").toUpperCase()} href="#cache-ratio" />
-      <SectionTitle
-        id="market-share"
-        title={i18n.t("home.marketShareTitle")}
-        description={i18n.t("home.marketShareDescription")}
-      />
+      <SectionTitle title={i18n.t("home.marketShareTitle")} description={i18n.t("home.marketShareDescription")} />
       <Show
         when={activeDay()}
         fallback={<EmptyState title={i18n.t("home.noMarketTitle")} description={i18n.t("home.noMarketDescription")} />}
@@ -1319,7 +1298,7 @@ function GeoBreakdownSection(props: { data: StatsHomeData["country"] }) {
       }}
     >
       <SectionBridge label={i18n.t("nav.marketShare").toUpperCase()} href="#market-share" />
-      <SectionTitle id="geo-breakdown" title={i18n.t("home.geoTitle")} description={i18n.t("home.geoDescription")} />
+      <SectionTitle title={i18n.t("home.geoTitle")} description={i18n.t("home.geoDescription")} />
       <Show
         when={data().length > 0}
         fallback={<EmptyState title={i18n.t("home.noGeoTitle")} description={i18n.t("home.noGeoDescription")} />}
@@ -1604,11 +1583,7 @@ function TokenCostSection(props: { data: StatsHomeData["tokenCost"]; catalog: Mo
   return (
     <section id="token-cost" data-section="token-cost">
       <SectionBridge label={i18n.t("nav.sessionCost").toUpperCase()} href="#session-cost" />
-      <SectionTitle
-        id="token-cost"
-        title={i18n.t("home.tokenCostTitle")}
-        description={i18n.t("home.tokenCostDescription")}
-      />
+      <SectionTitle title={i18n.t("home.tokenCostTitle")} description={i18n.t("home.tokenCostDescription")} />
       <Show
         when={visible().length > 0}
         fallback={
@@ -1691,11 +1666,7 @@ function CacheRatioSection(props: { data: StatsHomeData["cacheRatio"] }) {
   return (
     <section id="cache-ratio" data-section="cache-ratio">
       <SectionBridge label={i18n.t("nav.tokenCost").toUpperCase()} href="#token-cost" />
-      <SectionTitle
-        id="cache-ratio"
-        title={i18n.t("home.cacheRatioTitle")}
-        description={i18n.t("home.cacheRatioDescription")}
-      />
+      <SectionTitle title={i18n.t("home.cacheRatioTitle")} description={i18n.t("home.cacheRatioDescription")} />
       <Show
         when={visible().length > 0}
         fallback={<EmptyState title={i18n.t("home.noCacheTitle")} description={i18n.t("home.noCacheDescription")} />}
@@ -1821,11 +1792,7 @@ function SessionCostSection(props: { data: StatsHomeData["sessionCost"] }) {
   return (
     <section id="session-cost" data-section="session-cost">
       <SectionBridge label={i18n.t("nav.topModels").toUpperCase()} href="#top-models" />
-      <SectionTitle
-        id="session-cost"
-        title={i18n.t("home.sessionCostTitle")}
-        description={i18n.t("home.sessionCostDescription")}
-      />
+      <SectionTitle title={i18n.t("home.sessionCostTitle")} description={i18n.t("home.sessionCostDescription")} />
       <Show
         when={visible().length > 0}
         fallback={

packages/stats/app/src/routes/section-heading.tsx

@@ -1,24 +0,0 @@
-export function SectionHeading(props: {
-  href: string
-  title: string
-  description: string
-  as?: "h2" | "p"
-  slot?: string
-}) {
-  const content = (
-    <>
-      <strong>
-        <a data-slot="heading-link" href={props.href}>
-          <span data-slot="heading-anchor" aria-hidden="true">
-            #
-          </span>
-          {props.title}.
-        </a>
-      </strong>{" "}
-      <span>{props.description}</span>
-    </>
-  )
-
-  if (props.as === "h2") return <h2 data-slot={props.slot ?? "section-title"}>{content}</h2>
-  return <p data-slot={props.slot ?? "section-title"}>{content}</p>
-}

packages/tui/src/context/data.tsx

@@ -1,7 +1,6 @@
 import type {
   AgentV2Info,
   CommandV2Info,
-  Event,
   IntegrationInfo,
   LocationRef,
   ModelV2Info,
@@ -17,6 +16,7 @@ import type {
   SessionMessageAssistantTool,
   SessionV2Info,
   SkillV2Info,
+  V2Event,
 } from "@opencode-ai/sdk/v2"
 import { createStore, produce } from "solid-js/store"
 import { createSimpleContext } from "./helper"
@@ -47,10 +47,6 @@ type Data = {
   location: Record<string, LocationData>
 }
 
-type DataEvent = {
-  [Item in Event as Item["type"]]: Item & { data: Item["properties"]; location: LocationRef }
-}[Event["type"]]
-
 function locationKey(location: LocationRef) {
   return JSON.stringify([location.directory, location.workspaceID])
 }
@@ -125,7 +121,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
       },
     }
 
-    function handleEvent(event: DataEvent) {
+    function handleEvent(event: V2Event) {
       switch (event.type) {
         case "catalog.updated":
           void Promise.all([
@@ -412,7 +408,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           ...event,
           data: event.properties,
           location: { directory: metadata.directory, workspaceID: metadata.workspace },
-        } as DataEvent)
+        } as V2Event)
       })
       onCleanup(unsub)
     })

packages/tui/src/context/local.tsx

@@ -417,6 +417,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       const filePath = path.join(paths.state, "session.json")
       const state = {
         pending: false,
+        scroll: new Map<string, number>(),
       }
 
       function save() {
@@ -455,6 +456,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
 
       function prune(sessionID: string) {
         batch(() => {
+          state.scroll.delete(sessionID)
           if (sessionStore.pinned.includes(sessionID)) {
             setSessionStore(
               "pinned",
@@ -487,6 +489,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
               ? sessionStore.pinned.filter((x) => x !== sessionID)
               : [...sessionStore.pinned, sessionID]
             setSessionStore("pinned", next)
+            if (exists) state.scroll.delete(sessionID)
             save()
           })
         },
@@ -496,6 +499,17 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           if (route.data.type === "session" && route.data.sessionID === target) return
           route.navigate({ type: "session", sessionID: target })
         },
+        scrollPosition(sessionID: string) {
+          if (!slots().includes(sessionID)) return
+          return state.scroll.get(sessionID)
+        },
+        setScrollPosition(sessionID: string, position: number | undefined) {
+          if (position === undefined || !slots().includes(sessionID)) {
+            state.scroll.delete(sessionID)
+            return
+          }
+          state.scroll.set(sessionID, position)
+        },
       }
     }
 

packages/tui/src/routes/session/index.tsx

@@ -6,7 +6,6 @@ import {
   createSignal,
   For,
   Match,
-  on,
   onCleanup,
   onMount,
   Show,
@@ -82,6 +81,7 @@ import { getRevertDiffFiles } from "../../util/revert-diff"
 import { OPENCODE_BASE_MODE, useBindings, useCommandShortcut, useOpencodeKeymap } from "../../keymap"
 import { usePathFormatter } from "../../context/path-format"
 import { LocationProvider } from "../../context/location"
+import { Flag } from "@opencode-ai/core/flag/flag"
 
 addDefaultParsers(parsers.parsers)
 
@@ -259,6 +259,11 @@ export function Session() {
   const [diffWrapMode] = kv.signal<"word" | "none">("diff_wrap_mode", "word")
   const [_animationsEnabled, _setAnimationsEnabled] = kv.signal("animations_enabled", true)
   const [showGenericToolOutput, setShowGenericToolOutput] = kv.signal("generic_tool_output_visibility", false)
+  const [jumpBottomPosition, setJumpBottomPosition] = kv.signal<"center" | "right">(
+    "experimental_jump_bottom_position",
+    "center",
+  )
+  const [awayFromBottom, setAwayFromBottom] = createSignal(false)
 
   const wide = createMemo(() => dimensions().width > 120)
   const sidebarVisible = createMemo(() => {
@@ -275,6 +280,7 @@ export function Session() {
   const toast = useToast()
   const sdk = useSDK()
   const editor = useEditorContext()
+  const local = useLocal()
 
   createEffect(() => {
     const sessionID = route.sessionID
@@ -304,7 +310,15 @@ export function Session() {
       }
       editor.reconnect(result.data.directory)
       await sync.session.sync(sessionID)
-      if (route.sessionID === sessionID && scroll) scroll.scrollBy(100_000)
+      setTimeout(() => {
+        if (route.sessionID !== sessionID || !scroll || scroll.isDestroyed) return
+        scroll.scrollTo(
+          Flag.OPENCODE_EXPERIMENTAL_TAB_SCROLL
+            ? (local.session.scrollPosition(sessionID) ?? scroll.scrollHeight)
+            : scroll.scrollHeight,
+        )
+        updateAwayFromBottom()
+      }, 50)
     })().catch((error) => {
       if (route.sessionID !== sessionID) return
       toast.show({
@@ -335,6 +349,13 @@ export function Session() {
 
   let seeded = false
   let scroll: ScrollBoxRenderable
+  onCleanup(() => {
+    if (!scroll || scroll.isDestroyed) return
+    local.session.setScrollPosition(
+      route.sessionID,
+      Flag.OPENCODE_EXPERIMENTAL_TAB_SCROLL && isAwayFromBottom() ? scroll.scrollTop : undefined,
+    )
+  })
   let prompt: PromptRef | undefined
   const bind = (r: PromptRef | undefined) => {
     prompt = r
@@ -404,24 +425,40 @@ export function Session() {
 
     if (!targetID) {
       scroll.scrollBy(direction === "next" ? scroll.height : -scroll.height)
+      updateAwayFromBottom()
       dialog.clear()
       return
     }
 
     const child = scroll.getChildren().find((c) => c.id === targetID)
     if (child) scroll.scrollBy(child.y - scroll.y - 1)
+    updateAwayFromBottom()
     dialog.clear()
   }
 
+  function isAwayFromBottom() {
+    return scroll.scrollTop < Math.max(0, scroll.scrollHeight - scroll.viewport.height) - 1
+  }
+
+  function updateAwayFromBottom() {
+    if (!Flag.OPENCODE_EXPERIMENTAL_TAB_SCROLL) return
+    setTimeout(() => {
+      if (!scroll || scroll.isDestroyed) return
+      const away = isAwayFromBottom()
+      setAwayFromBottom(away)
+      if (!away) local.session.setScrollPosition(route.sessionID, undefined)
+    })
+  }
+
   function toBottom() {
+    setAwayFromBottom(false)
+    local.session.setScrollPosition(route.sessionID, undefined)
     setTimeout(() => {
       if (!scroll || scroll.isDestroyed) return
       scroll.scrollTo(scroll.scrollHeight)
     }, 50)
   }
 
-  const local = useLocal()
-
   function enterChild(sessionID: string) {
     navigate({
       type: "session",
@@ -522,6 +559,7 @@ export function Session() {
                 return child.id === messageID
               })
               if (child) scroll.scrollBy(child.y - scroll.y - 1)
+              updateAwayFromBottom()
             }}
             sessionID={route.sessionID}
             setPrompt={(promptInfo) => prompt?.set(promptInfo)}
@@ -545,6 +583,7 @@ export function Session() {
                 return child.id === messageID
               })
               if (child) scroll.scrollBy(child.y - scroll.y - 1)
+              updateAwayFromBottom()
             }}
             sessionID={route.sessionID}
           />
@@ -742,6 +781,19 @@ export function Session() {
         dialog.clear()
       },
     },
+    {
+      title: `Move jump-to-bottom button ${jumpBottomPosition() === "center" ? "right" : "to center"}`,
+      value: "session.jump_bottom.position",
+      category: "Session",
+      hidden: !Flag.OPENCODE_EXPERIMENTAL_TAB_SCROLL,
+      slash: {
+        name: "jump-bottom-position",
+      },
+      run: () => {
+        setJumpBottomPosition((position) => (position === "center" ? "right" : "center"))
+        dialog.clear()
+      },
+    },
     {
       title: "Page up",
       value: "session.page.up",
@@ -749,6 +801,7 @@ export function Session() {
       hidden: true,
       run: () => {
         scroll.scrollBy(-scroll.height / 2)
+        updateAwayFromBottom()
         dialog.clear()
       },
     },
@@ -759,6 +812,7 @@ export function Session() {
       hidden: true,
       run: () => {
         scroll.scrollBy(scroll.height / 2)
+        updateAwayFromBottom()
         dialog.clear()
       },
     },
@@ -769,6 +823,7 @@ export function Session() {
       hidden: true,
       run: () => {
         scroll.scrollBy(-1)
+        updateAwayFromBottom()
         dialog.clear()
       },
     },
@@ -779,6 +834,7 @@ export function Session() {
       hidden: true,
       run: () => {
         scroll.scrollBy(1)
+        updateAwayFromBottom()
         dialog.clear()
       },
     },
@@ -789,6 +845,7 @@ export function Session() {
       hidden: true,
       run: () => {
         scroll.scrollBy(-scroll.height / 4)
+        updateAwayFromBottom()
         dialog.clear()
       },
     },
@@ -799,6 +856,7 @@ export function Session() {
       hidden: true,
       run: () => {
         scroll.scrollBy(scroll.height / 4)
+        updateAwayFromBottom()
         dialog.clear()
       },
     },
@@ -809,6 +867,7 @@ export function Session() {
       hidden: true,
       run: () => {
         scroll.scrollTo(0)
+        updateAwayFromBottom()
         dialog.clear()
       },
     },
@@ -818,7 +877,7 @@ export function Session() {
       category: "Session",
       hidden: true,
       run: () => {
-        scroll.scrollTo(scroll.scrollHeight)
+        toBottom()
         dialog.clear()
       },
     },
@@ -848,6 +907,7 @@ export function Session() {
               return child.id === message.id
             })
             if (child) scroll.scrollBy(child.y - scroll.y - 1)
+            updateAwayFromBottom()
             break
           }
         }
@@ -1139,9 +1199,6 @@ export function Session() {
     }
   })
 
-  // snap to bottom when session changes
-  createEffect(on(() => route.sessionID, toBottom))
-
   return (
     <LocationProvider location={location()}>
       <context.Provider
@@ -1182,6 +1239,7 @@ export function Session() {
                 stickyStart="bottom"
                 flexGrow={1}
                 scrollAcceleration={scrollAcceleration()}
+                onMouseScroll={updateAwayFromBottom}
               >
                 <box height={1} />
                 <For each={messages()}>
@@ -1280,6 +1338,18 @@ export function Session() {
                 </For>
               </scrollbox>
               <box flexShrink={0}>
+                <Show when={Flag.OPENCODE_EXPERIMENTAL_TAB_SCROLL && awayFromBottom()}>
+                  <box
+                    height={1}
+                    flexDirection="row"
+                    justifyContent={jumpBottomPosition() === "center" ? "center" : "flex-end"}
+                    paddingRight={jumpBottomPosition() === "right" ? 1 : 0}
+                  >
+                    <text fg={theme.textMuted} onMouseUp={toBottom}>
+                      ↓ Bottom
+                    </text>
+                  </box>
+                </Show>
                 <Show when={permissions().length > 0}>
                   <PermissionPrompt
                     request={permissions()[0]}

packages/ui/package.json

@@ -64,16 +64,15 @@
     "generate:v2-oc2": "bun run script/build-oc2-v2-overrides.ts"
   },
   "devDependencies": {
-    "@solidjs/meta": "catalog:",
     "@tailwindcss/vite": "catalog:",
     "@tsconfig/node22": "catalog:",
     "@types/bun": "catalog:",
     "@types/katex": "0.16.7",
     "@types/luxon": "catalog:",
     "@typescript/native-preview": "catalog:",
+    "@solidjs/meta": "catalog:",
     "solid-js": "catalog:",
     "tailwindcss": "catalog:",
-    "tw-animate-css": "1.4.0",
     "typescript": "catalog:",
     "vite": "catalog:",
     "vite-plugin-icons-spritesheet": "3.0.1",

specs/v2/schema-changelog.md

@@ -1,12 +1,5 @@
 # V2 Schema Changelog
 
-## 2026-06-26: Add Finite Session History
-
-- Add `GET /api/session/:sessionID/history` and generated Promise, Effect, and legacy JavaScript client methods.
-- Page public durable Session events after an optional exclusive aggregate sequence, with an explicit `hasMore` exhaustion signal.
-- Keep aggregate gaps legal, cap pages at 100 events, and preserve the existing durable replay-and-tail `sessions.events()` stream unchanged.
-- Add no migration or durable-event version; this is a finite read API over the existing event manifest.
-
 ## 2026-06-22: Simplify Session Input Promotion
 
 - Keep `session.next.prompt.admitted.1` as the durable, client-visible record of pending Session input.

specs/v2/session.md

@@ -176,10 +176,6 @@ The synchronized `session.next.*` event family and projected Session-message mod
 
 The first `sessions.events(...)` contract is durable-only during both replay and live tailing. This keeps one cursor equal to one persisted aggregate sequence and is sufficient for reconnect-safe consumers. A later UI-facing API may optionally interleave live-only deltas while connected, but those fragments must remain explicitly ephemeral: they cannot advance the durable cursor, replay after reconnect, or be mistaken for publication boundaries.
 
-`sessions.history({ sessionID, after?, limit? })` is the finite counterpart for request/response consumers. `after` is an exclusive aggregate sequence, and omission starts before sequence zero. The response is `{ data, hasMore }`; callers derive the next `after` from the final event's durable sequence when `hasMore` is true. Public durable Session events are selected before pagination, which permits gaps from private or historical aggregate events while preserving strictly increasing unique sequences. The log has a moving head, so events committed between pages may appear on the next page.
-
-The finite endpoint is `GET /api/session/:sessionID/history`, uses the normal Session Location and authorization middleware, defaults to 50 events, and accepts at most 100. It returns only events in the public durable Session schema. The existing `sessions.events()` replay-and-tail stream is unchanged.
-
 Durable event tail wakeups are advisory and edge-triggered. Each active tail owns one sliding-capacity-1 dirty signal for its aggregate and re-queries SQLite after a wake. Repeated commits coalesce while the tail is busy because durable rows, not in-memory notifications, preserve every event and sequence. Subscribe and register the dirty signal before historical replay, then remove it when the tail closes, so replay handoff cannot miss a commit and inactive aggregates retain no wake state.
 
 Event replay owner claims are separate from clustered Session execution ownership. The former already fences synchronized projection reconstruction; the latter still needs distributed active-run acquisition, stale-runtime rejection, interruption, and placement orchestration.
@@ -210,7 +206,7 @@ The first V2 `apply_patch` leaf supports add, update, and delete hunks. It parse
 - Keep eager structured local-tool settlement: durably record each complete call, start its child execution immediately, await all started settlements after provider-turn consumption, persist every result, and reload history once before continuation.
 - Buffer or coalesce streamed deltas before rewriting growing assistant projections.
 - Revisit additional covering indexes as larger-history query shapes become concrete.
-- Design any global multi-Session event stream separately; the finite history API deliberately reads one authorized Session aggregate and does not change global Event publication.
+- Expose replayable Session events over HTTP and the generated SDK where remote consumers need them, deciding whether that public cursor should be opaque rather than the embedded API's branded aggregate sequence.
 - Decide whether UI-facing Session subscriptions should optionally interleave ephemeral deltas while connected without advancing the durable cursor.
 - Add provider-aware context control for provider-executed tool results. Generic text truncation cannot replace provider-native structured payloads that must round-trip exactly.