feat(tui): use server viewed state

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

.changeset/steer-resume-simplified.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/core": patch
----
-
-Simplify interrupt continuation: the steer-scoped resume decision now lives in SessionExecution as a post-cleanup inbox check, and the run coordinator drops its continuation state machine. Wakes arriving during cancellation cleanup now restart a normal full drain, and interrupting an idle session with continue now resumes pending steering input.

.github/actions/setup-bun/action.yml

@@ -1,6 +1,10 @@
 name: "Setup Bun"
 description: "Setup Bun with caching and install dependencies"
 inputs:
+  bun-version:
+    description: "Bun version to install instead of the root packageManager version"
+    required: false
+    default: ""
   install-flags:
     description: "Additional flags to pass to 'bun install'"
     required: false
@@ -20,19 +24,22 @@ runs:
       shell: bash
       run: |
         if [ "$RUNNER_ARCH" = "X64" ]; then
-          V=$(node -p "require('./package.json').packageManager.split('@')[1]")
+          V="${{ inputs.bun-version }}"
+          if [ -z "$V" ]; then V=$(node -p "require('./package.json').packageManager.split('@')[1]"); fi
+          TAG=$([ "$V" = "canary" ] && echo "canary" || echo "bun-v${V}")
           case "$RUNNER_OS" in
             macOS)   OS=darwin ;;
             Linux)   OS=linux ;;
             Windows) OS=windows ;;
           esac
-          echo "url=https://github.com/oven-sh/bun/releases/download/bun-v${V}/bun-${OS}-x64-baseline.zip" >> "$GITHUB_OUTPUT"
+          echo "url=https://github.com/oven-sh/bun/releases/download/${TAG}/bun-${OS}-x64-baseline.zip" >> "$GITHUB_OUTPUT"
         fi
 
     - name: Setup Bun
       uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
       with:
-        bun-version-file: ${{ !steps.bun-url.outputs.url && 'package.json' || '' }}
+        bun-version: ${{ !steps.bun-url.outputs.url && inputs.bun-version || '' }}
+        bun-version-file: ${{ !steps.bun-url.outputs.url && !inputs.bun-version && 'package.json' || '' }}
         bun-download-url: ${{ steps.bun-url.outputs.url }}
 
     - name: Get cache directory

.github/workflows/beta.yml

@@ -1,37 +0,0 @@
-name: beta
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 * * * *"
-
-jobs:
-  sync:
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
-        with:
-          fetch-depth: 0
-
-      - name: Setup Bun
-        uses: ./.github/actions/setup-bun
-
-      - name: Setup Git Committer
-        id: setup-git-committer
-        uses: ./.github/actions/setup-git-committer
-        with:
-          opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
-          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}
-
-      - name: Install OpenCode
-        run: bun i -g opencode-ai
-
-      - name: Sync beta branch
-        env:
-          GH_TOKEN: ${{ steps.setup-git-committer.outputs.token }}
-          OPENCODE_API_KEY: ${{ secrets.OPENCODE_API_KEY }}
-        run: bun script/beta.ts

.github/workflows/publish.yml

@@ -7,6 +7,7 @@ on:
       - ci
       - dev
       - beta
+      - v2
       - fix/npm-native-binary-install
       - snapshot-*
   workflow_dispatch:
@@ -32,7 +33,7 @@ permissions:
   packages: write
 
 env:
-  OPENCODE_CHANNEL: ${{ (github.ref_name == 'v2' && 'next') || '' }}
+  OPENCODE_CHANNEL: ${{ (github.ref_name == 'v2' && 'dev') || '' }}
 
 jobs:
   version:
@@ -45,6 +46,13 @@ jobs:
 
       - uses: ./.github/actions/setup-bun
 
+      - name: Deploy update service
+        if: github.ref_name == 'v2' || github.ref_name == 'beta'
+        working-directory: packages/updates
+        run: bun run deploy
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+
       - name: Setup git committer
         id: committer
         uses: ./.github/actions/setup-git-committer
@@ -74,13 +82,15 @@ jobs:
   build-cli:
     needs: version
     runs-on: blacksmith-4vcpu-ubuntu-2404
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
         with:
           fetch-tags: true
 
       - uses: ./.github/actions/setup-bun
+        with:
+          bun-version: canary # Bun 1.4 until its stable release is published
 
       - name: Setup git committer
         id: committer
@@ -102,6 +112,7 @@ jobs:
         id: build
         run: ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
         env:
+          BUN_COMPILE_RELEASE: canary
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
           GH_REPO: ${{ needs.version.outputs.repo }}
@@ -185,7 +196,7 @@ jobs:
 
   build-node-cli:
     needs: version
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
     strategy:
       fail-fast: false
       matrix:
@@ -335,6 +346,7 @@ jobs:
   build-electron:
     needs:
       - version
+      - sign-cli-macos
     if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
     continue-on-error: false
     env:
@@ -373,6 +385,12 @@ jobs:
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
 
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        if: github.ref_name == 'beta'
+        with:
+          name: opencode-preview-cli
+          path: packages/cli/dist
+
       - uses: apple-actions/import-codesign-certs@8f3fb608891dd2244cdab3d69cd68c0d37a7fe93 # v2.0.0
         if: runner.os == 'macOS'
         with:
@@ -431,6 +449,7 @@ jobs:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
           OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
+          OPENCODE_CLI_DIST: ${{ (github.ref_name == 'beta' && format('{0}/packages/cli/dist', github.workspace)) || '' }}
 
       - name: Build
         run: bun run build
@@ -569,13 +588,11 @@ jobs:
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'beta'
         with:
           name: opencode-preview-cli
           path: packages/cli/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'beta'
         with:
           pattern: opencode-node-cli-*
           path: packages/cli/dist/node

AGENTS.md

@@ -9,7 +9,7 @@
 
 - Run `bun run dev:live` from a development worktree to test its TUI against the currently elected `opencode2` background server and live sessions.
 - Pass a directory after the script when needed, for example `bun run dev:live /path/to/project`.
-- The script discovers the server with `opencode2 service status`, injects its private local credential from `opencode2 service get password`, and uses the `next` TUI storage channel so tabs and other client-local state match the installed client.
+- The script discovers the server with `opencode2 service status`, injects its private local credential from `opencode2 service get password`, and uses the `dev` TUI storage channel so tabs and other client-local state match the installed client.
 - Prefer `dev:live` over plain `bun run dev` for this workflow. An implicit managed-service connection may replace the live server when the worktree client version differs; explicit `--server` warns and continues without replacing it.
 
 ## V2 TUI Stories

bun.lock

@@ -613,6 +613,7 @@
         "@tsconfig/bun": "catalog:",
         "@types/bun": "catalog:",
         "@typescript/native-preview": "catalog:",
+        "prettier": "3.6.2",
         "typescript": "catalog:",
       },
     },

install

@@ -15,13 +15,13 @@ Usage: install.sh [options]
 
 Options:
     -h, --help              Display this help message
-    -v, --version <version> Install a specific version (e.g., 0.0.0-next-17236)
+    -v, --version <version> Install a specific version (e.g., 0.0.0-beta-17236)
     -b, --binary <path>     Install from a local binary instead of downloading
         --no-modify-path    Don't modify shell config files (.zshrc, .bashrc, etc.)
 
 Examples:
     curl -fsSL https://raw.githubusercontent.com/anomalyco/opencode/v2/install | bash
-    curl -fsSL https://raw.githubusercontent.com/anomalyco/opencode/v2/install | bash -s -- --version 0.0.0-next-17236
+    curl -fsSL https://raw.githubusercontent.com/anomalyco/opencode/v2/install | bash -s -- --version 0.0.0-beta-17236
     ./install --binary /path/to/opencode2
 EOF
 }
@@ -166,7 +166,7 @@ else
     fi
 
     if [ -z "$requested_version" ]; then
-        metadata=$(curl -fsSL https://registry.npmjs.org/@opencode-ai%2fcli/next || true)
+        metadata=$(curl -fsSL https://registry.npmjs.org/@opencode-ai%2fcli/beta || true)
         specific_version=$(echo "$metadata" | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')
 
         if [ -z "$specific_version" ]; then

package.json

@@ -8,7 +8,7 @@
   "packageManager": "bun@1.3.14",
   "scripts": {
     "dev": "bun run --cwd packages/cli --conditions=browser src/index.ts",
-    "dev:live": "OPENCODE_TUI_CHANNEL=next OPENCODE_PASSWORD=\"$(opencode2 service get password)\" bun run dev --server \"$(opencode2 service status)\"",
+    "dev:live": "OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode2 service get password)\" bun run dev --server \"$(opencode2 service status)\"",
     "dev:desktop": "bun --cwd packages/desktop dev",
     "dev:web": "bun --cwd packages/app dev",
     "dev:console": "ulimit -n 10240 2>/dev/null; bun run --cwd packages/console/app dev",

packages/app/e2e/regression/project-picker-recent-search.spec.ts

@@ -1,60 +0,0 @@
-import { expect, test } from "@playwright/test"
-import type { Page } from "@playwright/test"
-import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectAppVisible } from "../utils/waits"
-
-const NAMES = ["alpha-service", "bravo-web", "charlie-api", "delta-tools", "echo-infra", "foxtrot-docs"]
-const worktrees = NAMES.map((name) => `/opencode-demo/${name}`)
-
-// The sixth project sits outside the five-item recent cap, so it is only reachable if the
-// dialog hands every recent project to the list filter instead of a pre-truncated slice.
-const OUTSIDE_CAP = "foxtrot-docs"
-
-// Dialog rows carry data-directory-path; the sidebar project list does not, so this
-// scopes assertions to the picker instead of matching the sidebar entry of the same name.
-const rows = (page: Page) => page.locator("[data-directory-path]")
-const row = (page: Page, name: string) => page.locator(`[data-directory-path*="${name}"]`)
-
-async function openProjectDialog(page: Page) {
-  await mockOpenCodeServer(page, {
-    sessions: fixture.sessions,
-    provider: fixture.provider,
-    directory: fixture.directory,
-    project: fixture.project,
-    pageMessages,
-    fileList: () => [],
-    findFiles: () => [],
-  })
-  await page.addInitScript((dirs) => {
-    localStorage.setItem(
-      "opencode.global.dat:server",
-      JSON.stringify({
-        projects: { local: dirs.map((worktree: string) => ({ worktree, expanded: false })) },
-        lastProject: {},
-      }),
-    )
-  }, worktrees)
-  await page.goto("/")
-  const add = page.getByRole("button", { name: "Add project" }).first()
-  await expectAppVisible(add)
-  await add.click()
-  await expect(rows(page)).toHaveCount(5)
-  return page.getByRole("textbox").last()
-}
-
-test("searches every recent project, not just the five most recent", async ({ page }) => {
-  const search = await openProjectDialog(page)
-  await expect(row(page, OUTSIDE_CAP)).toHaveCount(0)
-
-  await search.fill("foxtrot")
-
-  await expect(row(page, OUTSIDE_CAP)).toHaveCount(1)
-})
-
-test("still caps the idle recent list at five projects", async ({ page }) => {
-  await openProjectDialog(page)
-
-  await expect(row(page, NAMES[4])).toHaveCount(1)
-  await expect(row(page, OUTSIDE_CAP)).toHaveCount(0)
-})

packages/app/e2e/user-story/model-selection-flow.spec.ts

@@ -72,7 +72,12 @@ test("creates a session in a new project and selects its model", async ({ page }
   const addProject = page.locator('[data-action="home-add-project-row"]')
   await expectAppVisible(addProject)
   await addProject.click()
-  await page.locator("[data-directory-path]").click()
+  const directoryItem = page.getByRole("treeitem", { name: "NewProject" })
+  await expect(directoryItem).toBeVisible()
+  await directoryItem.click()
+  const selectFolder = page.getByRole("button", { name: "Select folder" })
+  await expect(selectFolder).toBeEnabled()
+  await selectFolder.click()
 
   await page.locator('[data-action="home-new-session"]').click()
   await expectAppVisible(page.locator('[data-component="prompt-input-v2"]'))

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

@@ -1,205 +0,0 @@
-import { useDialog } from "@opencode-ai/ui/context/dialog"
-import { Dialog } from "@opencode-ai/ui/dialog"
-import { FileIcon } from "@opencode-ai/ui/file-icon"
-import { List } from "@opencode-ai/ui/list"
-import type { ListRef } from "@opencode-ai/ui/list"
-import { getDirectory, getFilename } from "@opencode-ai/core/util/path"
-import { createMemo, createResource, createSignal } from "solid-js"
-import { useLanguage } from "@/context/language"
-import { ServerConnection } from "@/context/servers"
-import { useGlobal } from "@/context/global"
-import { cleanPickerInput, createDirectorySearch, displayPickerPath } from "./directory-picker-domain"
-import type { Path } from "@/types"
-
-interface DialogSelectDirectoryProps {
-  title?: string
-  multiple?: boolean
-  onSelect: (result: string | string[] | null) => void
-  server: ServerConnection.Any
-}
-
-const RECENT_PROJECT_LIMIT = 5
-
-type Row = {
-  absolute: string
-  search: string
-  group: "recent" | "folders"
-}
-
-function toRow(absolute: string, home: string, group: Row["group"]): Row {
-  const full = displayPickerPath(absolute, "", "")
-  const tilde = displayPickerPath(full, "~", home)
-  const withSlash = (value: string) => {
-    if (!value) return ""
-    if (value.endsWith("/")) return value
-    return value + "/"
-  }
-
-  const search = Array.from(
-    new Set([full, withSlash(full), tilde, withSlash(tilde), getFilename(full)].filter(Boolean)),
-  ).join("\n")
-  return { absolute: full, search, group }
-}
-
-function uniqueRows(rows: Row[]) {
-  const seen = new Set<string>()
-  return rows.filter((row) => {
-    if (seen.has(row.absolute)) return false
-    seen.add(row.absolute)
-    return true
-  })
-}
-
-export function DialogSelectDirectory(props: DialogSelectDirectoryProps) {
-  const global = useGlobal()
-  const { sync, sdk, ...serverCtx } = global.ensureServerCtx(props.server)
-  const dialog = useDialog()
-  const language = useLanguage()
-
-  const [filter, setFilter] = createSignal("")
-  let list: ListRef | undefined
-
-  const [fallbackPath] = createResource(
-    () => (!(sync.data.path.home || sync.data.path.directory) ? true : undefined),
-    () =>
-      sdk.api.location
-        .get()
-        .then(
-          (location): Path => ({
-            state: "",
-            config: "",
-            worktree: location.project.directory,
-            directory: location.directory,
-            home: "",
-          }),
-        )
-        .catch(() => undefined),
-    { initialValue: undefined },
-  )
-
-  const home = createMemo(() => sync.data.path.home || fallbackPath()?.home || "")
-  const start = createMemo(
-    () => sync.data.path.home || sync.data.path.directory || fallbackPath()?.home || fallbackPath()?.directory,
-  )
-
-  const directories = createDirectorySearch({
-    sdk,
-    home,
-    base: start,
-  })
-
-  const recentProjects = createMemo(() => {
-    const projects = serverCtx.projects.list()
-    const byProject = new Map<string, number>()
-
-    for (const project of projects) {
-      let at = 0
-      const dirs = [project.worktree, ...(project.sandboxes ?? [])]
-      for (const directory of dirs) {
-        const sessions = sync.child(directory, { bootstrap: false })[0].session
-        for (const session of sessions) {
-          if (session.time.archived) continue
-          const updated = session.time.updated ?? session.time.created
-          if (updated > at) at = updated
-        }
-      }
-      byProject.set(project.worktree, at)
-    }
-
-    return projects
-      .map((project, index) => ({ project, at: byProject.get(project.worktree) ?? 0, index }))
-      .sort((a, b) => b.at - a.at || a.index - b.index)
-      .map(({ project }) => {
-        const row = toRow(project.worktree, home(), "recent")
-        const name = project.name || getFilename(project.worktree)
-        return {
-          ...row,
-          search: `${row.search}\n${name}`,
-        }
-      })
-  })
-
-  const items = async (value: string) => {
-    const results = await directories(value)
-    const directoryRows = results.map((absolute) => toRow(absolute, home(), "folders"))
-    // Cap the idle list only. Once a query narrows the results, every project stays searchable.
-    const recent = recentProjects()
-    const visible = value ? recent : recent.slice(0, RECENT_PROJECT_LIMIT)
-    return uniqueRows([...visible, ...directoryRows])
-  }
-
-  function resolve(absolute: string) {
-    props.onSelect(props.multiple ? [absolute] : absolute)
-    dialog.close()
-  }
-
-  return (
-    <Dialog title={props.title ?? language.t("command.project.open")}>
-      <List
-        class="px-3"
-        search={{ placeholder: language.t("dialog.directory.search.placeholder"), autofocus: true }}
-        emptyMessage={language.t("dialog.directory.empty")}
-        loadingMessage={language.t("common.loading")}
-        items={items}
-        key={(x) => x.absolute}
-        filterKeys={["search"]}
-        groupBy={(item) => item.group}
-        sortGroupsBy={(a, b) => {
-          if (a.category === b.category) return 0
-          return a.category === "recent" ? -1 : 1
-        }}
-        groupHeader={(group) =>
-          group.category === "recent" ? language.t("home.recentProjects") : language.t("command.project.open")
-        }
-        ref={(r) => (list = r)}
-        onFilter={(value) => setFilter(cleanPickerInput(value))}
-        onKeyEvent={(e, item) => {
-          if (e.key !== "Tab") return
-          if (e.shiftKey) return
-          if (!item) return
-
-          e.preventDefault()
-          e.stopPropagation()
-
-          const value = displayPickerPath(item.absolute, filter(), home())
-          list?.setFilter(value.endsWith("/") ? value : value + "/")
-        }}
-        onSelect={(path) => {
-          if (!path) return
-          resolve(path.absolute)
-        }}
-      >
-        {(item) => {
-          const path = displayPickerPath(item.absolute, filter(), home())
-          if (path === "~") {
-            return (
-              <div data-directory-path={item.absolute} class="w-full flex items-center justify-between rounded-md">
-                <div class="flex items-center gap-x-3 grow min-w-0">
-                  <FileIcon node={{ path: item.absolute, type: "directory" }} class="shrink-0 size-4" />
-                  <div class="flex items-center text-14-regular min-w-0">
-                    <span class="text-text-strong whitespace-nowrap">~</span>
-                    <span class="text-text-weak whitespace-nowrap">/</span>
-                  </div>
-                </div>
-              </div>
-            )
-          }
-          return (
-            <div data-directory-path={item.absolute} class="w-full flex items-center justify-between rounded-md">
-              <div class="flex items-center gap-x-3 grow min-w-0">
-                <FileIcon node={{ path: item.absolute, type: "directory" }} class="shrink-0 size-4" />
-                <div class="flex items-center text-14-regular min-w-0">
-                  <span class="text-text-weak whitespace-nowrap overflow-hidden overflow-ellipsis truncate min-w-0">
-                    {getDirectory(path)}
-                  </span>
-                  <span class="text-text-strong whitespace-nowrap">{getFilename(path)}</span>
-                  <span class="text-text-weak whitespace-nowrap">/</span>
-                </div>
-              </div>
-            </div>
-          )
-        }}
-      </List>
-    </Dialog>
-  )
-}

packages/app/src/components/directory-picker.tsx

@@ -1,9 +1,7 @@
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { ServerConnection } from "@/context/servers"
 import { usePlatform } from "@/context/platform"
-import { useSettings } from "@/context/settings"
 import { lazy } from "solid-js"
-import { DialogSelectDirectory } from "./dialog-select-directory"
 import { directoryPickerKind } from "./directory-picker-policy"
 
 const DialogSelectDirectoryV2 = lazy(() =>
@@ -19,7 +17,6 @@ type DirectoryPickerInput = {
 
 export function useDirectoryPicker() {
   const platform = usePlatform()
-  const settings = useSettings()
   const dialog = useDialog()
 
   return (input: DirectoryPickerInput) => {
@@ -36,10 +33,6 @@ export function useDirectoryPicker() {
     const cancel = () => {
       if (!selected) input.onSelect(null)
     }
-    if (platform.platform === "desktop" && settings.general.newLayoutDesigns()) {
-      dialog.show(() => <DialogSelectDirectoryV2 {...input} onSelect={onSelect} />, cancel)
-      return
-    }
-    dialog.show(() => <DialogSelectDirectory {...input} onSelect={onSelect} />, cancel)
+    dialog.show(() => <DialogSelectDirectoryV2 {...input} onSelect={onSelect} />, cancel)
   }
 }

packages/app/src/pages/session/timeline/controller.tsx

@@ -94,7 +94,7 @@ export function createTimelineController(input: {
       fallback: language.t("command.session.new"),
     })
   })
-  const showHeader = createMemo(() => !!(titleValue() || input.session.data.parentID()))
+  const showHeader = createMemo(() => !!input.session.identity.sessionID())
   const projection = createTimelineProjection({
     messages: input.session.history.messages,
     userMessages: input.userMessages,

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

@@ -1203,6 +1203,8 @@ function MessageTimelineView(
 
     onCleanup(() => {
       if (contentMeasureFrame !== undefined) cancelAnimationFrame(contentMeasureFrame)
+      // Solid runs cleanup before it disconnects the row, so defer TanStack's null-ref cleanup.
+      queueMicrotask(() => virtualizer.measureElement(null))
     })
 
     return (

packages/cli/script/build.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 
 import { $ } from "bun"
-import { rm } from "fs/promises"
+import { mkdir, rm } from "fs/promises"
 import path from "path"
 import { Script } from "@opencode-ai/script"
 import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
@@ -27,6 +27,7 @@ const requestedTarget = process.argv.find((arg) => arg.startsWith("--target="))?
 const skipInstall = process.argv.includes("--skip-install")
 const skipWebUi = process.argv.includes("--skip-web-ui")
 const solidPlugin = createSolidTransformPlugin()
+const releaseAssets = new Map<string, Promise<Map<string, string>>>()
 
 const allTargets: {
   os: string
@@ -99,6 +100,7 @@ for (const item of targets) {
   }
   const target = targetName(item)
   const name = target.replace(binary, "cli")
+  const executablePath = await compileExecutable(item)
   console.log(`building ${name}`)
   const result = await Bun.build({
     entrypoints: ["./src/index.ts"],
@@ -115,6 +117,7 @@ for (const item of targets) {
       autoloadTsconfig: true,
       autoloadPackageJson: true,
       target: target.replace(binary, "bun") as Bun.Build.CompileTarget,
+      executablePath,
       outfile: path.join(outdir, name, "bin", binary),
       execArgv: [`--user-agent=${binary}/${Script.version}`, "--use-system-ca", "--"],
       windows: {},
@@ -154,6 +157,72 @@ for (const item of targets) {
   await verifyArtifact(path.join(outdir, name))
 }
 
+async function compileExecutable(item: (typeof allTargets)[number]) {
+  const release = process.env.BUN_COMPILE_RELEASE
+  if (!release) return
+
+  const platform = item.os === "win32" ? "windows" : item.os
+  const name = [
+    "bun",
+    platform,
+    item.arch === "arm64" ? "aarch64" : item.arch,
+    item.abi,
+    item.avx2 === false ? "baseline" : undefined,
+  ]
+    .filter(Boolean)
+    .join("-")
+  const cache = path.join(outdir, ".bun", release)
+  const executable = path.join(cache, name, item.os === "win32" ? "bun.exe" : "bun")
+  if (await Bun.file(executable).exists()) return executable
+
+  await mkdir(cache, { recursive: true })
+  const archive = path.join(cache, `${name}.zip`)
+  const assets = await compileReleaseAssets(release)
+  const url = assets.get(`${name}.zip`)
+  if (!url) throw new Error(`Bun release ${release} does not include ${name}.zip`)
+  const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN
+  const response = await fetch(url, {
+    headers: { Accept: "application/octet-stream", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+  })
+  if (!response.ok) throw new Error(`Failed to download ${name} from Bun release ${release}: ${response.status}`)
+  await Bun.write(archive, response)
+  await $`unzip -oq ${archive} -d ${cache}`
+  await rm(archive)
+  return executable
+}
+
+function compileReleaseAssets(release: string) {
+  const existing = releaseAssets.get(release)
+  if (existing) return existing
+  const pending = fetch(`https://api.github.com/repos/oven-sh/bun/releases/tags/${release}?cache=${Date.now()}`)
+    .then(async (response) => {
+      if (!response.ok) throw new Error(`Failed to resolve Bun release ${release}: ${response.status}`)
+      const data: unknown = await response.json()
+      if (typeof data !== "object" || data === null || !("assets" in data) || !Array.isArray(data.assets)) {
+        throw new Error(`Bun release ${release} returned invalid metadata`)
+      }
+      return new Map(
+        data.assets
+          .filter(
+            (asset): asset is { name: string; url: string } =>
+              typeof asset === "object" &&
+              asset !== null &&
+              "name" in asset &&
+              typeof asset.name === "string" &&
+              "url" in asset &&
+              typeof asset.url === "string",
+          )
+          .map((asset) => [asset.name, asset.url]),
+      )
+    })
+    .catch((error) => {
+      releaseAssets.delete(release)
+      throw error
+    })
+  releaseAssets.set(release, pending)
+  return pending
+}
+
 function targetName(item: (typeof allTargets)[number]) {
   return [
     binary,

packages/cli/script/publish.ts

@@ -14,9 +14,13 @@ async function published(name: string, version: string) {
 
 async function publish(dir: string, name: string, version: string) {
   if (process.platform !== "win32") await $`chmod -R 755 .`.cwd(dir)
-  if (await published(name, version)) return console.log(`already published ${name}@${version}`)
-  await $`bun pm pack`.cwd(dir)
-  await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(dir)
+  const exists = await published(name, version)
+  if (exists) console.log(`already published ${name}@${version}`)
+  if (!exists) {
+    await $`bun pm pack`.cwd(dir)
+    await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(dir)
+  }
+  if (Script.channel === "beta") await $`npm dist-tag add ${`${name}@${version}`} next`
 }
 
 async function publishDistribution(input: { root: string; name: string; binary: string; packagePrefix: string }) {

packages/cli/src/server-process.ts

@@ -84,7 +84,7 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
           database: {
             path:
               process.env.OPENCODE_DB ??
-              (["latest", "beta", "next", "prod"].includes(OPENCODE_CHANNEL) ||
+              (["latest", "dev", "beta", "next", "prod"].includes(OPENCODE_CHANNEL) ||
               process.env.OPENCODE_DISABLE_CHANNEL_DB === "1" ||
               process.env.OPENCODE_DISABLE_CHANNEL_DB === "true"
                 ? "opencode.db"

packages/cli/src/services/service-config.ts

@@ -25,12 +25,12 @@ const decodeInfo = Schema.decodeUnknownEffect(Schema.fromJsonString(Info))
 const decodeRegistration = Schema.decodeUnknownEffect(Schema.fromJsonString(Service.Info))
 
 export function filename(channel = OPENCODE_CHANNEL) {
-  if (channel === "latest" || channel === "next") return "service.json"
+  if (channel === "latest" || channel === "dev" || channel === "beta" || channel === "next") return "service.json"
   return `service-${channel.replace(/[^a-zA-Z0-9._-]/g, "-")}.json`
 }
 
 export function defaultPort(channel = OPENCODE_CHANNEL) {
-  if (channel === "latest" || channel === "next") return 0xc0de
+  if (channel === "latest" || channel === "dev" || channel === "beta" || channel === "next") return 0xc0de
   if (channel === "local") return 0xc0df
   return 10_000 + (Number.parseInt(Hash.fast(channel).slice(0, 8), 16) % 50_000)
 }

packages/cli/src/services/updater.test.ts

@@ -35,7 +35,8 @@ describe("updater", () => {
   test("accepts strict release version variants", () => {
     expect(action("v1.2.3", " 1.2.4\n", true)).toBe("upgrade")
     expect(action("1.2.3-alpha.1", "1.2.3-alpha.2", true)).toBe("upgrade")
-    expect(action("0.0.0-next-17403", "0.0.0-next-17403.2", true)).toBe("upgrade")
+    expect(action("0.0.0-dev-17403", "0.0.0-dev-17403.2", true)).toBe("upgrade")
+    expect(action("0.0.0-next-17403", "0.0.0-beta-17404", true)).toBe("upgrade")
     expect(action("1.2.3+old", "1.2.3+new", true)).toBe("none")
     expect(action("v1.2.3+old", "1.2.3", true)).toBe("none")
   })

packages/cli/test/service.test.ts

@@ -11,6 +11,8 @@ import { ServiceConfig } from "../src/services/service-config"
 
 test("managed service ports are stable per installation channel", () => {
   expect(ServiceConfig.defaultPort("latest")).toBe(0xc0de)
+  expect(ServiceConfig.defaultPort("dev")).toBe(0xc0de)
+  expect(ServiceConfig.defaultPort("beta")).toBe(0xc0de)
   expect(ServiceConfig.defaultPort("next")).toBe(0xc0de)
   expect(ServiceConfig.defaultPort("local")).toBe(0xc0df)
   expect(ServiceConfig.defaultPort("preview-a")).toBe(ServiceConfig.defaultPort("preview-a"))
@@ -37,6 +39,8 @@ test("local channel stores service config with the local service filename", asyn
 
 test("service filenames share release channels and identify preview channels", () => {
   expect(ServiceConfig.filename("latest")).toBe("service.json")
+  expect(ServiceConfig.filename("dev")).toBe("service.json")
+  expect(ServiceConfig.filename("beta")).toBe("service.json")
   expect(ServiceConfig.filename("next")).toBe("service.json")
   expect(ServiceConfig.filename("local")).toBe("service-local.json")
   expect(ServiceConfig.filename("preview-a")).toBe("service-preview-a.json")

packages/client/src/effect/api/api.ts

@@ -20,7 +20,6 @@ import type { InstructionEntry } from "@opencode-ai/schema/instruction-entry"
 import type { Schema } from "effect"
 import type { EventLog } from "@opencode-ai/schema/event-log"
 import type { Shell } from "@opencode-ai/schema/shell"
-import type { DateTime } from "effect"
 import type { Provider } from "@opencode-ai/schema/provider"
 import type { Integration } from "@opencode-ai/schema/integration"
 import type { Form } from "@opencode-ai/schema/form"
@@ -316,7 +315,7 @@ export type Endpoint5_31Output =
   | (
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.created"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -336,7 +335,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.agent.selected"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -349,7 +348,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.model.selected"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -362,7 +361,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.moved"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -376,7 +375,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.renamed"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -385,7 +384,16 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.viewed"
+          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
+          readonly location?: Location.Ref | undefined
+          readonly data: { readonly sessionID: Session.ID }
+        }
+      | {
+          readonly id: Event.ID
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.deleted"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -394,7 +402,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.forked"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -410,7 +418,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.inbox.delivered"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -419,7 +427,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.inbox.enqueued"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -432,7 +440,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.inbox.cancelled"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -441,7 +449,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.inbox.delivery.changed"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -454,7 +462,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.execution.started"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -463,7 +471,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.execution.succeeded"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -472,7 +480,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.execution.failed"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -484,7 +492,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.execution.interrupted"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -493,7 +501,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.instructions.updated"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -506,7 +514,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.synthetic"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -520,7 +528,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.skill.activated"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -534,7 +542,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.shell.started"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -543,7 +551,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.shell.ended"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -561,7 +569,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.step.started"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -576,7 +584,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.step.ended"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -598,7 +606,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.step.failed"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -622,7 +630,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.text.started"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -635,7 +643,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.text.ended"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -650,7 +658,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.reasoning.started"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -664,7 +672,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.reasoning.ended"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -679,7 +687,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.tool.input.started"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -693,7 +701,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.tool.input.ended"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -707,7 +715,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.tool.called"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -723,7 +731,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.tool.success"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -759,7 +767,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.tool.failed"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -798,7 +806,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.retry.scheduled"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -813,7 +821,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.compaction.started"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -827,7 +835,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.compaction.ended"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -841,7 +849,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.compaction.failed"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -855,7 +863,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.revert.staged"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -864,7 +872,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.revert.cleared"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -873,7 +881,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.revert.committed"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -882,7 +890,7 @@ export type Endpoint5_31Output =
         }
       | {
           readonly id: Event.ID
-          readonly created: DateTime.Utc
+          readonly created: number
           readonly metadata?: { readonly [x: string]: unknown } | undefined
           readonly type: "session.usage.recorded"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
@@ -915,6 +923,10 @@ export type Endpoint5_34Input = { readonly sessionID: Session.ID; readonly messa
 export type Endpoint5_34Output = SessionMessage.Info
 export type SessionMessageOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>
 
+export type Endpoint5_35Input = { readonly sessionID: Session.ID }
+export type Endpoint5_35Output = void
+export type SessionViewOperation<E = never> = (input: Endpoint5_35Input) => Effect.Effect<Endpoint5_35Output, E>
+
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
   readonly create: SessionCreateOperation<E>
@@ -959,6 +971,7 @@ export interface SessionApi<E = never> {
   readonly interrupt: SessionInterruptOperation<E>
   readonly background: SessionBackgroundOperation<E>
   readonly message: SessionMessageOperation<E>
+  readonly view: SessionViewOperation<E>
 }
 
 export type Endpoint6_0Input = {

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

@@ -86,6 +86,8 @@ import type {
   Endpoint5_33Output,
   Endpoint5_34Input,
   Endpoint5_34Output,
+  Endpoint5_35Input,
+  Endpoint5_35Output,
   Endpoint6_0Input,
   Endpoint6_0Output,
   Endpoint7_0Input,
@@ -610,6 +612,11 @@ const Endpoint5_34 = (raw: RawClient["server.session"]) => (input: Endpoint5_34I
     ),
   )
 
+const Endpoint5_35 = (raw: RawClient["server.session"]) => (input: Endpoint5_35Input) =>
+  preserveEffect<Endpoint5_35Output>()(
+    raw["session.view"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
+  )
+
 const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   list: Endpoint5_0(raw),
   create: Endpoint5_1(raw),
@@ -639,6 +646,7 @@ const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   interrupt: Endpoint5_32(raw),
   background: Endpoint5_33(raw),
   message: Endpoint5_34(raw),
+  view: Endpoint5_35(raw),
 })
 
 const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>

packages/client/src/promise/generated/client.ts

@@ -80,6 +80,8 @@ import type {
   SessionBackgroundOutput,
   SessionMessageInput,
   SessionMessageOutput,
+  SessionViewInput,
+  SessionViewOutput,
   MessageListInput,
   MessageListOutput,
   ModelListInput,
@@ -896,6 +898,17 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
+      view: (input: SessionViewInput, requestOptions?: RequestOptions) =>
+        request<SessionViewOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/view`,
+            successStatus: 204,
+            declaredStatuses: [404, 401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
     },
     message: {
       list: (input: MessageListInput, requestOptions?: RequestOptions) =>

packages/client/src/promise/generated/types.ts

@@ -479,6 +479,16 @@ export type SessionRenamed = {
   data: { sessionID: string; title: string }
 }
 
+export type SessionViewed = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.viewed"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string }
+}
+
 export type SessionDeleted = {
   id: string
   created: number
@@ -1510,7 +1520,7 @@ export type SessionInfo = {
   model?: ModelRef
   cost: MoneyUSD
   tokens: TokenUsageInfo
-  time: { created: number; updated: number; archived?: number }
+  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
   title?: string
   location: LocationRef
   subpath?: string
@@ -1923,6 +1933,7 @@ export type SessionEventDurable =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
+  | SessionViewed
   | SessionDeleted
   | SessionForked
   | SessionInboxDelivered
@@ -2013,6 +2024,7 @@ export type V2Event =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
+  | SessionViewed
   | SessionUsageUpdated
   | SessionDeleted
   | SessionForked
@@ -2476,7 +2488,13 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -2743,7 +2761,13 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -3010,7 +3034,13 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -3936,6 +3966,10 @@ export type SessionMessageInput = {
 
 export type SessionMessageOutput = { data: SessionMessageInfo }["data"]
 
+export type SessionViewInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
+
+export type SessionViewOutput = void
+
 export type MessageListInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
   readonly limit?: {

packages/client/test/effect.test.ts

@@ -136,8 +136,10 @@ test("event.subscribe terminates on Effect protocol decode failures", async () =
 
 test("session methods retain decoded Effect inputs and outputs", async () => {
   const logQueries: Array<Record<string, string>> = []
+  const requests: Array<{ method: string; url: string }> = []
   const httpClient = HttpClient.make((request) => {
     const url = request.url
+    requests.push({ method: request.method, url })
     if (url.includes("/log")) {
       logQueries.push(Object.fromEntries(request.urlParams.params))
       return Effect.succeed(
@@ -183,6 +185,7 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     const created = yield* client.session.create({
       location: Location.Ref.make({ directory: AbsolutePath.make("/tmp/project") }),
     })
+    yield* client.session.view({ sessionID: Session.ID.make("ses_test") })
     yield* client.session.switchAgent({ sessionID: Session.ID.make("ses_test"), agent: Agent.ID.make("build") })
     yield* client.session.switchModel({
       sessionID: Session.ID.make("ses_test"),
@@ -207,7 +210,11 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     return { page, active, created, admitted, context, log, message }
   }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
 
-  expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
+  const listed = result.page.data[0]
+  if (!listed?.time.idle || !listed.time.viewed) throw new Error("Expected attention times")
+  expect(DateTime.toEpochMillis(listed.time.created)).toBe(1_717_171_717_000)
+  expect(DateTime.toEpochMillis(listed.time.idle)).toBe(1_717_171_717_002)
+  expect(DateTime.toEpochMillis(listed.time.viewed)).toBe(1_717_171_717_001)
   expect(result.active).toEqual({ ses_test: { type: "running" } })
   expect(Object.getPrototypeOf(result.page.data[0])).toBe(Object.prototype)
   expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
@@ -217,11 +224,10 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   expect(DateTime.toEpochMillis(result.admitted.timeCreated)).toBe(1_717_171_717_000)
   expect(result.context).toEqual([])
   expect(logQueries[0]).toEqual({ after: "0" })
+  expect(requests).toContainEqual({ method: "POST", url: "http://localhost:3000/api/session/ses_test/view" })
   const logged = Array.from(result.log)
   expect(logged.map((item) => item.type)).toEqual(["session.model.selected", "log.synced"])
-  expect(logged[0]?.type === "session.model.selected" && DateTime.toEpochMillis(logged[0].created)).toBe(
-    1_717_171_717_000,
-  )
+  expect(logged[0]?.type === "session.model.selected" && logged[0].created).toBe(1_717_171_717_000)
   expect(logged.at(-1)).toEqual(synced)
   expect(result.message).toEqual(expect.objectContaining({ id: "msg_model", type: "model-switched" }))
 })
@@ -260,6 +266,8 @@ const session = {
     time: {
       created: 1_717_171_717_000,
       updated: 1_717_171_717_000,
+      idle: 1_717_171_717_002,
+      viewed: 1_717_171_717_001,
     },
     title: "Test",
     location: { directory: "/tmp/project" },

packages/client/test/promise.test.ts

@@ -539,6 +539,7 @@ test("session methods use the public HTTP contract", async () => {
   const page = await client.session.list({ limit: 10, order: "desc", parentID: null })
   const active = await client.session.active()
   const created = await client.session.create({ location: { directory: "/tmp/project" } })
+  await client.session.view({ sessionID: "ses_test" })
   await client.session.switchAgent({ sessionID: "ses_test", agent: "build" })
   await client.session.switchModel({
     sessionID: "ses_test",
@@ -565,6 +566,7 @@ test("session methods use the public HTTP contract", async () => {
   const message = await client.session.message({ sessionID: "ses_test", messageID: "msg_model" })
 
   expect(page.cursor.next).toBe("next")
+  expect(page.data[0].time).toMatchObject({ idle: 1_717_171_717_002, viewed: 1_717_171_717_001 })
   expect(active).toEqual({ ses_test: { type: "running" } })
   expect(created.id).toBe("ses_test")
   expect(admitted.id).toBe("msg_test")
@@ -577,6 +579,7 @@ test("session methods use the public HTTP contract", async () => {
     ["GET", "http://localhost:3000/api/session?limit=10&order=desc&parentID=null"],
     ["GET", "http://localhost:3000/api/session/active"],
     ["POST", "http://localhost:3000/api/session"],
+    ["POST", "http://localhost:3000/api/session/ses_test/view"],
     ["POST", "http://localhost:3000/api/session/ses_test/agent"],
     ["POST", "http://localhost:3000/api/session/ses_test/model"],
     ["POST", "http://localhost:3000/api/session/ses_test/prompt"],
@@ -651,6 +654,8 @@ const session = {
     time: {
       created: 1_717_171_717_000,
       updated: 1_717_171_717_000,
+      idle: 1_717_171_717_002,
+      viewed: 1_717_171_717_001,
     },
     title: "Test",
     location: { directory: "/tmp/project" },

packages/console/app/src/routes/legal/terms-of-service/index.tsx

@@ -21,7 +21,7 @@ export default function TermsOfService() {
           <section data-component="brand-content">
             <article data-component="terms-of-service">
               <h1>Terms of Use</h1>
-              <p class="effective-date">Effective date: Mar 6, 2026</p>
+              <p class="effective-date">Effective date: Aug 15, 2026</p>
 
               <p>
                 Welcome to OpenCode. Please read on to learn the rules and restrictions that govern your use of
@@ -154,6 +154,11 @@ export default function TermsOfService() {
                   is dangerous, harmful, fraudulent, deceptive, threatening, harassing, defamatory, obscene, or
                   otherwise objectionable;
                 </li>
+                <li>
+                  creates, maintains, or uses accounts in bulk, or creates, maintains, or uses multiple accounts to
+                  circumvent usage limits, access restrictions, billing obligations, promotions, suspensions, or any
+                  other restriction or policy applicable to the Services;
+                </li>
                 <li>automatically or programmatically extracts data or Output (defined below);</li>
                 <li>Represent that the Output was human-generated when it was not;</li>
                 <li>

packages/core/schema.json

@@ -1,8 +1,8 @@
 {
   "version": "7",
   "dialect": "sqlite",
-  "id": "dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936",
-  "prevIds": ["5c1aa56b-c3ee-4283-9a84-c0bf626dc604"],
+  "id": "94b6c496-ad84-426f-9d5d-3e1ac3ebfb56",
+  "prevIds": ["dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936"],
   "ddl": [
     {
       "name": "account_state",
@@ -1350,6 +1350,26 @@
       "entityType": "columns",
       "table": "session_v2"
     },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_idle",
+      "entityType": "columns",
+      "table": "session_v2"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_viewed",
+      "entityType": "columns",
+      "table": "session_v2"
+    },
     {
       "type": "integer",
       "notNull": false,

packages/core/src/bus.ts

@@ -1,6 +1,6 @@
 export * as Bus from "./bus.js"
 
-import { Cause, Context, DateTime, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
+import { Cause, Clock, Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
 import { Event } from "@opencode-ai/schema/event"
 import type { EventLog } from "@opencode-ai/schema/event-log"
 import { and, asc, eq, gt, lte, sql } from "drizzle-orm"
@@ -47,7 +47,7 @@ export const reserveSequence = Effect.fn("Bus.reserveSequence")(function* (
 export type SerializedEvent = {
   readonly id: Event.ID
   readonly type: string
-  readonly created?: DateTime.Utc
+  readonly created?: number
   readonly seq: number
   readonly aggregateID: string
   readonly data: Record<string, unknown>
@@ -74,7 +74,7 @@ const decodeSerializedEvent = (event: SerializedEvent): Event.Payload => {
   }
   return {
     id: event.id,
-    created: event.created ?? DateTime.makeUnsafe(0),
+    created: event.created ?? 0,
     type: definition.type,
     durable: envelope(event.aggregateID, event.seq, definition.durable.version),
     data: Schema.decodeUnknownSync(definition.data)(event.data),
@@ -283,7 +283,7 @@ export function configured(options?: Options) {
                               if (
                                 stored?.id === event.id &&
                                 stored.type === versionedType(definition.type, durable.version) &&
-                                stored.created === DateTime.toEpochMillis(event.created ?? DateTime.makeUnsafe(0)) &&
+                                stored.created === (event.created ?? 0) &&
                                 isDeepStrictEqual(stored.data, encoded)
                               ) {
                                 if (input.ownerID && row?.ownerID == null) {
@@ -358,7 +358,7 @@ export function configured(options?: Options) {
                                     id: event.id,
                                     aggregate_id: aggregateID,
                                     seq,
-                                    created: DateTime.toEpochMillis(event.created ?? DateTime.makeUnsafe(0)),
+                                    created: event.created ?? 0,
                                     type: versionedType(definition.type, durable.version),
                                     data: encoded,
                                   },
@@ -455,7 +455,7 @@ export function configured(options?: Options) {
               definition,
               {
                 id: options?.id ?? Event.ID.create(),
-                created: yield* DateTime.now,
+                created: yield* Clock.currentTimeMillis,
                 ...(options?.metadata ? { metadata: options.metadata } : {}),
                 type: definition.type,
                 ...(location ? { location } : {}),
@@ -491,7 +491,7 @@ export function configured(options?: Options) {
                   commit: options?.commit,
                   event: {
                     id: options?.id ?? Event.ID.create(),
-                    created: yield* DateTime.now,
+                    created: yield* Clock.currentTimeMillis,
                     ...(options?.metadata ? { metadata: options.metadata } : {}),
                     type: definition.type,
                     ...(location ? { location } : {}),
@@ -571,7 +571,7 @@ export function configured(options?: Options) {
                                 id: event.id,
                                 aggregate_id: aggregateID,
                                 seq,
-                                created: DateTime.toEpochMillis(event.created),
+                                created: event.created,
                                 type: versionedType(item.definition.type, item.definition.durable.version),
                                 data: encoded,
                               })
@@ -619,7 +619,7 @@ export function configured(options?: Options) {
                 Effect.gen(function* () {
                   const payload = {
                     id: event.id,
-                    created: event.created ?? DateTime.makeUnsafe(0),
+                    created: event.created ?? 0,
                     type: definition.type,
                     data: Schema.decodeUnknownSync(definition.data)(event.data),
                   } as Event.Payload
@@ -733,7 +733,7 @@ export function configured(options?: Options) {
                 return [
                   decodeSerializedEvent({
                     id: event.id,
-                    created: DateTime.makeUnsafe(event.created),
+                    created: event.created,
                     aggregateID: event.aggregate_id,
                     seq: event.seq,
                     type: event.type,

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

@@ -43,6 +43,7 @@ import m40 from "./migration/20260808023530_workspace_domain.js"
 import m41 from "./migration/20260811161259_execution_claim_attempts.js"
 import m42 from "./migration/20260812181746_session_inbox.js"
 import m43 from "./migration/20260812213948_worktree.js"
+import m44 from "./migration/20260815182818_session_viewed_state.js"
 
 export const migrations = [
   m00,
@@ -89,4 +90,5 @@ export const migrations = [
   m41,
   m42,
   m43,
+  m44,
 ] satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260815182818_session_viewed_state.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration.js"
+
+const migration: DatabaseMigration.Migration = {
+  id: "20260815182818_session_viewed_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`time_idle\` integer;`)
+      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`time_viewed\` integer;`)
+    })
+  },
+}
+
+export default migration

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

@@ -209,6 +209,8 @@ const schema: Omit<DatabaseMigration.Migration, "id"> = {
           \`model\` text,
           \`time_created\` integer NOT NULL,
           \`time_updated\` integer NOT NULL,
+          \`time_idle\` integer,
+          \`time_viewed\` integer,
           \`time_compacting\` integer,
           \`time_archived\` integer,
           \`time_suspended\` integer,

packages/core/src/plugin/skill/opencode.md

@@ -63,6 +63,33 @@ examples, but do not fetch it to determine the V2 configuration shape.
 See the [full configuration guide](https://opencode.ai/v2/docs/config) for
 every field, examples, config locations, and links to dedicated feature guides.
 
+## [MCP servers](https://opencode.ai/v2/docs/mcp-servers)
+
+Configure MCP servers under `mcp.servers`. Prefer the CLI because it preserves
+unrelated configuration. Use `--global` when the user asks to set up a service
+for themselves without limiting it to the current project; omit it when they
+explicitly want project-local configuration.
+
+```sh
+opencode2 mcp add <name> --global --url <remote-url>
+opencode2 mcp list
+```
+
+Remote servers use OAuth by default. If `mcp list` reports that a server needs
+authentication, run the OAuth flow and then verify the connection:
+
+```sh
+opencode2 mcp auth <name>
+opencode2 mcp list
+```
+
+The auth command prints an authorization URL, waits for the browser redirect,
+and stores credentials outside the OpenCode configuration. Do not ask for or
+store an API key when the server supports OAuth. Use header-based credentials
+only when OAuth is unavailable or the user explicitly requires them, and use an
+environment substitution such as `{env:MCP_API_KEY}` instead of writing a
+secret into configuration.
+
 ## [V1 to V2 migration](https://opencode.ai/v2/docs/migrate-v1)
 
 For any request to migrate OpenCode configuration, agents, commands, skills,

packages/core/src/session.ts

@@ -165,6 +165,7 @@ export interface Interface {
     input: ForkInput,
   ) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError | ForkEmptyError>
   readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>
+  readonly view: (input: { sessionID: SessionSchema.ID }) => Effect.Effect<void, NotFoundError>
   readonly remove: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
   readonly messages: (input: {
     sessionID: SessionSchema.ID
@@ -447,6 +448,17 @@ const layer = Layer.effect(
         if (!session) return yield* new NotFoundError({ sessionID })
         return session
       }),
+      view: Effect.fn("Session.view")(function* (input) {
+        const row = yield* db
+          .select({ idle: SessionTable.time_idle, viewed: SessionTable.time_viewed })
+          .from(SessionTable)
+          .where(eq(SessionTable.id, input.sessionID))
+          .get()
+          .pipe(Effect.orDie)
+        if (!row) return yield* new NotFoundError({ sessionID: input.sessionID })
+        if (row.idle === null || (row.viewed !== null && row.viewed >= row.idle)) return
+        yield* bus.publish(SessionEvent.Viewed, { sessionID: input.sessionID })
+      }),
       remove: Effect.fn("Session.remove")(function* (sessionID) {
         const session = yield* result.get(sessionID)
         yield* execution.interrupt(sessionID)

packages/core/src/session/execution.ts

@@ -137,13 +137,13 @@ export const layer = Layer.effect(
     return Service.of({
       active: coordinator.active,
       interrupt: (sessionID, options) =>
-        Effect.gen(function* () {
-          yield* coordinator.interrupt(sessionID, "user")
-          if (!options?.continue) return
-          // Resume only steering input from the interrupted intent. Queued next-turn work
-          // stays parked: a steer-scoped drain never promotes queue-delivery rows.
-          if (yield* SessionInbox.has(db, sessionID, "steer")) yield* coordinator.wake(sessionID, "steer")
-        }),
+        coordinator.interrupt(
+          sessionID,
+          "user",
+          options?.continue
+            ? { continue: { request: "steer", when: SessionInbox.has(db, sessionID, "steer") } }
+            : undefined,
+        ),
       resume: coordinator.run,
       wake: coordinator.wake,
       wakeActive: coordinator.wakeActive,

packages/core/src/session/inbox.ts

@@ -161,7 +161,7 @@ export const admit = Effect.fn("SessionInbox.admit")(function* (
         const base = {
           id: request.id,
           sessionID: request.sessionID,
-          timeCreated: event.created,
+          timeCreated: DateTime.makeUnsafe(event.created),
         }
         return Effect.succeed(Info.make({ ...base, ...request.item }))
       }),
@@ -196,7 +196,7 @@ export const projectAdmitted = Effect.fn("SessionInbox.projectAdmitted")(functio
     readonly id: SessionMessage.ID
     readonly sessionID: SessionSchema.ID
     readonly item: Item
-    readonly timeCreated: DateTime.Utc
+    readonly timeCreated: number
   },
 ) {
   const message = yield* db
@@ -222,7 +222,7 @@ export const projectAdmitted = Effect.fn("SessionInbox.projectAdmitted")(functio
               : encodeMove(request.item.payload),
       delivery: request.item.delivery,
       enqueued_seq: request.enqueuedSeq,
-      time_created: DateTime.toEpochMillis(request.timeCreated),
+      time_created: request.timeCreated,
     })
     .onConflictDoNothing()
     .returning({ id: SessionInboxTable.id })

packages/core/src/session/info.ts

@@ -53,6 +53,8 @@ export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.In
     time: {
       created: DateTime.makeUnsafe(row.time_created),
       updated: DateTime.makeUnsafe(row.time_updated),
+      idle: row.time_idle === null ? undefined : DateTime.makeUnsafe(row.time_idle),
+      viewed: row.time_viewed === null ? undefined : DateTime.makeUnsafe(row.time_viewed),
       archived: row.time_archived ? DateTime.makeUnsafe(row.time_archived) : undefined,
     },
   })

packages/core/src/session/message-updater.ts

@@ -26,6 +26,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
   type DraftTool = WritableDraft<SessionMessage.AssistantTool>
   type DraftText = WritableDraft<SessionMessage.AssistantText>
   type DraftReasoning = WritableDraft<SessionMessage.AssistantReasoning>
+  const created = DateTime.makeUnsafe(event.created)
 
   const latestTool = (assistant: DraftAssistant | undefined, id?: string) =>
     assistant?.content.findLast(
@@ -59,6 +60,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
     Match.type<SessionEvent.DurableEvent>(),
     Match.discriminatorsExhaustive("type")({
       "session.created": () => Effect.void,
+      "session.viewed": () => Effect.void,
       "session.usage.recorded": () => Effect.void,
       "session.agent.selected": (event) => {
         return Effect.gen(function* () {
@@ -70,7 +72,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
               metadata: event.metadata,
               agent: event.data.agent,
               previous,
-              time: { created: event.created },
+              time: { created },
             }),
           )
         })
@@ -85,7 +87,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
               metadata: event.metadata,
               model: event.data.model,
               previous,
-              time: { created: event.created },
+              time: { created },
             }),
           )
         })
@@ -101,7 +103,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
               projectID: event.data.projectID,
               subpath: event.data.subpath,
               previous: yield* adapter.getLocation(),
-              time: { created: event.created },
+              time: { created },
             }),
           )
         })
@@ -126,7 +128,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             text: event.data.text,
             description: `Instructions updated: ${Object.keys(event.data.delta).join(", ")}`,
             metadata: event.metadata,
-            time: { created: event.created },
+            time: { created },
           }),
         )
       },
@@ -138,7 +140,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             metadata: event.data.metadata,
             id: SessionMessage.ID.fromEvent(event.id),
             type: "synthetic",
-            time: { created: event.created },
+            time: { created },
           }),
         )
       },
@@ -151,7 +153,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             name: event.data.name,
             text: event.data.text,
             metadata: event.metadata,
-            time: { created: event.created },
+            time: { created },
           }),
         )
       },
@@ -164,7 +166,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             shellID: event.data.shell.id,
             command: event.data.shell.command,
             status: event.data.shell.status,
-            time: { created: event.created },
+            time: { created },
           }),
         )
       },
@@ -177,7 +179,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
                 draft.status = event.data.shell.status
                 draft.exit = event.data.shell.exit
                 draft.output = event.data.output
-                draft.time.completed = event.created
+                draft.time.completed = created
               }),
             )
           }
@@ -205,7 +207,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             yield* adapter.updateAssistant(
               produce(currentAssistant, (draft) => {
                 draft.retry = undefined
-                draft.time.completed = event.created
+                draft.time.completed = created
               }),
             )
           }
@@ -216,7 +218,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
               agent: event.data.agent,
               model: event.data.model,
               metadata: event.metadata,
-              time: { created: event.created },
+              time: { created },
               content: [],
               snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
             }),
@@ -225,7 +227,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       },
       "session.step.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          draft.time.completed = event.created
+          draft.time.completed = created
           draft.finish = event.data.finish
           draft.cost = event.data.cost
           draft.tokens = event.data.tokens
@@ -239,7 +241,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       },
       "session.step.failed": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          draft.time.completed = event.created
+          draft.time.completed = created
           draft.finish = "error"
           draft.error = castDraft(event.data.error)
           draft.retry = undefined
@@ -277,7 +279,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
                 type: "tool",
                 id: event.data.id,
                 name: event.data.name,
-                time: { created: event.created },
+                time: { created },
                 state: SessionMessage.ToolStateStreaming.make({ status: "streaming", input: "" }),
               }),
             ),
@@ -296,7 +298,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           if (match) {
             match.executed = event.data.executed
             match.providerState = event.data.state
-            match.time.ran = event.created
+            match.time.ran = created
             match.state = castDraft(
               SessionMessage.ToolStateRunning.make({
                 status: "running",
@@ -315,7 +317,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           if (match && match.state.status === "running") {
             match.executed = event.data.executed || match.executed === true
             match.providerResultState = event.data.resultState
-            match.time.completed = event.created
+            match.time.completed = created
             match.state = castDraft(
               SessionMessage.ToolStateCompleted.make({
                 status: "completed",
@@ -333,7 +335,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           if (match && (match.state.status === "streaming" || match.state.status === "running")) {
             match.executed = event.data.executed || match.executed === true
             match.providerResultState = event.data.resultState
-            match.time.completed = event.created
+            match.time.completed = created
             match.state = castDraft(
               SessionMessage.ToolStateError.make({
                 status: "error",
@@ -354,7 +356,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
                 type: "reasoning",
                 text: "",
                 state: event.data.state,
-                time: { created: event.created },
+                time: { created },
               }),
             ),
           )
@@ -365,7 +367,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           const match = latestReasoning(draft)
           if (match) {
             match.text = event.data.text
-            match.time = { created: match.time?.created ?? event.created, completed: event.created }
+            match.time = { created: match.time?.created ?? created, completed: created }
             if (event.data.state !== undefined) match.state = event.data.state
           }
         })
@@ -389,7 +391,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             reason: event.data.reason,
             summary: "",
             recent: event.data.recent ?? "",
-            time: { created: event.created },
+            time: { created },
           }),
         ),
       "session.compaction.ended": (event) => {
@@ -414,7 +416,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
               reason: event.data.reason,
               summary: event.data.text,
               recent: event.data.recent,
-              time: { created: event.created },
+              time: { created },
             }),
           )
         })
@@ -429,7 +431,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             metadata: current?.metadata ?? event.metadata,
             reason: event.data.reason,
             error: event.data.error,
-            time: current?.time ?? { created: event.created },
+            time: current?.time ?? { created },
           })
           if (current?.status === "running") return yield* adapter.updateCompaction(failed)
           yield* adapter.appendMessage(failed)

packages/core/src/session/projector.ts

@@ -162,8 +162,8 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
       tokens_reasoning: 0,
       tokens_cache_read: 0,
       tokens_cache_write: 0,
-      time_created: DateTime.toEpochMillis(event.created),
-      time_updated: DateTime.toEpochMillis(event.created),
+      time_created: event.created,
+      time_updated: event.created,
     })
     .onConflictDoNothing()
     .returning({ sessionID: SessionTable.id })
@@ -391,6 +391,30 @@ function insertMessage(db: DatabaseService, event: SessionEvent.DurableEvent, me
     .pipe(Effect.orDie)
 }
 
+function projectIdle(
+  db: DatabaseService,
+  event:
+    | typeof SessionEvent.Execution.Succeeded.Type
+    | typeof SessionEvent.Execution.Failed.Type
+    | typeof SessionEvent.Execution.Interrupted.Type,
+) {
+  return Effect.gen(function* () {
+    yield* run(db, event)
+    if (event.type === SessionEvent.Execution.Interrupted.type && event.data.reason === "shutdown") return
+    const time = event.created
+    yield* db
+      .update(SessionTable)
+      .set({
+        // Unread uses a strict timestamp comparison, so every terminal must advance even within one millisecond.
+        time_idle: sql`max(${time}, coalesce(${SessionTable.time_idle} + 1, ${time}))`,
+        time_updated: sql`${SessionTable.time_updated}`,
+      })
+      .where(eq(SessionTable.id, event.data.sessionID))
+      .run()
+      .pipe(Effect.orDie)
+  })
+}
+
 const layer = Layer.effectDiscard(
   Effect.gen(function* () {
     const bus = yield* Bus.Service
@@ -411,8 +435,8 @@ const layer = Layer.effectDiscard(
             agent: event.data.agent,
             model: event.data.model,
             version: event.data.version,
-            time_created: DateTime.toEpochMillis(event.created),
-            time_updated: DateTime.toEpochMillis(event.created),
+            time_created: event.created,
+            time_updated: event.created,
           })
           .onConflictDoNothing()
           .returning({ sessionID: SessionTable.id })
@@ -431,7 +455,7 @@ const layer = Layer.effectDiscard(
             path: event.data.subpath,
             ...(event.data.projectID ? { project_id: event.data.projectID } : {}),
             workspace_id: event.data.location.workspaceID ? Workspace.ID.make(event.data.location.workspaceID) : null,
-            time_updated: DateTime.toEpochMillis(event.created),
+            time_updated: event.created,
           })
           .where(eq(SessionTable.id, event.data.sessionID))
           .run()
@@ -487,7 +511,7 @@ const layer = Layer.effectDiscard(
         yield* run(db, event)
         yield* db
           .update(SessionTable)
-          .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.created) })
+          .set({ agent: event.data.agent, time_updated: event.created })
           .where(eq(SessionTable.id, event.data.sessionID))
           .run()
           .pipe(Effect.orDie)
@@ -498,7 +522,7 @@ const layer = Layer.effectDiscard(
         yield* run(db, event)
         yield* db
           .update(SessionTable)
-          .set({ model: event.data.model, time_updated: DateTime.toEpochMillis(event.created) })
+          .set({ model: event.data.model, time_updated: event.created })
           .where(eq(SessionTable.id, event.data.sessionID))
           .run()
           .pipe(Effect.orDie)
@@ -507,7 +531,18 @@ const layer = Layer.effectDiscard(
     yield* bus.project(SessionEvent.Renamed, (event) =>
       db
         .update(SessionTable)
-        .set({ title: event.data.title, time_updated: DateTime.toEpochMillis(event.created) })
+        .set({ title: event.data.title, time_updated: event.created })
+        .where(eq(SessionTable.id, event.data.sessionID))
+        .run()
+        .pipe(Effect.orDie),
+    )
+    yield* bus.project(SessionEvent.Viewed, (event) =>
+      db
+        .update(SessionTable)
+        .set({
+          time_viewed: sql`${SessionTable.time_idle}`,
+          time_updated: sql`${SessionTable.time_updated}`,
+        })
         .where(eq(SessionTable.id, event.data.sessionID))
         .run()
         .pipe(Effect.orDie),
@@ -535,7 +570,7 @@ const layer = Layer.effectDiscard(
                 files: input.payload.files,
                 agents: input.payload.agents,
                 skills: input.payload.skills,
-                time: { created: event.created },
+                time: { created: DateTime.makeUnsafe(event.created) },
               }
             : {
                 id: input.id,
@@ -543,7 +578,7 @@ const layer = Layer.effectDiscard(
                 text: input.payload.text,
                 description: input.payload.description,
                 metadata: input.payload.metadata,
-                time: { created: event.created },
+                time: { created: DateTime.makeUnsafe(event.created) },
               },
         )
       }),
@@ -561,7 +596,7 @@ const layer = Layer.effectDiscard(
         })
         yield* db
           .update(SessionTable)
-          .set({ time_updated: DateTime.toEpochMillis(event.created) })
+          .set({ time_updated: event.created })
           .where(eq(SessionTable.id, event.data.sessionID))
           .run()
           .pipe(Effect.orDie)
@@ -580,9 +615,9 @@ const layer = Layer.effectDiscard(
         delivery: event.data.delivery,
       }),
     )
-    yield* bus.project(SessionEvent.Execution.Succeeded, (event) => run(db, event))
-    yield* bus.project(SessionEvent.Execution.Failed, (event) => run(db, event))
-    yield* bus.project(SessionEvent.Execution.Interrupted, (event) => run(db, event))
+    yield* bus.project(SessionEvent.Execution.Succeeded, (event) => projectIdle(db, event))
+    yield* bus.project(SessionEvent.Execution.Failed, (event) => projectIdle(db, event))
+    yield* bus.project(SessionEvent.Execution.Interrupted, (event) => projectIdle(db, event))
     yield* bus.project(SessionEvent.InstructionsUpdated, (event) =>
       Effect.gen(function* () {
         yield* run(db, event)
@@ -640,7 +675,7 @@ const layer = Layer.effectDiscard(
           .update(SessionTable)
           .set({
             revert: { ...revert, files: revert.files ? [...revert.files] : undefined },
-            time_updated: DateTime.toEpochMillis(event.created),
+            time_updated: event.created,
           })
           .where(eq(SessionTable.id, event.data.sessionID))
           .run()
@@ -650,7 +685,7 @@ const layer = Layer.effectDiscard(
     yield* bus.project(SessionEvent.RevertEvent.Cleared, (event) =>
       db
         .update(SessionTable)
-        .set({ revert: null, time_updated: DateTime.toEpochMillis(event.created) })
+        .set({ revert: null, time_updated: event.created })
         .where(eq(SessionTable.id, event.data.sessionID))
         .run()
         .pipe(Effect.orDie, Effect.asVoid),
@@ -685,7 +720,7 @@ const layer = Layer.effectDiscard(
           .pipe(Effect.orDie)
         yield* db
           .update(SessionTable)
-          .set({ revert: null, time_updated: DateTime.toEpochMillis(event.created) })
+          .set({ revert: null, time_updated: event.created })
           .where(eq(SessionTable.id, event.data.sessionID))
           .run()
           .pipe(Effect.orDie)

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

@@ -10,19 +10,25 @@ export interface Coordinator<Key, E, Reason = never> {
   /** Starts an execution while idle, or joins the active execution and returns its exit. */
   readonly run: (key: Key) => Effect.Effect<void, E>
   /** Rings the doorbell: an idle key starts an execution; an active one drains again before settling. */
-  readonly wake: (key: Key, scope?: Promotable) => Effect.Effect<void>
-  /** Rings the current execution's doorbell with its existing scope. Idle keys remain idle. */
+  readonly wake: (key: Key, request?: Request) => Effect.Effect<void>
+  /** Rings the current execution's doorbell with its existing request. Idle keys remain idle. */
   readonly wakeActive: (key: Key) => Effect.Effect<void>
   /** Stops the active execution, clears its doorbell, and waits for cleanup. No-op when idle. */
-  readonly interrupt: (key: Key, reason?: Reason) => Effect.Effect<void>
+  readonly interrupt: (
+    key: Key,
+    reason?: Reason,
+    options?: { readonly continue?: { readonly request: Request; readonly when: Effect.Effect<boolean> } },
+  ) => Effect.Effect<void>
   /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
   readonly awaitIdle: (key: Key) => Effect.Effect<void>
 }
 
+export type Request = Promotable
+
 /**
  * One execution is a busy period for one key: one fiber that drains from the first wake
  * until the key would stay idle. `pendingWake` is the doorbell: work recorded during the
- * execution rings it with the scope that work needs, and the execution loop drains again
+ * execution rings it with its eligibility request, and the execution loop drains again
  * instead of ending. The doorbell closes the gap between a drain's last eligibility check
  * and the idle transition, since those cannot be one atomic step. `done` resolves joiners
  * with this execution's exit.
@@ -30,10 +36,15 @@ export interface Coordinator<Key, E, Reason = never> {
 type Execution<E, Reason> = {
   readonly done: Deferred.Deferred<void, E>
   owner?: Fiber.Fiber<void>
-  scope: Promotable
-  pendingWake?: Promotable
+  request: Request
+  pendingWake?: Request
   stopping: boolean
   interruptionReason?: Reason
+  continuation?: {
+    readonly request: Request
+    readonly when: Effect.Effect<boolean>
+    signaled: boolean
+  }
 }
 
 /**
@@ -48,7 +59,7 @@ type Execution<E, Reason> = {
  * ```
  */
 export const make = <Key, E, Reason = never>(options: {
-  readonly drain: (key: Key, force: boolean, scope: Promotable) => Effect.Effect<void, E>
+  readonly drain: (key: Key, force: boolean, request: Request) => Effect.Effect<void, E>
   /** Runs once when a process-local busy period begins, before its first drain. */
   readonly started?: (key: Key) => Effect.Effect<void>
   /**
@@ -62,11 +73,11 @@ export const make = <Key, E, Reason = never>(options: {
     const fork = yield* FiberSet.makeRuntime<never, void, never>()
 
     const loop = (key: Key, execution: Execution<E, Reason>, force: boolean): Effect.Effect<void, E> =>
-      Effect.suspend(() => options.drain(key, force, execution.scope)).pipe(
+      Effect.suspend(() => options.drain(key, force, execution.request)).pipe(
         Effect.flatMap(() =>
           Effect.suspend(() => {
             if (execution.stopping || execution.pendingWake === undefined) return Effect.void
-            execution.scope = execution.pendingWake
+            execution.request = execution.pendingWake
             execution.pendingWake = undefined
             // Trampoline so drains that complete synchronously cannot grow the stack.
             return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)))
@@ -74,10 +85,10 @@ export const make = <Key, E, Reason = never>(options: {
         ),
       )
 
-    const start = (key: Key, force: boolean, scope: Promotable) => {
+    const start = (key: Key, force: boolean, request: Request) => {
       const execution: Execution<E, Reason> = {
         done: Deferred.makeUnsafe<void, E>(),
-        scope,
+        request,
         stopping: false,
       }
       executions.set(key, execution)
@@ -93,7 +104,7 @@ export const make = <Key, E, Reason = never>(options: {
               execution.owner = undefined
             }).pipe(Effect.andThen(options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void)),
           ),
-          Effect.onExit((exit) => Effect.sync(() => settle(key, execution, exit))),
+          Effect.onExit((exit) => finish(key, execution, exit)),
           Effect.exit,
           Effect.asVoid,
         ),
@@ -103,12 +114,22 @@ export const make = <Key, E, Reason = never>(options: {
 
     // A doorbell that survives the execution loop (rung after the loop decided to end, or
     // during failure or interruption cleanup) starts a fresh execution for the remaining work.
-    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {
-      if (execution.pendingWake) start(key, false, execution.pendingWake)
+    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>, resume: boolean) => {
+      if (resume && execution.continuation) start(key, false, execution.continuation.request)
+      else if (execution.pendingWake) start(key, false, execution.pendingWake)
       else executions.delete(key)
       Deferred.doneUnsafe(execution.done, exit)
     }
 
+    const finish = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {
+      if (!execution.continuation) return Effect.sync(() => settle(key, execution, exit, false))
+      return execution.continuation.when.pipe(
+        Effect.flatMap((ready) =>
+          Effect.sync(() => settle(key, execution, exit, ready || execution.continuation?.signaled === true)),
+        ),
+      )
+    }
+
     const run = (key: Key): Effect.Effect<void, E> =>
       Effect.suspend(() => {
         const execution = executions.get(key)
@@ -120,32 +141,55 @@ export const make = <Key, E, Reason = never>(options: {
         return Deferred.await(start(key, true, "input").done)
       })
 
-    const wake = (key: Key, scope: Promotable = "input") =>
+    const wake = (key: Key, request: Request = "input") =>
       Effect.sync(() => {
         const execution = executions.get(key)
         if (execution !== undefined) {
-          // Coalesced wakes keep the widest scope: "input" subsumes "steer".
-          execution.pendingWake = execution.pendingWake === "input" ? "input" : scope
+          if (execution.stopping) {
+            if (execution.continuation) execution.continuation.signaled = true
+            else execution.continuation = { request, when: Effect.succeed(true), signaled: true }
+            return
+          }
+          // Coalesced wakes keep the widest request: "input" subsumes "steer".
+          execution.pendingWake = execution.pendingWake === "input" ? "input" : request
           return
         }
-        start(key, false, scope)
+        start(key, false, request)
       })
 
     const wakeActive = (key: Key) =>
       Effect.suspend(() => {
         const execution = executions.get(key)
-        return execution ? wake(key, execution.scope) : Effect.void
+        return execution ? wake(key, execution.request) : Effect.void
       })
 
-    const interrupt = (key: Key, reason?: Reason): Effect.Effect<void> =>
+    const interrupt = (
+      key: Key,
+      reason?: Reason,
+      options?: { readonly continue?: { readonly request: Request; readonly when: Effect.Effect<boolean> } },
+    ): Effect.Effect<void> =>
       Effect.suspend(() => {
         const execution = executions.get(key)
-        if (execution?.owner === undefined || execution.stopping) return Effect.void
+        if (execution === undefined) return Effect.void
+        if (execution.stopping) {
+          if (options?.continue)
+            execution.continuation = {
+              ...options.continue,
+              signaled: execution.continuation?.signaled ?? false,
+            }
+          return Deferred.await(execution.done).pipe(Effect.exit, Effect.asVoid)
+        }
+        if (execution.owner === undefined) {
+          if (!options?.continue) return Effect.void
+          execution.stopping = true
+          execution.pendingWake = undefined
+          execution.continuation = { ...options.continue, signaled: false }
+          return Deferred.await(execution.done).pipe(Effect.exit, Effect.asVoid)
+        }
         execution.stopping = true
-        // Wakes recorded so far belong to the interrupted intent; the interrupt claims them.
-        // Wakes arriving during cleanup are new admissions and restart normally at settle.
         execution.pendingWake = undefined
         execution.interruptionReason = reason
+        if (options?.continue) execution.continuation = { ...options.continue, signaled: false }
         return Fiber.interrupt(execution.owner)
       })
 

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

@@ -1,5 +1,5 @@
 import { type LLMEvent, type ProviderMetadata, type ToolResultValue } from "@opencode-ai/ai"
-import { Effect } from "effect"
+import { Clock, Effect } from "effect"
 import { Bus } from "../../bus.js"
 import { Model } from "../../model.js"
 import { SessionEvent } from "../event.js"
@@ -81,6 +81,7 @@ const hostedContent = (result: ToolResultValue): NonEmptyContent => {
  * and consumers fold by id/ordinal rather than global position.
  */
 export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, input: Input) => {
+  const deltaBatchInterval = 100
   const tools = new Map<
     string,
     {
@@ -123,32 +124,56 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
   const fragments = (
     name: string,
     ended: (id: string, value: string, ordinal: number, state?: Record<string, unknown>) => Effect.Effect<void>,
+    delta?: (id: string, value: string, ordinal: number) => Effect.Effect<void>,
     single = false,
   ) => {
-    const chunks = new Map<
-      string,
-      { readonly ordinal: number; readonly values: string[]; state?: Record<string, unknown> }
-    >()
+    type Fragment = {
+      readonly ordinal: number
+      readonly values: string[]
+      pending: string
+      publishedAt?: number
+      state?: Record<string, unknown>
+    }
+    const chunks = new Map<string, Fragment>()
     let nextOrdinal = 0
     const start = (id: string, state?: Record<string, unknown>) =>
       Effect.suspend(() => {
         if (chunks.has(id)) return Effect.die(new Error(`Duplicate ${name} start: ${id}`))
         if (single && chunks.size > 0) return Effect.die(new Error(`${name} start before end: ${id}`))
         const ordinal = nextOrdinal++
-        chunks.set(id, { ordinal, values: [], state })
+        chunks.set(id, { ordinal, values: [], pending: "", state })
         return Effect.succeed(ordinal)
       })
-    const append = (id: string, value: string, state?: Record<string, unknown>) =>
-      Effect.suspend(() => {
-        const current = chunks.get(id)
-        if (!current) return Effect.die(new Error(`${name} delta before start: ${id}`))
-        current.values.push(value)
-        if (state !== undefined) current.state = { ...current.state, ...state }
-        return Effect.succeed(current.ordinal)
-      })
+    const publishDelta = Effect.fnUntraced(function* (id: string, force = false) {
+      if (!delta) return undefined
+      const current = chunks.get(id)
+      if (!current) return yield* Effect.die(new Error(`${name} delta before start: ${id}`))
+      if (!current.pending) return undefined
+      const now = yield* Clock.currentTimeMillis
+      if (!force && current.publishedAt === undefined) {
+        current.publishedAt = now
+        return undefined
+      }
+      if (!force && current.publishedAt !== undefined && now - current.publishedAt < deltaBatchInterval)
+        return undefined
+      yield* delta(id, current.pending, current.ordinal)
+      current.pending = ""
+      current.publishedAt = now
+      return undefined
+    })
+    const append = Effect.fnUntraced(function* (id: string, value: string, state?: Record<string, unknown>) {
+      const current = chunks.get(id)
+      if (!current) return yield* Effect.die(new Error(`${name} delta before start: ${id}`))
+      current.values.push(value)
+      if (delta) current.pending += value
+      if (state !== undefined) current.state = { ...current.state, ...state }
+      yield* publishDelta(id)
+      return current.ordinal
+    })
     const end = Effect.fnUntraced(function* (id: string, state?: Record<string, unknown>, value?: string) {
       const current = chunks.get(id)
       if (!current) return yield* Effect.die(new Error(`${name} end before start: ${id}`))
+      yield* publishDelta(id, true)
       yield* ended(
         id,
         value ?? current.values.join(""),
@@ -156,9 +181,10 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         state === undefined ? current.state : { ...current.state, ...state },
       )
       chunks.delete(id)
+      return undefined
     })
     const flush = Effect.fnUntraced(function* () {
-      for (const id of chunks.keys()) yield* end(id)
+      for (const id of Array.from(chunks.keys())) yield* end(id)
     })
     return { start, append, end, flush, has: (id: string) => chunks.has(id) }
   }
@@ -175,6 +201,15 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
           state,
         })
       }),
+    (_textID, value, ordinal) =>
+      Effect.gen(function* () {
+        yield* bus.publish(SessionEvent.Text.Delta, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* currentAssistantMessageID(),
+          ordinal,
+          delta: value,
+        })
+      }),
     true,
   )
   const reasoning = fragments(
@@ -189,6 +224,15 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
           state,
         })
       }),
+    (_reasoningID, value, ordinal) =>
+      Effect.gen(function* () {
+        yield* bus.publish(SessionEvent.Reasoning.Delta, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* currentAssistantMessageID(),
+          ordinal,
+          delta: value,
+        })
+      }),
     true,
   )
   const toolInput = fragments("tool input", (id, value) =>
@@ -351,13 +395,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         })
         return
       case "text-delta":
-        const deltaTextOrdinal = yield* text.append(event.id, event.text, providerState(event.providerMetadata))
-        yield* bus.publish(SessionEvent.Text.Delta, {
-          sessionID: input.sessionID,
-          assistantMessageID: yield* currentAssistantMessageID(),
-          ordinal: deltaTextOrdinal,
-          delta: event.text,
-        })
+        yield* text.append(event.id, event.text, providerState(event.providerMetadata))
         return
       case "text-end":
         yield* text.end(event.id, providerState(event.providerMetadata))
@@ -373,17 +411,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         })
         return
       case "reasoning-delta":
-        const deltaReasoningOrdinal = yield* reasoning.append(
-          event.id,
-          event.text,
-          providerState(event.providerMetadata),
-        )
-        yield* bus.publish(SessionEvent.Reasoning.Delta, {
-          sessionID: input.sessionID,
-          assistantMessageID: yield* currentAssistantMessageID(),
-          ordinal: deltaReasoningOrdinal,
-          delta: event.text,
-        })
+        yield* reasoning.append(event.id, event.text, providerState(event.providerMetadata))
         return
       case "reasoning-end":
         yield* reasoning.end(event.id, providerState(event.providerMetadata))
@@ -399,12 +427,6 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
           return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`))
         if (!toolInput.has(event.id)) return yield* Effect.die(new Error(`Tool input delta after end: ${event.id}`))
         yield* toolInput.append(event.id, event.text)
-        yield* bus.publish(SessionEvent.Tool.Input.Delta, {
-          sessionID: input.sessionID,
-          assistantMessageID: tool.assistantMessageID,
-          id: event.id,
-          delta: event.text,
-        })
         return
       }
       case "tool-input-end":

packages/core/src/session/sql.ts

@@ -56,6 +56,8 @@ export const SessionTable = sqliteTable(
       variant?: string
     }>(),
     ...Timestamps,
+    time_idle: integer(),
+    time_viewed: integer(),
     time_compacting: integer(),
     time_archived: integer(),
     /** The execution claim timestamp (historical column name; see SessionStore.claim). */

packages/core/src/session/transfer.ts

@@ -117,6 +117,10 @@ const layer = Layer.effect(
                       tokens_cache_write: input.data.info.tokens.cache.write,
                       time_created: DateTime.toEpochMillis(input.data.info.time.created),
                       time_updated: DateTime.toEpochMillis(input.data.info.time.updated),
+                      time_idle: input.data.info.time.idle ? DateTime.toEpochMillis(input.data.info.time.idle) : null,
+                      time_viewed: input.data.info.time.viewed
+                        ? DateTime.toEpochMillis(input.data.info.time.viewed)
+                        : null,
                       time_archived: input.data.info.time.archived
                         ? DateTime.toEpochMillis(input.data.info.time.archived)
                         : null,

packages/core/src/tool/plugin/subagent.ts

@@ -181,9 +181,7 @@ export const Plugin = {
                 )
 
               const background = input.background === true
-              yield* context.progress({
-                metadata: { sessionID: child.id, status: "running" },
-              })
+              yield* context.progress({ sessionID: child.id, status: "running" })
 
               const run = Effect.gen(function* () {
                 // The child session owns its agent/model (set at create); prompt only admits input.

packages/core/test/bus.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect } from "bun:test"
-import { Cause, DateTime, Deferred, Effect, Exit, Fiber, Layer, Option, Ref, Schema, Stream } from "effect"
+import { Cause, Deferred, Effect, Exit, Fiber, Layer, Option, Ref, Schema, Stream } from "effect"
 import { Bus } from "@opencode-ai/core/bus"
 import { Event } from "@opencode-ai/schema/event"
 import { Session } from "@opencode-ai/schema/session"
@@ -422,7 +422,7 @@ describe("Bus", () => {
       const { db } = yield* Database.Service
       const aggregateID = Event.ID.create()
 
-      yield* bus.publish(SyncMessage, { id: aggregateID, text: "first" })
+      const event = yield* bus.publish(SyncMessage, { id: aggregateID, text: "first" })
       const rows = yield* db
         .select()
         .from(EventTable)
@@ -433,6 +433,7 @@ describe("Bus", () => {
       expect(rows).toHaveLength(1)
       expect(rows[0]?.type).toBe(Bus.versionedType(SyncMessage.type, 1))
       expect(rows[0]?.aggregate_id).toBe(aggregateID)
+      expect(rows[0]?.created).toBe(event.created)
     }),
   )
 
@@ -706,7 +707,7 @@ describe("Bus", () => {
 
       yield* bus.replay({
         id: Event.ID.create(),
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(DurableMessage.type, 1),
         seq: 0,
         aggregateID,
@@ -726,7 +727,7 @@ describe("Bus", () => {
 
       yield* bus.replay({
         id: Event.ID.create(),
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(DurableMessage.type, 1),
         seq: 0,
         aggregateID,
@@ -763,7 +764,7 @@ describe("Bus", () => {
         const exit = yield* bus
           .replay({
             id: Event.ID.create(),
-            created: DateTime.makeUnsafe(0),
+            created: 0,
             type: Bus.versionedType(DurableMessage.type, 1),
             seq: 1,
             aggregateID: envelopeAggregateID,
@@ -797,7 +798,7 @@ describe("Bus", () => {
 
       yield* bus.replay({
         id: Event.ID.create(),
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(DurableMessage.type, 1),
         seq: 0,
         aggregateID,
@@ -806,7 +807,7 @@ describe("Bus", () => {
       const exit = yield* bus
         .replay({
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 5,
           aggregateID,
@@ -831,14 +832,14 @@ describe("Bus", () => {
 
       yield* bus.replay({
         id: Event.ID.create(),
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(SessionEvent.InstructionsUpdated.type, 2),
         seq: 0,
         aggregateID,
         data: { sessionID: aggregateID, delta: { "core/context": "0".repeat(64) } },
       })
 
-      expect(received[0]?.created).toEqual(DateTime.makeUnsafe(0))
+      expect(received[0]?.created).toBe(0)
     }),
   )
 
@@ -867,7 +868,7 @@ describe("Bus", () => {
       const exit = yield* bus
         .replay({
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: "unknown.event.1",
           seq: 0,
           aggregateID: Event.ID.create(),
@@ -895,7 +896,7 @@ describe("Bus", () => {
       yield* bus.replay(
         {
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 1,
           aggregateID,
@@ -915,7 +916,7 @@ describe("Bus", () => {
       const id = Event.ID.create()
       const replayed = {
         id,
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(DurableMessage.type, 1),
         seq: 0,
         aggregateID,
@@ -972,7 +973,7 @@ describe("Bus", () => {
       yield* bus.replay(
         {
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 0,
           aggregateID,
@@ -1001,7 +1002,7 @@ describe("Bus", () => {
       yield* bus.replay(
         {
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 1,
           aggregateID,
@@ -1012,7 +1013,7 @@ describe("Bus", () => {
       yield* bus.replay(
         {
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 2,
           aggregateID,
@@ -1045,7 +1046,7 @@ describe("Bus", () => {
       yield* bus.replay(
         {
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 0,
           aggregateID,
@@ -1058,7 +1059,7 @@ describe("Bus", () => {
         .replay(
           {
             id: Event.ID.create(),
-            created: DateTime.makeUnsafe(0),
+            created: 0,
             type: Bus.versionedType(DurableMessage.type, 1),
             seq: 1,
             aggregateID,
@@ -1080,7 +1081,7 @@ describe("Bus", () => {
       yield* bus.listen((event) => Effect.sync(() => received.push(event)))
       const replayed = {
         id: Event.ID.create(),
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(DurableMessage.type, 1),
         seq: 0,
         aggregateID,
@@ -1101,7 +1102,7 @@ describe("Bus", () => {
       const aggregateID = Session.ID.create()
       const replayed = {
         id: Event.ID.create(),
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(DurableMessage.type, 1),
         seq: 0,
         aggregateID,
@@ -1126,7 +1127,7 @@ describe("Bus", () => {
       const id = Event.ID.create()
       yield* bus.replay({
         id,
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(DurableMessage.type, 1),
         seq: 0,
         aggregateID,
@@ -1136,7 +1137,7 @@ describe("Bus", () => {
       const exit = yield* bus
         .replay({
           id,
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 1,
           aggregateID,
@@ -1159,7 +1160,7 @@ describe("Bus", () => {
       yield* bus.replay(
         {
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 0,
           aggregateID,
@@ -1170,7 +1171,7 @@ describe("Bus", () => {
       yield* bus.replay(
         {
           id: Event.ID.create(),
-          created: DateTime.makeUnsafe(0),
+          created: 0,
           type: Bus.versionedType(DurableMessage.type, 1),
           seq: 1,
           aggregateID,
@@ -1232,7 +1233,7 @@ describe("Bus", () => {
 
       yield* bus.replay({
         id: Event.ID.create(),
-        created: DateTime.makeUnsafe(0),
+        created: 0,
         type: Bus.versionedType(DurableMessage.type, 1),
         seq: 0,
         aggregateID,

packages/core/test/database-migration.test.ts

@@ -13,6 +13,7 @@ import { tmpdir } from "./fixture/tmpdir"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import legacyCredentialsMigration from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
 import worktreeMigration from "@opencode-ai/core/database/migration/20260812213948_worktree"
+import sessionViewedStateMigration from "@opencode-ai/core/database/migration/20260815182818_session_viewed_state"
 import { Global } from "@opencode-ai/util/global"
 
 const run = <A, E>(
@@ -73,6 +74,27 @@ describe("DatabaseMigration", () => {
     )
   })
 
+  test("adds nullable attention state to existing sessions", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run(sql`CREATE TABLE session_v2 (id text PRIMARY KEY, title text)`)
+        yield* db.run(sql`INSERT INTO session_v2 (id, title) VALUES ('ses_existing', 'Existing')`)
+
+        yield* DatabaseMigration.applyOnly(db, [sessionViewedStateMigration])
+        yield* DatabaseMigration.applyOnly(db, [sessionViewedStateMigration])
+
+        expect(yield* db.get(sql`SELECT id, title, time_idle, time_viewed FROM session_v2`)).toEqual({
+          id: "ses_existing",
+          title: "Existing",
+          time_idle: null,
+          time_viewed: null,
+        })
+        expect(yield* db.get(sql`SELECT count(*) AS count FROM migration`)).toEqual({ count: 1 })
+      }),
+    )
+  })
+
   test("rejects a non-empty database without a session table", async () => {
     await expect(
       run(

packages/core/test/mcp.test.ts

@@ -1002,7 +1002,7 @@ test("reconciles only changed MCP server config", async () => {
         const publishUpdate = () =>
           PubSub.publish(updates, {
             id: ID.create(),
-            created: DateTime.makeUnsafe(0),
+            created: 0,
             type: Event.Updated.type,
             data: {},
           } satisfies Payload<typeof Event.Updated>)

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

@@ -599,7 +599,7 @@ describe("Session.create", () => {
         .all()
         .pipe(Effect.orDie)).map((event) => ({
         id: event.id,
-        created: DateTime.makeUnsafe(event.created),
+        created: event.created,
         aggregateID: event.aggregate_id,
         seq: event.seq,
         type: event.type,
@@ -840,7 +840,15 @@ describe("SessionTransfer", () => {
 
       const imported = yield* transfer.import({
         data: {
-          info: { ...template, id: sessionID },
+          info: {
+            ...template,
+            id: sessionID,
+            time: {
+              ...template.time,
+              idle: DateTime.makeUnsafe(200),
+              viewed: DateTime.makeUnsafe(150),
+            },
+          },
           messages: [
             {
               id: sourceMessageID,
@@ -863,13 +871,18 @@ describe("SessionTransfer", () => {
       const messages = yield* session.messages({ sessionID, order: "asc" })
 
       expect(imported).toMatchObject({ id: sessionID, title: "Exported", location })
+      expect(imported.time).toMatchObject({ idle: DateTime.makeUnsafe(200), viewed: DateTime.makeUnsafe(150) })
       expect(messages).toMatchObject([
         { id: sourceMessageID, type: "user", text: "Imported message" },
         { id: errorMessageID, type: "compaction", error: { type: "test_error", message: "Original error" } },
       ])
       expect(yield* Bus.latestSequence(db, sessionID)).toBe(2)
-      expect((yield* transfer.export({ sessionID })).messages).toEqual(messages)
-      expect((yield* transfer.export({ sessionID, sanitize: true })).messages).toMatchObject([
+      const exported = yield* transfer.export({ sessionID })
+      expect(exported.info.time).toMatchObject({ idle: DateTime.makeUnsafe(200), viewed: DateTime.makeUnsafe(150) })
+      expect(exported.messages).toEqual(messages)
+      const sanitized = yield* transfer.export({ sessionID, sanitize: true })
+      expect(sanitized.info.time).toMatchObject({ idle: DateTime.makeUnsafe(200), viewed: DateTime.makeUnsafe(150) })
+      expect(sanitized.messages).toMatchObject([
         { id: sourceMessageID, text: `[redacted:text:${sourceMessageID}]` },
         { id: errorMessageID, error: { type: "test_error", message: "Original error" } },
       ])

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

@@ -14,10 +14,8 @@ import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionRestart } from "@opencode-ai/core/session/execution/restart"
 import { UserInterruptedError } from "@opencode-ai/core/session/error"
 import { SessionEvent } from "@opencode-ai/core/session/event"
-import { SessionInbox } from "@opencode-ai/core/session/inbox"
-import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionRunner } from "@opencode-ai/core/session/runner/index"
-import { SessionInboxTable, SessionTable } from "@opencode-ai/core/session/sql"
+import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { Context, Deferred, Effect, Exit, Fiber, Layer, LayerMap, Scope } from "effect"
 import { eq } from "drizzle-orm"
@@ -292,113 +290,6 @@ describe("SessionExecution lifecycle", () => {
   )
 })
 
-describe("SessionExecution interrupt continuation", () => {
-  it.effect("resumes only steering input after an interrupt with continue", () =>
-    Effect.gen(function* () {
-      const database = yield* Database.Service
-      const sessionID = Session.ID.make("ses_continue_steer")
-      yield* seedSessions(database, [sessionID])
-      yield* seedInbox(database, sessionID, ["steer", "queue"])
-
-      const draining = yield* Deferred.make<void>()
-      const drains: Array<{ force: boolean; promotable?: SessionInbox.Promotable }> = []
-      const scope = yield* Scope.make()
-      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
-      const context = yield* buildExecution(scope, (input) =>
-        Effect.suspend(() => {
-          drains.push({ force: input.force, promotable: input.promotable })
-          if (drains.length > 1) return Effect.void
-          return Deferred.succeed(draining, undefined).pipe(Effect.andThen(Effect.never))
-        }),
-      )
-      const execution = Context.get(context, SessionExecution.Service)
-      yield* execution.resume(sessionID).pipe(Effect.forkScoped)
-      yield* Deferred.await(draining)
-
-      yield* execution.interrupt(sessionID, { continue: true })
-      yield* execution.awaitIdle(sessionID)
-
-      // The successor drain is steer-scoped: queued next-turn work stays parked.
-      expect(drains).toEqual([
-        { force: true, promotable: "input" },
-        { force: false, promotable: "steer" },
-      ])
-    }),
-  )
-
-  it.effect("stays parked after an interrupt with continue when only queued work remains", () =>
-    Effect.gen(function* () {
-      const database = yield* Database.Service
-      const sessionID = Session.ID.make("ses_continue_parked")
-      yield* seedSessions(database, [sessionID])
-      yield* seedInbox(database, sessionID, ["queue"])
-
-      const draining = yield* Deferred.make<void>()
-      const drains: Array<SessionInbox.Promotable | undefined> = []
-      const scope = yield* Scope.make()
-      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
-      const context = yield* buildExecution(scope, (input) =>
-        Effect.suspend(() => {
-          drains.push(input.promotable)
-          return Deferred.succeed(draining, undefined).pipe(Effect.andThen(Effect.never))
-        }),
-      )
-      const execution = Context.get(context, SessionExecution.Service)
-      yield* execution.resume(sessionID).pipe(Effect.forkScoped)
-      yield* Deferred.await(draining)
-
-      yield* execution.interrupt(sessionID, { continue: true })
-      yield* execution.awaitIdle(sessionID)
-
-      expect(drains).toEqual(["input"])
-      expect(yield* execution.active).toEqual(new Set())
-    }),
-  )
-
-  it.effect("an idle interrupt with continue resumes pending steers", () =>
-    Effect.gen(function* () {
-      const database = yield* Database.Service
-      const sessionID = Session.ID.make("ses_continue_idle")
-      yield* seedSessions(database, [sessionID])
-      yield* seedInbox(database, sessionID, ["steer"])
-
-      const drains: Array<{ force: boolean; promotable?: SessionInbox.Promotable }> = []
-      const scope = yield* Scope.make()
-      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
-      const context = yield* buildExecution(scope, (input) =>
-        Effect.sync(() => void drains.push({ force: input.force, promotable: input.promotable })),
-      )
-      const execution = Context.get(context, SessionExecution.Service)
-
-      yield* execution.interrupt(sessionID, { continue: true })
-      yield* execution.awaitIdle(sessionID)
-
-      expect(drains).toEqual([{ force: false, promotable: "steer" }])
-    }),
-  )
-})
-
-function seedInbox(
-  database: Database.Service["Service"],
-  sessionID: Session.ID,
-  deliveries: ReadonlyArray<SessionInbox.Delivery>,
-) {
-  return database.db
-    .insert(SessionInboxTable)
-    .values(
-      deliveries.map((delivery, index) => ({
-        id: SessionMessage.ID.create(),
-        session_id: sessionID,
-        type: "compaction" as const,
-        payload: {},
-        delivery,
-        enqueued_seq: index + 1,
-      })),
-    )
-    .run()
-    .pipe(Effect.orDie)
-}
-
 function seedSessions(
   database: Database.Service["Service"],
   sessionIDs: ReadonlyArray<Session.ID>,

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

@@ -760,7 +760,7 @@ describe("Session.prompt", () => {
       yield* Effect.forEach(
         recorded.map((event) => ({
           id: event.id,
-          created: DateTime.makeUnsafe(event.created),
+          created: event.created,
           aggregateID: event.aggregate_id,
           seq: event.seq,
           type: event.type,

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

@@ -1,6 +1,5 @@
 import { describe, expect } from "bun:test"
 import { Cause, Deferred, Effect, Exit, Fiber, Layer } from "effect"
-import { SessionInbox } from "@opencode-ai/core/session/inbox"
 import { SessionRunCoordinator } from "@opencode-ai/core/session/run-coordinator"
 import { testEffect } from "./lib/effect"
 
@@ -270,24 +269,31 @@ describe("SessionRunCoordinator", () => {
     ),
   )
 
-  it.effect("a settlement-window wake starts a fresh execution with its own scope", () =>
+  it.effect("replaces a settlement-window wake with a steer continuation", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const settling = yield* Deferred.make<void>()
         const release = yield* Deferred.make<void>()
-        const scopes: SessionInbox.Promotable[] = []
+        const requests: SessionRunCoordinator.Request[] = []
         const coordinator = yield* SessionRunCoordinator.make({
-          drain: (_key, _force, scope) => Effect.sync(() => scopes.push(scope)),
+          drain: (_key, _force, request) => Effect.sync(() => requests.push(request)),
           settled: () => Deferred.succeed(settling, undefined).pipe(Effect.andThen(Deferred.await(release))),
         })
 
-        yield* coordinator.wake("session", "steer")
+        yield* coordinator.wake("session", "input")
         yield* Deferred.await(settling)
         yield* coordinator.wake("session", "input")
+        const interrupted = yield* coordinator
+          .interrupt("session", undefined, {
+            continue: { request: "steer", when: Effect.succeed(true) },
+          })
+          .pipe(Effect.forkChild)
+        yield* Effect.yieldNow
         yield* Deferred.succeed(release, undefined)
+        yield* Fiber.join(interrupted)
         yield* coordinator.awaitIdle("session")
 
-        expect(scopes).toEqual(["steer", "input"])
+        expect(requests).toEqual(["input", "steer"])
       }),
     ),
   )
@@ -365,17 +371,17 @@ describe("SessionRunCoordinator", () => {
     ),
   )
 
-  it.effect("coalesces drain scopes with input taking precedence", () =>
+  it.effect("coalesces drain requests with input taking precedence", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const firstStarted = yield* Deferred.make<void>()
         const release = yield* Deferred.make<void>()
-        const scopes: SessionInbox.Promotable[] = []
+        const requests: SessionRunCoordinator.Request[] = []
         const coordinator = yield* SessionRunCoordinator.make({
-          drain: (_key, _force, scope) =>
+          drain: (_key, _force, request) =>
             Effect.gen(function* () {
-              scopes.push(scope)
-              if (scopes.length !== 1) return
+              requests.push(request)
+              if (requests.length !== 1) return
               yield* Deferred.succeed(firstStarted, undefined)
               yield* Deferred.await(release)
             }),
@@ -388,22 +394,22 @@ describe("SessionRunCoordinator", () => {
         yield* Deferred.succeed(release, undefined)
         yield* coordinator.awaitIdle("session")
 
-        expect(scopes).toEqual(["steer", "input"])
+        expect(requests).toEqual(["steer", "input"])
       }),
     ),
   )
 
-  it.effect("does not carry a completed input scope into a steer drain", () =>
+  it.effect("does not carry a completed input request into a steer drain", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const firstStarted = yield* Deferred.make<void>()
         const release = yield* Deferred.make<void>()
-        const scopes: SessionInbox.Promotable[] = []
+        const requests: SessionRunCoordinator.Request[] = []
         const coordinator = yield* SessionRunCoordinator.make({
-          drain: (_key, _force, scope) =>
+          drain: (_key, _force, request) =>
             Effect.gen(function* () {
-              scopes.push(scope)
-              if (scopes.length !== 1) return
+              requests.push(request)
+              if (requests.length !== 1) return
               yield* Deferred.succeed(firstStarted, undefined)
               yield* Deferred.await(release)
             }),
@@ -415,7 +421,7 @@ describe("SessionRunCoordinator", () => {
         yield* Deferred.succeed(release, undefined)
         yield* coordinator.awaitIdle("session")
 
-        expect(scopes).toEqual(["input", "steer"])
+        expect(requests).toEqual(["input", "steer"])
       }),
     ),
   )
@@ -425,12 +431,12 @@ describe("SessionRunCoordinator", () => {
       Effect.gen(function* () {
         const firstStarted = yield* Deferred.make<void>()
         const release = yield* Deferred.make<void>()
-        const scopes: SessionInbox.Promotable[] = []
+        const requests: SessionRunCoordinator.Request[] = []
         const coordinator = yield* SessionRunCoordinator.make({
-          drain: (_key, _force, scope) =>
+          drain: (_key, _force, request) =>
             Effect.gen(function* () {
-              scopes.push(scope)
-              if (scopes.length !== 1) return
+              requests.push(request)
+              if (requests.length !== 1) return
               yield* Deferred.succeed(firstStarted, undefined)
               yield* Deferred.await(release)
             }),
@@ -443,23 +449,61 @@ describe("SessionRunCoordinator", () => {
         yield* Deferred.succeed(release, undefined)
         yield* coordinator.awaitIdle("session")
 
-        expect(scopes).toEqual(["steer", "steer"])
+        expect(requests).toEqual(["steer", "steer"])
       }),
     ),
   )
 
-  it.effect("a cleanup-era wake starts a successor with its own scope", () =>
+  it.effect("coalesces overlapping interrupt continuations into one steer successor", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const firstStarted = yield* Deferred.make<void>()
         const cleanupStarted = yield* Deferred.make<void>()
         const cleanupGate = yield* Deferred.make<void>()
-        const scopes: SessionInbox.Promotable[] = []
+        const requests: SessionRunCoordinator.Request[] = []
         const coordinator = yield* SessionRunCoordinator.make({
-          drain: (_key, _force, scope) =>
+          drain: (_key, _force, request) =>
             Effect.gen(function* () {
-              scopes.push(scope)
-              if (scopes.length !== 1) return
+              requests.push(request)
+              if (requests.length !== 1) return
+              yield* Deferred.succeed(firstStarted, undefined)
+              yield* Effect.never.pipe(
+                Effect.onInterrupt(() =>
+                  Deferred.succeed(cleanupStarted, undefined).pipe(Effect.andThen(Deferred.await(cleanupGate))),
+                ),
+              )
+            }),
+        })
+        const continuation = { continue: { request: "steer" as const, when: Effect.succeed(false) } }
+
+        yield* coordinator.wake("session")
+        yield* Deferred.await(firstStarted)
+        const first = yield* coordinator.interrupt("session", undefined, continuation).pipe(Effect.forkChild)
+        yield* Deferred.await(cleanupStarted)
+        const second = yield* coordinator.interrupt("session", undefined, continuation).pipe(Effect.forkChild)
+        yield* Effect.yieldNow
+        yield* coordinator.wake("session", "input")
+        yield* Deferred.succeed(cleanupGate, undefined)
+        yield* Effect.all([Fiber.join(first), Fiber.join(second)])
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["input", "steer"])
+      }),
+    ),
+  )
+
+  it.effect("a continuing interrupt replaces a cleanup-era input wake", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const cleanupStarted = yield* Deferred.make<void>()
+        const cleanupGate = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) =>
+            Effect.gen(function* () {
+              requests.push(request)
+              if (requests.length !== 1) return
               yield* Deferred.succeed(firstStarted, undefined)
               yield* Effect.never.pipe(
                 Effect.onInterrupt(() =>
@@ -471,16 +515,45 @@ describe("SessionRunCoordinator", () => {
 
         yield* coordinator.wake("session", "input")
         yield* Deferred.await(firstStarted)
-        const interrupt = yield* coordinator.interrupt("session").pipe(Effect.forkChild)
+        const plain = yield* coordinator.interrupt("session").pipe(Effect.forkChild)
         yield* Deferred.await(cleanupStarted)
-        // A new admission during cancellation restarts normally: interruption only
-        // claims the wakes recorded before it.
         yield* coordinator.wake("session", "input")
+        const continuing = yield* coordinator
+          .interrupt("session", undefined, {
+            continue: { request: "steer", when: Effect.succeed(false) },
+          })
+          .pipe(Effect.forkChild)
+        yield* Effect.yieldNow
         yield* Deferred.succeed(cleanupGate, undefined)
-        yield* Fiber.join(interrupt)
+        yield* Effect.all([Fiber.join(plain), Fiber.join(continuing)])
         yield* coordinator.awaitIdle("session")
 
-        expect(scopes).toEqual(["input", "input"])
+        expect(requests).toEqual(["input", "steer"])
+      }),
+    ),
+  )
+
+  it.effect("does not start a conditional continuation without eligible work", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const started = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) =>
+            Effect.sync(() => requests.push(request)).pipe(
+              Effect.andThen(Deferred.succeed(started, undefined)),
+              Effect.andThen(Effect.never),
+            ),
+        })
+
+        yield* coordinator.wake("session")
+        yield* Deferred.await(started)
+        yield* coordinator.interrupt("session", undefined, {
+          continue: { request: "steer", when: Effect.succeed(false) },
+        })
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["input"])
       }),
     ),
   )

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

@@ -13,6 +13,8 @@ import { Provider } from "@opencode-ai/core/provider"
 import { RelativePath } from "@opencode-ai/core/schema"
 import { Snapshot } from "@opencode-ai/core/snapshot"
 import { createLLMEventPublisher } from "@opencode-ai/core/session/runner/publish-llm-event"
+import { it } from "./lib/effect"
+import { TestClock } from "effect/testing"
 
 const sessionID = Session.ID.make("ses_tool_event_test")
 const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB"
@@ -201,6 +203,82 @@ test("reasoning state from start, empty delta, and end is merged", async () => {
   })
 })
 
+it.effect("batches text deltas and flushes pending text before the terminal event", () =>
+  Effect.gen(function* () {
+    const { published, publisher } = capture()
+    yield* Effect.forEach(
+      [
+        LLMEvent.textStart({ id: "text" }),
+        LLMEvent.textDelta({ id: "text", text: "one" }),
+        LLMEvent.textDelta({ id: "text", text: " two" }),
+        LLMEvent.textDelta({ id: "text", text: " three" }),
+      ],
+      publisher.publish,
+      { discard: true },
+    )
+
+    expect(published.filter((event) => event.type === "session.text.delta")).toHaveLength(0)
+    yield* TestClock.adjust("99 millis")
+    expect(published.filter((event) => event.type === "session.text.delta")).toHaveLength(0)
+    yield* TestClock.adjust("1 millis")
+    yield* publisher.publish(LLMEvent.textDelta({ id: "text", text: " four" }))
+    expect(published.filter((event) => event.type === "session.text.delta").map((event) => event.data)).toMatchObject([
+      { delta: "one two three four" },
+    ])
+
+    yield* publisher.publish(LLMEvent.textDelta({ id: "text", text: " five" }))
+    yield* publisher.publish(LLMEvent.textEnd({ id: "text" }))
+    expect(published.slice(-2).map((event) => event.type)).toEqual(["session.text.delta", "session.text.ended.1"])
+    expect(published.at(-2)?.data).toMatchObject({ delta: " five" })
+  }),
+)
+
+it.effect("batches reasoning deltas and flushes pending reasoning before the terminal event", () =>
+  Effect.gen(function* () {
+    const { published, publisher } = capture()
+    yield* Effect.forEach(
+      [
+        LLMEvent.reasoningStart({ id: "reasoning" }),
+        LLMEvent.reasoningDelta({ id: "reasoning", text: "one" }),
+        LLMEvent.reasoningDelta({ id: "reasoning", text: " two" }),
+        LLMEvent.reasoningDelta({ id: "reasoning", text: " three" }),
+        LLMEvent.reasoningEnd({ id: "reasoning" }),
+      ],
+      publisher.publish,
+      { discard: true },
+    )
+
+    expect(
+      published.filter((event) => event.type === "session.reasoning.delta").map((event) => event.data),
+    ).toMatchObject([{ delta: "one two three" }])
+    expect(published.slice(-2).map((event) => event.type)).toEqual([
+      "session.reasoning.delta",
+      "session.reasoning.ended.1",
+    ])
+  }),
+)
+
+test("tool input deltas are accumulated without being published", async () => {
+  const { published, publisher } = capture()
+  await Effect.runPromise(
+    Effect.forEach(
+      [
+        LLMEvent.toolInputStart({ id: "call", name: "read" }),
+        LLMEvent.toolInputDelta({ id: "call", name: "read", text: '{"path":' }),
+        LLMEvent.toolInputDelta({ id: "call", name: "read", text: '"file.txt"}' }),
+        LLMEvent.toolInputEnd({ id: "call", name: "read" }),
+      ],
+      publisher.publish,
+      { discard: true },
+    ),
+  )
+
+  expect(published.some((event) => event.type === "session.tool.input.delta")).toBe(false)
+  expect(published.find((event) => event.type === "session.tool.input.ended.1")?.data).toMatchObject({
+    text: '{"path":"file.txt"}',
+  })
+})
+
 test("provider-executed tool metadata is flattened using the route key", async () => {
   const { published, publisher } = capture("openai")
   await Effect.runPromise(

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

@@ -75,7 +75,7 @@ import { SessionSystemPrompt } from "@opencode-ai/core/session/system-prompt"
 import { ID } from "@opencode-ai/core/model"
 import { Location } from "@opencode-ai/core/location"
 import { Provider } from "@opencode-ai/core/provider"
-import { Cause, DateTime, Deferred, Effect, Exit, Fiber, Layer, Schema, Scope, Stream } from "effect"
+import { Cause, Deferred, Effect, Exit, Fiber, Layer, Schema, Scope, Stream } from "effect"
 import { TestClock } from "effect/testing"
 import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { asc, desc, eq } from "drizzle-orm"
@@ -672,7 +672,7 @@ const replaySessionProjection = (id: Session.ID) =>
     yield* Effect.forEach(
       recorded.map((event) => ({
         id: event.id,
-        created: DateTime.makeUnsafe(event.created),
+        created: event.created,
         aggregateID: event.aggregate_id,
         seq: event.seq,
         type: event.type,
@@ -686,7 +686,7 @@ const replaySessionProjection = (id: Session.ID) =>
 type FragmentKind = "text" | "reasoning" | "tool input"
 
 type FragmentFixture = {
-  readonly delta: Event.Definition
+  readonly delta?: Event.Definition
   readonly completeEvents: LLMEvent[]
   readonly partialEvents: LLMEvent[]
   readonly expectedAssistant: unknown
@@ -748,7 +748,6 @@ const fragmentFixture = (kind: FragmentKind, id: string, chunks: readonly string
       ]
       const expectedContent = { type: "tool", id, state: { status: "streaming", input: text } }
       return {
-        delta: SessionEvent.Tool.Input.Delta,
         partialEvents,
         completeEvents: [...partialEvents, LLMEvent.toolInputEnd({ id, name: "echo" })],
         expectedAssistant: { type: "assistant", content: [expectedContent] },
@@ -767,20 +766,37 @@ const verifyEphemeralDeltas = (kind: FragmentKind) =>
     const expectedContext = [{ type: "user", text: prompt }, fixture.expectedAssistant]
     yield* admit(session, prompt)
     const bus = yield* Bus.Service
-    const live = yield* bus.subscribe(fixture.delta).pipe(Stream.take(32), Stream.runCollect, Effect.forkScoped)
+    const live = fixture.delta
+      ? yield* bus.subscribe(fixture.delta).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+      : undefined
     yield* Effect.yieldNow
     yield* TestLLM.push(fixture.completeEvents)
 
     yield* session.resume(sessionID)
 
     const { db } = yield* Database.Service
-    const deltas = yield* db
-      .select({ type: EventTable.type })
-      .from(EventTable)
-      .where(eq(EventTable.type, Bus.versionedType(fixture.delta.type, 1)))
-      .all()
-      .pipe(Effect.orDie)
-    expect(Array.from(yield* Fiber.join(live))).toHaveLength(32)
+    const deltas = fixture.delta
+      ? yield* db
+          .select({ type: EventTable.type })
+          .from(EventTable)
+          .where(eq(EventTable.type, Bus.versionedType(fixture.delta.type, 1)))
+          .all()
+          .pipe(Effect.orDie)
+      : []
+    if (live) {
+      const streamed = Array.from(yield* Fiber.join(live))
+      expect(streamed).toHaveLength(1)
+      expect(
+        streamed
+          .map((event) => {
+            if (!event.data || typeof event.data !== "object" || !("delta" in event.data))
+              throw new Error("Expected delta event")
+            if (typeof event.data.delta !== "string") throw new Error("Expected string delta")
+            return event.data.delta
+          })
+          .join(""),
+      ).toBe(chunks.join(""))
+    }
     expect(deltas).toHaveLength(0)
     expect(yield* session.context(sessionID)).toMatchObject(expectedContext)
 
@@ -1463,7 +1479,7 @@ describe("SessionRunnerLLM", () => {
       yield* Effect.forEach(
         recorded.map((event) => ({
           id: event.id,
-          created: DateTime.makeUnsafe(event.created),
+          created: event.created,
           aggregateID: event.aggregate_id,
           seq: event.seq,
           type: event.type,
@@ -5219,8 +5235,11 @@ describe("SessionRunnerLLM", () => {
   )
 
   for (const kind of fragmentKinds) {
-    it.effect(`broadcasts provider ${kind} deltas without storing projection rewrites`, () =>
-      verifyEphemeralDeltas(kind),
+    it.effect(
+      kind === "tool input"
+        ? "does not broadcast provider tool input deltas"
+        : `batches provider ${kind} deltas without storing projection rewrites`,
+      () => verifyEphemeralDeltas(kind),
     )
 
     it.effect(`durably closes partial ${kind} when the provider stream fails`, () => verifyPartialFlushOnFailure(kind))

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

@@ -0,0 +1,174 @@
+import { describe, expect } from "bun:test"
+import path from "path"
+import { Bus } from "@opencode-ai/core/bus"
+import { Database } from "@opencode-ai/core/database/database"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { EventTable } from "@opencode-ai/core/event/sql"
+import { Location } from "@opencode-ai/core/location"
+import { Project } from "@opencode-ai/core/project"
+import { ProjectTable } from "@opencode-ai/core/project/sql"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { Session } from "@opencode-ai/core/session"
+import { SessionEvent } from "@opencode-ai/core/session/event"
+import { SessionExecution } from "@opencode-ai/core/session/execution"
+import { SessionProjector } from "@opencode-ai/core/session/projector"
+import { SessionTable } from "@opencode-ai/core/session/sql"
+import { SessionStore } from "@opencode-ai/core/session/store"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { DateTime, Effect, Layer } from "effect"
+import { asc, eq } from "drizzle-orm"
+import { tmpdir } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+import { globalProjectLayer } from "./lib/project"
+
+const it = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
+    [
+      [Bus.node, Bus.configured({ persist: true })],
+      [Project.node, globalProjectLayer],
+      [SessionExecution.node, SessionExecution.noopLayer],
+    ],
+  ),
+)
+const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
+
+describe("Session.view", () => {
+  it.effect("copies the latest idle time without changing session recency", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      const created = yield* session.create({ location })
+
+      expect(created.time.idle).toBeUndefined()
+      expect(created.time.viewed).toBeUndefined()
+
+      yield* session.view({ sessionID: created.id })
+      expect((yield* session.get(created.id)).time.viewed).toBeUndefined()
+
+      yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: created.id })
+      const idle = yield* session.get(created.id)
+      expect(idle.time.idle).toBeDefined()
+      expect(idle.time.viewed).toBeUndefined()
+      expect(idle.time.updated).toEqual(created.time.updated)
+
+      yield* session.view({ sessionID: created.id })
+      const viewed = yield* session.get(created.id)
+      if (!viewed.time.idle || !viewed.time.viewed) return yield* Effect.die(new Error("Expected attention times"))
+      expect(viewed.time.viewed).toEqual(viewed.time.idle)
+      expect(viewed.time.updated).toEqual(created.time.updated)
+      expect(
+        yield* db
+          .select({ idle: SessionTable.time_idle, viewed: SessionTable.time_viewed })
+          .from(SessionTable)
+          .where(eq(SessionTable.id, created.id))
+          .get(),
+      ).toEqual({
+        idle: DateTime.toEpochMillis(viewed.time.idle),
+        viewed: DateTime.toEpochMillis(viewed.time.viewed),
+      })
+      expect((yield* session.list()).data.find((item) => item.id === created.id)?.time).toEqual(viewed.time)
+
+      yield* session.view({ sessionID: created.id })
+      expect((yield* session.get(created.id)).time).toEqual(viewed.time)
+
+      yield* bus.publish(SessionEvent.Execution.Failed, {
+        sessionID: created.id,
+        error: { type: "unknown", message: "failed" },
+      })
+      const unread = yield* session.get(created.id)
+      if (!unread.time.idle || !unread.time.viewed) return yield* Effect.die(new Error("Expected attention times"))
+      expect(DateTime.toEpochMillis(unread.time.idle)).toBeGreaterThan(DateTime.toEpochMillis(unread.time.viewed))
+
+      yield* session.view({ sessionID: created.id })
+      expect((yield* session.get(created.id)).time.viewed).toEqual(unread.time.idle)
+
+      yield* bus.publish(SessionEvent.Execution.Interrupted, { sessionID: created.id, reason: "shutdown" })
+      expect((yield* session.get(created.id)).time.idle).toEqual(unread.time.idle)
+
+      yield* bus.publish(SessionEvent.Execution.Interrupted, { sessionID: created.id, reason: "user" })
+      const interrupted = yield* session.get(created.id)
+      if (!interrupted.time.idle || !interrupted.time.viewed)
+        return yield* Effect.die(new Error("Expected attention times"))
+      expect(DateTime.toEpochMillis(interrupted.time.idle)).toBeGreaterThan(
+        DateTime.toEpochMillis(interrupted.time.viewed),
+      )
+      expect(
+        (yield* db
+          .select({ type: EventTable.type })
+          .from(EventTable)
+          .where(eq(EventTable.aggregate_id, created.id))
+          .all()).filter((event) => event.type === "session.viewed.1"),
+      ).toHaveLength(2)
+    }),
+  )
+
+  it.effect("rejects an unknown session", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const sessionID = Session.ID.make("ses_missing_view")
+      expect(yield* Effect.flip(session.view({ sessionID }))).toEqual(new Session.NotFoundError({ sessionID }))
+    }),
+  )
+
+  it.effect("replays viewed state into a fresh database", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const sourceDb = (yield* Database.Service).db
+      const created = yield* session.create({ id: Session.ID.make("ses_view_replay"), location })
+      yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: created.id })
+      yield* session.view({ sessionID: created.id })
+      yield* bus.publish(SessionEvent.Execution.Failed, {
+        sessionID: created.id,
+        error: { type: "unknown", message: "failed" },
+      })
+      const expected = yield* session.get(created.id)
+      if (!expected.time.idle || !expected.time.viewed) return yield* Effect.die(new Error("Expected attention times"))
+      const expectedIdle = DateTime.toEpochMillis(expected.time.idle)
+      const expectedViewed = DateTime.toEpochMillis(expected.time.viewed)
+      const serialized = (yield* sourceDb
+        .select()
+        .from(EventTable)
+        .where(eq(EventTable.aggregate_id, created.id))
+        .orderBy(asc(EventTable.seq))
+        .all()
+        .pipe(Effect.orDie)).map((event) => ({
+        id: event.id,
+        created: event.created,
+        aggregateID: event.aggregate_id,
+        seq: event.seq,
+        type: event.type,
+        data: event.data,
+      }))
+      const tmp = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir()),
+        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+      )
+      const targetLayer = AppNodeBuilder.build(
+        LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node]),
+        [
+          [Database.node, Database.configured({ path: path.join(tmp.path, "target.sqlite") })],
+          [Bus.node, Bus.configured({ persist: true })],
+        ],
+      )
+
+      yield* Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        const targetBus = yield* Bus.Service
+        const store = yield* SessionStore.Service
+        yield* db
+          .insert(ProjectTable)
+          .values({ id: Project.ID.global, worktree: location.directory, sandboxes: [] })
+          .run()
+          .pipe(Effect.orDie)
+        yield* Effect.forEach(serialized, (event) => targetBus.replay(event), { discard: true })
+
+        expect((yield* store.get(created.id))?.time).toEqual(expected.time)
+        expect(expected.time.updated).toEqual(created.time.updated)
+        expect(expectedIdle).toBeGreaterThan(expectedViewed)
+      }).pipe(Effect.provide(Layer.fresh(targetLayer)))
+    }),
+  )
+})

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

@@ -298,7 +298,7 @@ describe("SubagentTool", () => {
           })
           const child = yield* sessions.get(outputSessionID(settled.metadata))
           expect(settled.metadata).toEqual({ sessionID: child.id, status: "completed" })
-          expect(progress[0]?.metadata).toEqual({ sessionID: child.id, status: "running" })
+          expect(progress[0]).toEqual({ sessionID: child.id, status: "running" })
           expect(child).toMatchObject({
             parentID: parent.id,
             location: parent.location,

packages/core/test/v1-migration.test.ts

@@ -60,6 +60,8 @@ const session = (
   model: null,
   time_created: 1,
   time_updated: 2,
+  time_idle: null,
+  time_viewed: null,
   time_compacting: 3,
   time_archived: null,
   time_suspended: null,

packages/desktop/scripts/prebuild.ts

@@ -1,11 +1,12 @@
 #!/usr/bin/env bun
 import { $ } from "bun"
 
-import { downloadCliToResources, resolveChannel } from "./utils"
+import { copyBuiltCliToResources, downloadCliToResources, resolveChannel } from "./utils"
 
 const channel = resolveChannel()
 await $`bun ./scripts/copy-icons.ts ${channel}`
 await $`bun ./scripts/copy-metainfo.ts ${channel}`
 
 if (channel === "dev") await downloadCliToResources()
-if (channel === "beta") await downloadCliToResources("next")
+if (channel === "beta" && Bun.env.OPENCODE_CLI_DIST) await copyBuiltCliToResources(Bun.env.OPENCODE_CLI_DIST)
+if (channel === "beta" && !Bun.env.OPENCODE_CLI_DIST) await downloadCliToResources("beta")

packages/desktop/scripts/utils.ts

@@ -3,7 +3,7 @@ import { chmod, copyFile, mkdtemp, rm } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 
-const CLI_VERSION = "0.0.0-next-16365"
+const CLI_VERSION = "dev"
 
 export type Channel = "dev" | "beta" | "prod"
 
@@ -74,18 +74,28 @@ export async function downloadCliToResources(version = CLI_VERSION, dest = windo
   const directory = await mkdtemp(join(tmpdir(), "opencode-cli-"))
   try {
     await $`bun install --no-save --cwd ${directory} ${`${cli.package}@${version}`} ${`--os=${cli.os}`} ${`--cpu=${cli.cpu}`}`
-    await copyFile(
+    await copyCliToResources(
       join(directory, "node_modules", cli.package, "bin", cli.os === "win32" ? "opencode2.exe" : "opencode2"),
       dest,
     )
   } finally {
     await rm(directory, { recursive: true, force: true })
   }
-  await prepareCli(dest)
 
   console.log(`Copied ${cli.package}@${version} to ${dest}`)
 }
 
+export async function copyBuiltCliToResources(root: string, dest = windowsify("resources/opencode-cli")) {
+  const cli = getCurrentCli()
+  const directory = cli.package.replace("@opencode-ai/", "")
+  await copyCliToResources(join(root, directory, "bin", cli.os === "win32" ? "opencode2.exe" : "opencode2"), dest)
+}
+
+async function copyCliToResources(source: string, dest: string) {
+  await copyFile(source, dest)
+  await prepareCli(dest)
+}
+
 async function prepareCli(dest: string) {
   if (process.platform !== "win32") await chmod(dest, 0o755)
   if (process.platform === "win32" && process.env.GITHUB_ACTIONS === "true") {

packages/desktop/src/main/wsl/servers.test.ts

@@ -27,7 +27,7 @@ test("installs and verifies the bundled CLI version", async () => {
 
   await controller.installOpencode("Debian")
 
-  expect(installs).toEqual([["Debian", "0.0.0-next-16365"]])
+  expect(installs).toEqual([["Debian", "0.0.0-dev-16365"]])
   expect(controller.getState().opencodeChecks.Debian?.matchesDesktop).toBe(true)
 })
 
@@ -37,12 +37,12 @@ test("rejects a WSL CLI version that differs from the bundled version", async ()
     testControllerOptions({
       installCli: async () => undefined,
       resolveCli: async () => "/home/me/.opencode/bin/opencode2",
-      readCliVersion: async () => "0.0.0-next-older",
+      readCliVersion: async () => "0.0.0-dev-older",
     }),
   )
 
   await expect(controller.installOpencode("Debian")).rejects.toThrow(
-    "OpenCode update finished but Debian still reports 0.0.0-next-older; expected 0.0.0-next-16365",
+    "OpenCode update finished but Debian still reports 0.0.0-dev-older; expected 0.0.0-dev-16365",
   )
 })
 
@@ -147,7 +147,7 @@ async function waitFor(check: () => boolean) {
 
 function testControllerOptions(overrides: Partial<ControllerOptions> = {}): ControllerOptions {
   return {
-    cli: { version: "0.0.0-next-16365" },
+    cli: { version: "0.0.0-dev-16365" },
     spawnSidecar: async () => ({
       stop: async () => undefined,
       onExit: () => undefined,
@@ -159,7 +159,7 @@ function testControllerOptions(overrides: Partial<ControllerOptions> = {}): Cont
     writeServers: (servers: WslServerConfig[]) => {
       persistedServers = servers
     },
-    readCliVersion: async () => "0.0.0-next-16365",
+    readCliVersion: async () => "0.0.0-dev-16365",
     resolveCli: async () => "/home/me/.opencode/bin/opencode2",
     ...overrides,
   }

packages/protocol/openapi.json

@@ -4127,6 +4127,65 @@
         "summary": "Get session message"
       }
     },
+    "/api/session/{sessionID}/view": {
+      "post": {
+        "tags": ["session"],
+        "operationId": "v2.session.view",
+        "parameters": [
+          {
+            "name": "sessionID",
+            "in": "path",
+            "schema": {
+              "type": "string",
+              "allOf": [
+                {
+                  "pattern": "^ses"
+                }
+              ]
+            },
+            "required": true
+          }
+        ],
+        "security": [],
+        "responses": {
+          "204": {
+            "description": "<No Content>"
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestError"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedError"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SessionNotFoundError"
+                }
+              }
+            }
+          }
+        },
+        "description": "Mark the latest recorded idle transition as viewed.",
+        "summary": "View session"
+      }
+    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],
@@ -12135,6 +12194,12 @@
               "updated": {
                 "type": "number"
               },
+              "idle": {
+                "type": "number"
+              },
+              "viewed": {
+                "type": "number"
+              },
               "archived": {
                 "type": "number"
               }
@@ -14276,6 +14341,71 @@
         "required": ["id", "created", "type", "durable", "data"],
         "additionalProperties": false
       },
+      "session.viewed": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "allOf": [
+              {
+                "pattern": "^evt_"
+              }
+            ]
+          },
+          "created": {
+            "type": "number"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "type": {
+            "type": "string",
+            "enum": ["session.viewed"]
+          },
+          "durable": {
+            "type": "object",
+            "properties": {
+              "aggregateID": {
+                "type": "string"
+              },
+              "seq": {
+                "type": "integer",
+                "allOf": [
+                  {
+                    "minimum": 0
+                  }
+                ]
+              },
+              "version": {
+                "type": "number",
+                "enum": [1]
+              }
+            },
+            "required": ["aggregateID", "seq", "version"],
+            "additionalProperties": false
+          },
+          "location": {
+            "$ref": "#/components/schemas/Location.Ref"
+          },
+          "data": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string",
+                "allOf": [
+                  {
+                    "pattern": "^ses"
+                  }
+                ]
+              }
+            },
+            "required": ["sessionID"],
+            "additionalProperties": false
+          }
+        },
+        "required": ["id", "created", "type", "durable", "data"],
+        "additionalProperties": false
+      },
       "session.deleted": {
         "type": "object",
         "properties": {
@@ -17296,6 +17426,9 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
           {
             "$ref": "#/components/schemas/session.deleted"
           },
@@ -22664,6 +22797,9 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
           {
             "$ref": "#/components/schemas/session.usage.updated"
           },

packages/protocol/package.json

@@ -33,6 +33,7 @@
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@typescript/native-preview": "catalog:",
+    "prettier": "3.6.2",
     "typescript": "catalog:"
   }
 }

packages/protocol/script/generate-openapi.ts

@@ -1,8 +1,9 @@
 import { OpenApi } from "effect/unstable/httpapi"
+import { format } from "prettier"
 import { fileURLToPath } from "url"
 import { ClientApi } from "../src/client.js"
 
-const document = JSON.stringify(OpenApi.fromApi(ClientApi), null, 2) + "\n"
+const document = await format(JSON.stringify(OpenApi.fromApi(ClientApi), null, 2), { parser: "json", printWidth: 120 })
 const target = fileURLToPath(new URL("../openapi.json", import.meta.url))
 
 if (process.argv.includes("--check")) {

packages/protocol/src/groups/session.ts

@@ -693,6 +693,19 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         }),
       ),
     )
+    .add(
+      HttpApiEndpoint.post("session.view", "/api/session/:sessionID/view", {
+        params: { sessionID: Session.ID },
+        success: HttpApiSchema.NoContent,
+        error: SessionNotFoundError,
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.session.view",
+          summary: "View session",
+          description: "Mark the latest recorded idle transition as viewed.",
+        }),
+      ),
+    )
     .annotateMerge(
       OpenApi.annotations({
         title: "session",

packages/protocol/test/event.test.ts

@@ -1,5 +1,25 @@
 import { expect, test } from "bun:test"
-import { isOpenCodeEvent } from "../src/groups/event.js"
+import { isOpenCodeEvent, type OpenCodeEvent, type OpenCodeEventEncoded } from "../src/groups/event.js"
+
+type JsonShape<Value> = Value extends string | number | boolean | null
+  ? Value
+  : Value extends undefined
+    ? never
+    : Value extends ReadonlyArray<infer Item>
+      ? ReadonlyArray<JsonShape<Item>>
+      : Value extends object
+        ? {
+            readonly [Key in keyof Value as undefined extends Value[Key] ? never : Key]: JsonShape<Value[Key]>
+          } & {
+            readonly [Key in keyof Value as undefined extends Value[Key] ? Key : never]?: JsonShape<
+              Exclude<Value[Key], undefined>
+            >
+          }
+        : Value
+
+// JSON.stringify omits undefined object properties, so normalize them before
+// requiring every runtime event shape to fit its encoded wire contract.
+const wireReady: [JsonShape<OpenCodeEvent>] extends [JsonShape<OpenCodeEventEncoded>] ? true : false = true
 
 test("classifies public events by type", () => {
   expect(isOpenCodeEvent({ type: "server.connected" })).toBe(true)
@@ -7,3 +27,7 @@ test("classifies public events by type", () => {
   expect(isOpenCodeEvent({ type: "mcp.resources.changed" })).toBe(true)
   expect(isOpenCodeEvent({ type: "mcp.tools.changed" })).toBe(false)
 })
+
+test("keeps public event runtime values within the encoded contract", () => {
+  expect(wireReady).toBe(true)
+})

packages/schema/src/event.ts

@@ -4,7 +4,7 @@ import { Schema, SchemaTransformation } from "effect"
 import { optional } from "./schema.js"
 import { ascending } from "./identifier.js"
 import { Location } from "./location.js"
-import { DateTimeUtcFromMillis, statics } from "./schema.js"
+import { statics } from "./schema.js"
 
 export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(
   Schema.brand("Event.ID"),
@@ -60,7 +60,7 @@ export type Data<D extends Definition> = Schema.Schema.Type<D["data"]>
 type PayloadBase<D extends Definition> = {
   readonly id: ID
   readonly type: D["type"]
-  readonly created: typeof DateTimeUtcFromMillis.Type
+  readonly created: number
   readonly data: Data<D>
   readonly location?: Location.Ref
   readonly metadata?: Record<string, unknown>
@@ -100,7 +100,7 @@ export function durable<
   })
   return Schema.Struct({
     id: ID,
-    created: DateTimeUtcFromMillis,
+    created: Schema.Finite,
     metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
     type: Schema.Literal(input.type),
     durable,
@@ -125,7 +125,7 @@ export function ephemeral<
   const data = Schema.Struct(input.schema)
   return Schema.Struct({
     id: ID,
-    created: DateTimeUtcFromMillis,
+    created: Schema.Finite,
     metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
     type: Schema.Literal(input.type),
     location: optional(Location.Ref),

packages/schema/src/session-event.ts

@@ -105,6 +105,13 @@ export const Renamed = Event.durable({
 })
 export type Renamed = typeof Renamed.Type
 
+export const Viewed = Event.durable({
+  type: "session.viewed",
+  ...options,
+  schema: Base,
+})
+export type Viewed = typeof Viewed.Type
+
 export const UsageRecorded = Event.durable({
   type: "session.usage.recorded",
   ...options,
@@ -580,6 +587,7 @@ export const Definitions = Event.inventory(
   ModelSelected,
   Moved,
   Renamed,
+  Viewed,
   UsageUpdated,
   Deleted,
   Forked,

packages/schema/src/session.ts

@@ -40,6 +40,8 @@ export const Info = Schema.Struct({
   time: Schema.Struct({
     created: DateTimeUtcFromMillis,
     updated: DateTimeUtcFromMillis,
+    idle: DateTimeUtcFromMillis.pipe(optional),
+    viewed: DateTimeUtcFromMillis.pipe(optional),
     archived: DateTimeUtcFromMillis.pipe(optional),
   }),
   title: Schema.String.pipe(optional),

packages/schema/test/contract-hygiene.test.ts

@@ -54,17 +54,29 @@ describe("contract hygiene", () => {
       }),
     ).toEqual({ text: "completed" })
 
+    const info = Session.Info.make({
+      id: Session.ID.make("ses_untitled"),
+      projectID: Project.ID.make("global"),
+      cost: Money.USD.zero,
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+      time: {
+        created: DateTime.makeUnsafe(0),
+        updated: DateTime.makeUnsafe(0),
+        idle: undefined,
+        viewed: undefined,
+      },
+      title: undefined,
+      location: { directory: AbsolutePath.make("/project") },
+    })
+    const encoded = Schema.encodeSync(Session.Info)(info)
+    expect(encoded).not.toHaveProperty("title")
+    expect(encoded.time).toEqual({ created: 0, updated: 0 })
     expect(
       Schema.encodeSync(Session.Info)({
-        id: Session.ID.make("ses_untitled"),
-        projectID: Project.ID.make("global"),
-        cost: Money.USD.zero,
-        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
-        title: undefined,
-        location: { directory: AbsolutePath.make("/project") },
-      }),
-    ).not.toHaveProperty("title")
+        ...info,
+        time: { ...info.time, idle: DateTime.makeUnsafe(2), viewed: DateTime.makeUnsafe(1) },
+      }).time,
+    ).toEqual({ created: 0, updated: 0, idle: 2, viewed: 1 })
   })
 
   test("session inbox items omit the internal enqueue sequence", () => {

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

@@ -83,6 +83,7 @@ describe("public event manifest", () => {
         "session.model.selected.1",
         "session.moved.1",
         "session.renamed.1",
+        "session.viewed.1",
         "session.usage.recorded.1",
         "session.forked.2",
         "session.inbox.delivered.1",

packages/script/src/index.ts

@@ -34,7 +34,7 @@ const IS_PREVIEW = CHANNEL !== "latest"
 const VERSION = await (async () => {
   if (env.OPENCODE_VERSION) return env.OPENCODE_VERSION
   if (IS_PREVIEW) return `0.0.0-${CHANNEL}-${previewBuildNumber()}`
-  const version = await fetch("https://registry.npmjs.org/opencode-ai/latest")
+  const version = await fetch("https://registry.npmjs.org/@opencode-ai%2fcli/latest")
     .then((res) => {
       if (!res.ok) throw new Error(res.statusText)
       return res.json()

packages/server/src/event-feed.ts

@@ -2,7 +2,7 @@ export * as EventFeed from "./event-feed"
 
 import { Bus } from "@opencode-ai/core/bus"
 import { Event } from "@opencode-ai/schema/event"
-import { isOpenCodeEvent, OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
+import { isOpenCodeEvent, type OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
 import { Cause, Context, Effect, Layer, Queue, Schema, Scope, Stream } from "effect"
 
 export const SubscriberCapacity = 4_096
@@ -26,10 +26,8 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/server/EventFeed") {}
 
-const encode = Schema.encodeUnknownSync(OpenCodeEvent)
-
 export function frame(event: OpenCodeEvent) {
-  return `data: ${JSON.stringify(encode(event))}\n\n`
+  return `data: ${JSON.stringify(event)}\n\n`
 }
 
 export const make = Effect.fn("EventFeed.make")(function* (

packages/server/src/handlers/session.ts

@@ -180,6 +180,22 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
+      .handle(
+        "session.view",
+        Effect.fn(function* (ctx) {
+          yield* session.view({ sessionID: ctx.params.sessionID }).pipe(
+            Effect.catchTag(
+              "Session.NotFoundError",
+              (error) =>
+                new SessionNotFoundError({
+                  sessionID: error.sessionID,
+                  message: `Session not found: ${error.sessionID}`,
+                }),
+            ),
+          )
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
       .handle(
         "session.remove",
         Effect.fn(function* (ctx) {

packages/server/test/event-feed.test.ts

@@ -2,8 +2,7 @@ import { describe, expect, test } from "bun:test"
 import { Agent } from "@opencode-ai/core/agent"
 import { Bus } from "@opencode-ai/core/bus"
 import { Event } from "@opencode-ai/schema/event"
-import { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
-import { DateTime, Deferred, Effect, Exit, Fiber, Option, Schema, Stream } from "effect"
+import { Deferred, Effect, Exit, Fiber, Option, Schema, Stream } from "effect"
 import { it } from "../../core/test/lib/effect"
 import { EventFeed } from "../src/event-feed"
 
@@ -11,14 +10,14 @@ const Internal = Bus.ephemeral({ type: "test.internal", schema: { value: Schema.
 
 const event = (id: string): Event.Payload<typeof Agent.Event.Updated> => ({
   id: Event.ID.make(`evt_${id}`),
-  created: DateTime.makeUnsafe(Date.now()),
+  created: Date.now(),
   type: Agent.Event.Updated.type,
   data: {},
 })
 
 const internal = (value: string): Event.Payload<typeof Internal> => ({
   id: Event.ID.create(),
-  created: DateTime.makeUnsafe(Date.now()),
+  created: Date.now(),
   type: Internal.type,
   data: { value },
 })
@@ -40,9 +39,7 @@ function makeSource() {
 describe("EventFeed", () => {
   test("preserves the public SSE frame encoding", () => {
     const payload = event("wire")
-    expect(EventFeed.frame(payload)).toBe(
-      `data: ${JSON.stringify(Schema.encodeUnknownSync(OpenCodeEvent)(payload))}\n\n`,
-    )
+    expect(EventFeed.frame(payload)).toBe(`data: ${JSON.stringify(payload)}\n\n`)
   })
 
   it.effect("encodes once and delivers the same frame to every subscriber", () =>

packages/server/test/fetch.test.ts

@@ -52,6 +52,36 @@ it.live("serves unauthenticated and answers CORS preflight when no password is c
   }).pipe(Effect.scoped),
 )
 
+it.live("serves the session view operation and missing-session error", () =>
+  Effect.gen(function* () {
+    const handler = yield* ServerFetch.make(options)
+    const created = yield* Effect.promise(() =>
+      handler(
+        new Request("http://opencode.local/api/session", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: "{}",
+        }),
+      ).then((response) => response.json()),
+    )
+    if (typeof created !== "object" || created === null || !("data" in created))
+      return yield* Effect.die(new Error("Expected a session response"))
+    const data = created.data
+    if (typeof data !== "object" || data === null || !("id" in data) || typeof data.id !== "string")
+      return yield* Effect.die(new Error("Expected a session ID"))
+
+    const viewed = yield* Effect.promise(() =>
+      handler(new Request(`http://opencode.local/api/session/${data.id}/view`, { method: "POST" })),
+    )
+    expect(viewed.status).toBe(204)
+
+    const missing = yield* Effect.promise(() =>
+      handler(new Request("http://opencode.local/api/session/ses_missing_view/view", { method: "POST" })),
+    )
+    expect(missing.status).toBe(404)
+  }).pipe(Effect.scoped),
+)
+
 // Pins the eager-boot guarantee: the application layer is built before the handler returns, so
 // an aborted first request cannot interrupt layer construction and wedge every later request
 // (the Effect-TS/effect#6319 failure class that lazy first-request builds are prone to).

packages/tui/src/context/data.tsx

@@ -816,6 +816,13 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             const currentAssistant = message.activeAssistant(draft)
             if (currentAssistant) currentAssistant.retry = undefined
           })
+          if (event.type === "session.execution.interrupted" && event.data.reason === "shutdown") break
+          result.session.invalidate(event.data.sessionID)
+          void result.session.sync(event.data.sessionID)
+          break
+        case "session.viewed":
+          result.session.invalidate(event.data.sessionID)
+          void result.session.sync(event.data.sessionID)
           break
         case "session.revert.staged":
           if (store.session.info[event.data.sessionID])

packages/tui/src/context/session-tabs.tsx

@@ -25,12 +25,12 @@ import {
   type ClosedSessionTab,
   type SessionTab,
   type SessionTabHistory,
-  type SessionTabUnread,
 } from "./session-tabs-model"
 
 type TabsState = {
   tabs: SessionTab[]
-  unread: Record<string, SessionTabUnread>
+  // Read only long enough to remove the former client-owned state from persisted tab files.
+  unread?: Record<string, unknown>
 }
 
 type PersistedState = {
@@ -43,7 +43,7 @@ type ScrollAnchor = {
   screenY: number
 }
 
-const empty = (): TabsState => ({ tabs: [], unread: {} })
+const empty = (): TabsState => ({ tabs: [] })
 
 // Deliberately after connect settles: the visible session's mount syncs win the first slots.
 const TAB_PREFETCH_DELAY = 300
@@ -60,7 +60,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     const paths = useTuiPaths()
     const renderer = useRenderer()
     const enabled = () => config.tabs.enabled
-    // Focus reporting emits transitions, so an interactive launch owns unread state until its first blur.
+    // Focus reporting emits transitions, so an interactive launch may acknowledge viewed sessions until its first blur.
     const [focused, setFocused] = createSignal(true)
     // Keyed reconcile keeps tab object identity across reorders, so strip rows move instead of
     // mutating in place, which per-row animations and drag state depend on.
@@ -110,16 +110,15 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       const session = data.session.get(sessionID)
       return session?.title ?? persisted ?? fallback ?? (session ? withTimestampedFallback(session) : undefined)
     }
+    const isUnread = (sessionID: string) => {
+      const info = data.session.get(sessionID)
+      return info?.time.idle !== undefined && (info.time.viewed === undefined || info.time.idle > info.time.viewed)
+    }
     const normalize = (value: TabsState) => ({
       tabs: value.tabs.reduce<SessionTab[]>((tabs, tab) => {
         const sessionID = root(tab.sessionID)
         return openSessionTab(tabs, { sessionID, title: title(sessionID, tab.title) })
       }, []),
-      unread: Object.entries(value.unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
-        const sessionID = root(entry[0])
-        result[sessionID] = result[sessionID] === "error" ? "error" : entry[1]
-        return result
-      }, {}),
     })
     const current = () => (route.data.type === "session" ? root(route.data.sessionID) : undefined)
     const newTab = createMemo((open = false) => {
@@ -133,7 +132,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       const members = data.session.family(session)
       const family = members.length > 0 ? members : [session]
       return {
-        unread: state().unread[session],
+        unread: family.some(isUnread) ? ("activity" as const) : undefined,
         promptPulse: promptPulses()[session] ?? 0,
         attention: family.some(
           (id) => (data.session.permission.list(id)?.length ?? 0) > 0 || (data.session.form.list(id)?.length ?? 0) > 0,
@@ -142,17 +141,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       }
     }
 
-    function markUnread(sessionID: string, unread: SessionTabUnread) {
-      if (!enabled() || !focused()) return
-      const session = root(sessionID)
-      if (current() === session || !state().tabs.some((tab) => tab.sessionID === session)) return
-      if (state().unread[session] === unread) return
-      update((draft) => {
-        if (!draft.tabs.some((tab) => tab.sessionID === session)) return
-        draft.unread[session] = unread
-      })
-    }
-
     createEffect(() => {
       if (!enabled()) return
       if (route.data.type !== "session" || route.data.sessionID === "dummy") return
@@ -176,10 +164,11 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       if (!enabled() || !focused()) return
       if (route.data.type !== "session" || route.data.sessionID === "dummy") return
       const sessionID = root(route.data.sessionID)
-      if (!state().unread[sessionID]) return
-      update((draft) => {
-        delete draft.unread[sessionID]
-      })
+      const members = data.session.family(sessionID)
+      const family = members.length > 0 ? members : [sessionID]
+      const unread = family.filter(isUnread)
+      if (unread.length === 0) return
+      void Promise.allSettled(unread.map((id) => client.api.session.view({ sessionID: id })))
     })
 
     createEffect(() => {
@@ -189,7 +178,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       update((draft) => {
         const next = normalize(draft)
         draft.tabs = next.tabs
-        draft.unread = next.unread
+        delete draft.unread
       })
     })
 
@@ -210,7 +199,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       const sessionIDs = signature.split("\n")
       let stale = false
       void (async () => {
-        await Promise.allSettled(sessionIDs.map((sessionID) => data.session.sync(sessionID)))
+        await Promise.allSettled(sessionIDs.map((sessionID) => data.session.sync(sessionID, { children: true })))
         if (stale) return
         const locations = new Map(
           sessionIDs
@@ -244,9 +233,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       })
     })
 
-    onCleanup(event.on("session.execution.succeeded", (evt) => markUnread(evt.data.sessionID, "activity")))
-    onCleanup(event.on("session.execution.interrupted", (evt) => markUnread(evt.data.sessionID, "activity")))
-    onCleanup(event.on("session.execution.failed", (evt) => markUnread(evt.data.sessionID, "error")))
     onCleanup(
       event.on("session.moved", (evt) => {
         if (!enabled() || !state().tabs.some((tab) => tab.sessionID === root(evt.data.sessionID))) return
@@ -282,7 +268,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       history = previous.history
       update((draft) => {
         draft.tabs = closeSessionTab(draft.tabs, target).tabs
-        delete draft.unread[target]
       })
       setPromptPulses((pulses) => {
         if (pulses[target] === undefined) return pulses
@@ -378,7 +363,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       cycleUnread(direction: 1 | -1) {
         if (!enabled()) return
         const tab = cycleSessionTab(state().tabs, current(), direction, (tab) =>
-          Boolean(state().unread[tab.sessionID] || status(tab.sessionID).attention),
+          Boolean(status(tab.sessionID).unread || status(tab.sessionID).attention),
         )
         if (tab) route.navigate({ type: "session", sessionID: tab.sessionID })
       },

packages/tui/test/context/session-tabs.test.tsx

@@ -35,6 +35,8 @@ async function renderSessionTabs(
     persisted?: string[]
     sessionGate?: Promise<void>
     sessionDirectories?: Record<string, string>
+    sessionParents?: Record<string, string>
+    sessionTimes?: Record<string, { idle?: number; viewed?: number }>
     newLocation?: "launch" | "inherit"
   },
 ) {
@@ -53,9 +55,13 @@ async function renderSessionTabs(
   }
   const events = createEventStream()
   const sessions: string[] = []
+  const views: string[] = []
   const locations: string[] = []
   const vcsLocations: string[] = []
-  const calls = createFetch(async (url) => {
+  const sessionTimes = Object.fromEntries(
+    Object.entries(options?.sessionTimes ?? {}).map(([sessionID, time]) => [sessionID, { ...time }]),
+  )
+  const calls = createFetch(async (url, request) => {
     if (url.pathname === "/api/location") {
       const requested = url.searchParams.get("location[directory]") ?? directory
       locations.push(requested)
@@ -72,6 +78,13 @@ async function renderSessionTabs(
         data: { branch: { current: "main", default: "main" } },
       })
     }
+    const viewed = url.pathname.match(/^\/api\/session\/([^/]+)\/view$/)?.[1]
+    if (viewed && request.method === "POST") {
+      views.push(viewed)
+      const time = (sessionTimes[viewed] ??= {})
+      time.viewed = time.idle
+      return new Response(null, { status: 204 })
+    }
     const sessionID = url.pathname.match(/^\/api\/session\/([^/]+)$/)?.[1]
     if (!sessionID) return undefined
     sessions.push(sessionID)
@@ -79,12 +92,13 @@ async function renderSessionTabs(
     return json({
       data: {
         id: sessionID,
+        parentID: options?.sessionParents?.[sessionID],
         title: sessionID === initialSessionID ? options?.title : undefined,
         projectID: "project",
         location: { directory: options?.sessionDirectories?.[sessionID] ?? directory },
         cost: 0,
         tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-        time: { created: 0, updated: 0 },
+        time: { created: 0, updated: 0, ...sessionTimes[sessionID] },
       },
     })
   }, events)
@@ -138,9 +152,13 @@ async function renderSessionTabs(
     route,
     data,
     sessions,
+    views,
     locations,
     vcsLocations,
     state,
+    setSessionTime(sessionID: string, time: { idle?: number; viewed?: number }) {
+      sessionTimes[sessionID] = time
+    },
     emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     focus: () => app.renderer.emit("focus"),
     blur: () => app.renderer.emit("blur"),
@@ -153,14 +171,6 @@ async function renderSessionTabs(
   }
 }
 
-const executionSucceeded = (sessionID: string): OpenCodeEvent => ({
-  id: `evt_done_${sessionID}`,
-  created: Date.now(),
-  type: "session.execution.succeeded",
-  durable: { aggregateID: sessionID, seq: 1, version: 1 },
-  data: { sessionID },
-})
-
 test("loads persisted tab metadata concurrently on connect", async () => {
   let release!: () => void
   const sessionGate = new Promise<void>((resolve) => (release = resolve))
@@ -230,56 +240,94 @@ test("stores session tabs for the current working directory by default", async (
     const file = path.join(setup.state, "test", "tui", "tabs.json")
     await wait(() => Bun.file(file).size > 0)
     const stored = await Bun.file(file).json()
-    expect(stored.global).toEqual({ tabs: [], unread: {} })
+    expect(stored.global).toEqual({ tabs: [] })
     expect(Object.keys(stored.cwd)).toEqual([directory])
     expect(stored.cwd[directory].tabs.map((tab: { sessionID: string }) => tab.sessionID)).toEqual(["first"])
-    expect(stored.cwd[directory].unread).toEqual({})
+    expect(stored.cwd[directory]).not.toHaveProperty("unread")
   } finally {
     await setup.destroy()
   }
 })
 
-test("only the foreground TUI mutates unread state", async () => {
-  await using temporary = await tmpdir()
-  let foreground: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
-  let background: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
-
+test("derives unread state from server session times", async () => {
+  const setup = await renderSessionTabs("first", {
+    home: true,
+    persisted: ["first", "second"],
+    sessionTimes: { second: { idle: 2 } },
+  })
   try {
-    foreground = await renderSessionTabs("first", { state: temporary.path, persisted: ["first", "second"] })
-    background = await renderSessionTabs("second", { state: temporary.path })
-    foreground.focus()
-    background.blur()
-    await wait(() => foreground?.tabs.tabs().length === 2 && background?.tabs.tabs().length === 2, 2_000, "shared tabs")
-
-    const firstDone = executionSucceeded("first")
-    foreground.emit(firstDone)
-    background.emit(firstDone)
-    await Promise.all([foreground.flush(), background.flush()])
-    expect(foreground.tabs.status("first").unread).toBeUndefined()
-    expect(background.tabs.status("first").unread).toBeUndefined()
-
-    const secondDone = executionSucceeded("second")
-    foreground.emit(secondDone)
-    background.emit(secondDone)
-    await wait(
-      () =>
-        foreground?.tabs.status("second").unread === "activity" &&
-        background?.tabs.status("second").unread === "activity",
-      10_000,
-      "shared unread activity",
-    )
-
-    foreground.tabs.select("second")
-    await wait(
-      () =>
-        foreground?.tabs.status("second").unread === undefined &&
-        background?.tabs.status("second").unread === undefined,
-      10_000,
-      "shared unread clearing",
-    )
+    await wait(() => setup.tabs.status("second").unread === "activity")
+    expect(setup.tabs.status("first").unread).toBeUndefined()
   } finally {
-    if (foreground) await foreground.destroy()
-    if (background) await background.destroy()
+    await setup.destroy()
+  }
+})
+
+test("refreshes server session times after terminal events", async () => {
+  const setup = await renderSessionTabs("first", { home: true, persisted: ["first"] })
+  try {
+    setup.setSessionTime("first", { idle: 2 })
+    setup.emit({
+      id: "evt_done_first",
+      created: 2,
+      type: "session.execution.succeeded",
+      durable: { aggregateID: "first", seq: 1, version: 1 },
+      data: { sessionID: "first" },
+    })
+    await wait(() => setup.tabs.status("first").unread === "activity")
+  } finally {
+    await setup.destroy()
+  }
+})
+
+test("views a selected unread session only while focused", async () => {
+  const setup = await renderSessionTabs("first", {
+    home: true,
+    persisted: ["first"],
+    sessionTimes: { first: { idle: 2 } },
+  })
+  try {
+    setup.blur()
+    setup.route.navigate({ type: "session", sessionID: "first" })
+    await wait(() => setup.tabs.current() === "first" && setup.tabs.status("first").unread === "activity")
+    await Bun.sleep(20)
+    expect(setup.views).toEqual([])
+
+    setup.focus()
+    await wait(() => setup.views.includes("first"))
+    setup.emit({
+      id: "evt_viewed_first",
+      created: 3,
+      type: "session.viewed",
+      durable: { aggregateID: "first", seq: 2, version: 1 },
+      data: { sessionID: "first" },
+    })
+    await wait(() => setup.tabs.status("first").unread === undefined)
+  } finally {
+    await setup.destroy()
+  }
+})
+
+test("views unread child sessions through their root tab", async () => {
+  const setup = await renderSessionTabs("root", {
+    home: true,
+    persisted: ["root"],
+    sessionParents: { child: "root" },
+    sessionTimes: { child: { idle: 2 } },
+  })
+  try {
+    setup.blur()
+    await setup.data.session.sync("child")
+    await wait(() => setup.tabs.status("root").unread === "activity")
+
+    setup.route.navigate({ type: "session", sessionID: "root" })
+    await Bun.sleep(20)
+    expect(setup.views).toEqual([])
+    setup.focus()
+    await wait(() => setup.views.includes("child"))
+    expect(setup.views).not.toContain("root")
+  } finally {
+    await setup.destroy()
   }
 })
 

packages/updates/src/index.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { channelsForRef, validGitHubClaims } from "./index"
+import { channelsForRef, resolveChannel, validGitHubClaims } from "./index"
 
 const claims = {
   repository: "anomalyco/opencode",
@@ -19,6 +19,10 @@ describe("GitHub publish authorization", () => {
     expect(channelsForRef(claims.ref)).toEqual(["dev", "latest"])
   })
 
+  test("maps V2 development to the dev channel", () => {
+    expect(channelsForRef("refs/heads/v2")).toEqual(["dev"])
+  })
+
   test("rejects another repository or workflow", () => {
     expect(validGitHubClaims({ ...claims, repository_id: "1" })).toBe(false)
     expect(
@@ -33,3 +37,8 @@ describe("GitHub publish authorization", () => {
     ).toBe(false)
   })
 })
+
+test("routes the retired next channel to beta", () => {
+  expect(resolveChannel("next")).toBe("beta")
+  expect(resolveChannel("dev")).toBe("dev")
+})

packages/updates/src/index.ts

@@ -42,7 +42,7 @@ export default {
 
     const segments = url.pathname.split("/").filter(Boolean)
     if (segments.length === 2 && segments[0] === "api" && validIdentifier(segments[1])) {
-      return channel(env.DB, segments[1])
+      return channel(env.DB, resolveChannel(segments[1]))
     }
     if (
       segments.length === 3 &&
@@ -50,7 +50,7 @@ export default {
       validIdentifier(segments[1]) &&
       validIdentifier(segments[2])
     ) {
-      return artifactName(env.DB, segments[1], segments[2])
+      return artifactName(env.DB, resolveChannel(segments[1]), segments[2])
     }
     if (
       segments.length === 4 &&
@@ -59,7 +59,7 @@ export default {
       validIdentifier(segments[2]) &&
       validIdentifier(segments[3])
     ) {
-      return artifactDistribution(env.DB, segments[1], segments[2], segments[3])
+      return artifactDistribution(env.DB, resolveChannel(segments[1]), segments[2], segments[3])
     }
     return new Response("Not found", { status: 404 })
   },
@@ -344,7 +344,7 @@ export function validGitHubClaims(claims: JWTPayload): claims is GitHubClaims {
 
 export function channelsForRef(ref: string) {
   if (ref === "refs/heads/dev") return ["dev", "latest"]
-  if (ref === "refs/heads/v2") return ["next"]
+  if (ref === "refs/heads/v2") return ["dev"]
   if (ref === "refs/heads/beta") return ["beta"]
   if (ref === "refs/heads/ci") return ["ci"]
   if (ref === "refs/heads/fix/npm-native-binary-install") return ["fix/npm-native-binary-install"]
@@ -352,6 +352,10 @@ export function channelsForRef(ref: string) {
   return snapshot ? [snapshot] : []
 }
 
+export function resolveChannel(channel: string) {
+  return channel === "next" ? "beta" : channel
+}
+
 function validMutation(request: Request) {
   const origin = request.headers.get("Origin")
   if (origin && origin !== new URL(request.url).origin) return json({ error: "Invalid origin" }, 403)

packages/www/content/docs/build/client.mdx

@@ -15,7 +15,7 @@ network. Its types and methods are generated from the same contract as the
 ## Install
 
 ```sh
-bun add @opencode-ai/client@next
+bun add @opencode-ai/client@beta
 ```
 
 ## Create a client
@@ -119,7 +119,7 @@ OpenCode provides a first-class Effect client through the
 and decodes responses into OpenCode schema values.
 
 ```sh
-bun add @opencode-ai/client@next effect
+bun add @opencode-ai/client@beta effect
 ```
 
 ### Create a client

packages/www/content/docs/build/plugins.mdx

@@ -106,7 +106,7 @@ visible from the plugin file, for example:
 
 ```sh
 cd .opencode
-bun add @opencode-ai/plugin@next
+bun add @opencode-ai/plugin@beta
 ```
 
 Match the plugin package version to the OpenCode release you target.
@@ -400,7 +400,7 @@ manifest is:
   "type": "module",
   "exports": "./src/index.ts",
   "dependencies": {
-    "@opencode-ai/plugin": "next"
+    "@opencode-ai/plugin": "beta"
   }
 }
 ```
@@ -430,7 +430,7 @@ OpenCode provides a first-class Effect API for plugins through the
 plugin package and export an `effect` function instead of `setup`:
 
 ```sh
-bun add @opencode-ai/plugin@next effect
+bun add @opencode-ai/plugin@beta effect
 ```
 
 ```ts title=".opencode/plugins/reviewer-effect.ts"

packages/www/content/docs/index.mdx

@@ -18,19 +18,19 @@ description: "Get started with OpenCode."
 <CodeGroup>
 
 ```bash npm
-npm install -g @opencode-ai/cli@next
+npm install -g @opencode-ai/cli@beta
 ```
 
 ```bash bun
-bun install -g --trust @opencode-ai/cli@next
+bun install -g --trust @opencode-ai/cli@beta
 ```
 
 ```bash pnpm
-pnpm add -g --allow-build=@opencode-ai/cli @opencode-ai/cli@next
+pnpm add -g --allow-build=@opencode-ai/cli @opencode-ai/cli@beta
 ```
 
 ```bash yarn
-yarn global add @opencode-ai/cli@next
+yarn global add @opencode-ai/cli@beta
 ```
 
 ```bash curl

packages/www/content/docs/migrate-v1.mdx

@@ -35,10 +35,10 @@ beta compatibility bug rather than an expected migration requirement.
 
 ## Install the beta
 
-Install the beta from the `next` distribution tag:
+Install the beta from the `beta` distribution tag:
 
 ```bash
-npm install -g @opencode-ai/cli@next
+npm install -g @opencode-ai/cli@beta
 ```
 
 Start it in your project with:

packages/www/content/docs/troubleshooting.mdx

@@ -119,7 +119,7 @@ Its private service configuration is stored separately at:
 The database normally lives at:
 
 ```text
-~/.local/share/opencode/opencode-next.db
+~/.local/share/opencode/opencode.db
 ```
 
 `OPENCODE_DB` can override the database location.

packages/www/openapi.json

@@ -4127,6 +4127,65 @@
         "summary": "Get session message"
       }
     },
+    "/api/session/{sessionID}/view": {
+      "post": {
+        "tags": ["session"],
+        "operationId": "v2.session.view",
+        "parameters": [
+          {
+            "name": "sessionID",
+            "in": "path",
+            "schema": {
+              "type": "string",
+              "allOf": [
+                {
+                  "pattern": "^ses"
+                }
+              ]
+            },
+            "required": true
+          }
+        ],
+        "security": [],
+        "responses": {
+          "204": {
+            "description": "<No Content>"
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestError"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedError"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SessionNotFoundError"
+                }
+              }
+            }
+          }
+        },
+        "description": "Mark the latest recorded idle transition as viewed.",
+        "summary": "View session"
+      }
+    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],
@@ -12135,6 +12194,12 @@
               "updated": {
                 "type": "number"
               },
+              "idle": {
+                "type": "number"
+              },
+              "viewed": {
+                "type": "number"
+              },
               "archived": {
                 "type": "number"
               }
@@ -14276,6 +14341,71 @@
         "required": ["id", "created", "type", "durable", "data"],
         "additionalProperties": false
       },
+      "session.viewed": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "allOf": [
+              {
+                "pattern": "^evt_"
+              }
+            ]
+          },
+          "created": {
+            "type": "number"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "type": {
+            "type": "string",
+            "enum": ["session.viewed"]
+          },
+          "durable": {
+            "type": "object",
+            "properties": {
+              "aggregateID": {
+                "type": "string"
+              },
+              "seq": {
+                "type": "integer",
+                "allOf": [
+                  {
+                    "minimum": 0
+                  }
+                ]
+              },
+              "version": {
+                "type": "number",
+                "enum": [1]
+              }
+            },
+            "required": ["aggregateID", "seq", "version"],
+            "additionalProperties": false
+          },
+          "location": {
+            "$ref": "#/components/schemas/Location.Ref"
+          },
+          "data": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string",
+                "allOf": [
+                  {
+                    "pattern": "^ses"
+                  }
+                ]
+              }
+            },
+            "required": ["sessionID"],
+            "additionalProperties": false
+          }
+        },
+        "required": ["id", "created", "type", "durable", "data"],
+        "additionalProperties": false
+      },
       "session.deleted": {
         "type": "object",
         "properties": {
@@ -17296,6 +17426,9 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
           {
             "$ref": "#/components/schemas/session.deleted"
           },
@@ -22664,6 +22797,9 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
           {
             "$ref": "#/components/schemas/session.usage.updated"
           },

packages/www/public/openapi.json

@@ -4127,6 +4127,65 @@
         "summary": "Get session message"
       }
     },
+    "/api/session/{sessionID}/view": {
+      "post": {
+        "tags": ["session"],
+        "operationId": "v2.session.view",
+        "parameters": [
+          {
+            "name": "sessionID",
+            "in": "path",
+            "schema": {
+              "type": "string",
+              "allOf": [
+                {
+                  "pattern": "^ses"
+                }
+              ]
+            },
+            "required": true
+          }
+        ],
+        "security": [],
+        "responses": {
+          "204": {
+            "description": "<No Content>"
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestError"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedError"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SessionNotFoundError"
+                }
+              }
+            }
+          }
+        },
+        "description": "Mark the latest recorded idle transition as viewed.",
+        "summary": "View session"
+      }
+    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],
@@ -12135,6 +12194,12 @@
               "updated": {
                 "type": "number"
               },
+              "idle": {
+                "type": "number"
+              },
+              "viewed": {
+                "type": "number"
+              },
               "archived": {
                 "type": "number"
               }
@@ -14276,6 +14341,71 @@
         "required": ["id", "created", "type", "durable", "data"],
         "additionalProperties": false
       },
+      "session.viewed": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "allOf": [
+              {
+                "pattern": "^evt_"
+              }
+            ]
+          },
+          "created": {
+            "type": "number"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "type": {
+            "type": "string",
+            "enum": ["session.viewed"]
+          },
+          "durable": {
+            "type": "object",
+            "properties": {
+              "aggregateID": {
+                "type": "string"
+              },
+              "seq": {
+                "type": "integer",
+                "allOf": [
+                  {
+                    "minimum": 0
+                  }
+                ]
+              },
+              "version": {
+                "type": "number",
+                "enum": [1]
+              }
+            },
+            "required": ["aggregateID", "seq", "version"],
+            "additionalProperties": false
+          },
+          "location": {
+            "$ref": "#/components/schemas/Location.Ref"
+          },
+          "data": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string",
+                "allOf": [
+                  {
+                    "pattern": "^ses"
+                  }
+                ]
+              }
+            },
+            "required": ["sessionID"],
+            "additionalProperties": false
+          }
+        },
+        "required": ["id", "created", "type", "durable", "data"],
+        "additionalProperties": false
+      },
       "session.deleted": {
         "type": "object",
         "properties": {
@@ -17296,6 +17426,9 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
           {
             "$ref": "#/components/schemas/session.deleted"
           },
@@ -22664,6 +22797,9 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
           {
             "$ref": "#/components/schemas/session.usage.updated"
           },

script/beta.ts

@@ -1,360 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-import fs from "fs/promises"
-
-const model = "opencode/gpt-5.3-codex"
-
-interface PR {
-  number: number
-  title: string
-  author: { login: string }
-  labels: Array<{ name: string }>
-}
-
-interface FailedPR {
-  number: number
-  title: string
-  reason: string
-}
-
-async function commentOnPR(prNumber: number, reason: string) {
-  const body = `⚠️ **Blocking Beta Release**
-
-This PR cannot be merged into the beta branch due to: **${reason}**
-
-Please resolve this issue to include this PR in the next beta release.`
-
-  try {
-    await $`gh pr comment ${prNumber} --body ${body}`
-    console.log(`  Posted comment on PR #${prNumber}`)
-  } catch (err) {
-    console.log(`  Failed to post comment on PR #${prNumber}: ${err}`)
-  }
-}
-
-async function conflicts() {
-  const out = await $`git diff --name-only --diff-filter=U`.text().catch(() => "")
-  return out
-    .split("\n")
-    .map((x) => x.trim())
-    .filter(Boolean)
-}
-
-async function cleanup() {
-  try {
-    await $`git merge --abort`
-  } catch {}
-  try {
-    await $`git checkout -- .`
-  } catch {}
-  try {
-    await $`git clean -fd`
-  } catch {}
-}
-
-function lines(prs: PR[]) {
-  return prs.map((x) => `- #${x.number}: ${x.title}`).join("\n") || "(none)"
-}
-
-function group(title: string) {
-  if (process.env.GITHUB_ACTIONS !== "true") {
-    console.log(title)
-    return { [Symbol.dispose]() {} }
-  }
-  console.log(`::group::${title}`)
-  return {
-    [Symbol.dispose]() {
-      console.log("::endgroup::")
-    },
-  }
-}
-
-async function typecheck() {
-  console.log("  Running typecheck...")
-
-  try {
-    await $`bun typecheck`
-    return true
-  } catch (err) {
-    console.log(`Typecheck failed: ${err}`)
-    return false
-  }
-}
-
-async function build() {
-  console.log("  Running final build smoke check...")
-
-  try {
-    await $`./script/build.ts --single`.cwd("packages/opencode")
-    return true
-  } catch (err) {
-    console.log(`Build failed: ${err}`)
-    return false
-  }
-}
-
-async function validate() {
-  if (!(await typecheck())) return false
-  if (!(await build())) return false
-  return true
-}
-
-async function commitSmokeChanges() {
-  const out = await $`git status --porcelain`.text()
-  if (!out.trim()) {
-    console.log("Smoke check passed")
-    return true
-  }
-
-  try {
-    await $`git add -A`
-    await $`git commit -m "Fix beta integration"`
-  } catch (err) {
-    console.log(`Failed to commit smoke fixes: ${err}`)
-    return false
-  }
-
-  if (!(await validate())) return false
-
-  const left = await $`git status --porcelain`.text()
-  if (!left.trim()) {
-    console.log("Smoke check passed")
-    return true
-  }
-
-  console.log(`Smoke check left uncommitted changes:\n${left}`)
-  return false
-}
-
-async function install() {
-  console.log("  Regenerating bun.lock...")
-
-  try {
-    await fs.rm("bun.lock", { force: true })
-    await $`bun install`
-    await $`git add bun.lock`
-    return true
-  } catch (err) {
-    console.log(`Install failed: ${err}`)
-    return false
-  }
-}
-
-async function fix(pr: PR, files: string[], prs: PR[], applied: number[], idx: number) {
-  console.log(`  Trying to auto-resolve ${files.length} conflict(s) with opencode...`)
-
-  const done = lines(prs.filter((x) => applied.includes(x.number)))
-  const next = lines(prs.slice(idx + 1))
-
-  const prompt = [
-    `Resolve the current git merge conflicts while merging PR #${pr.number} into the beta branch.`,
-    `PR #${pr.number}: ${pr.title}`,
-    `Start with these conflicted files: ${files.join(", ")}.`,
-    `Merged PRs on HEAD:\n${done}`,
-    `Pending PRs after this one (context only):\n${next}`,
-    "IMPORTANT: The conflict resolution must be consistent with already-merged PRs.",
-    "Pending PRs are context only; do not introduce their changes unless they are already present on HEAD.",
-    "Prefer already-merged PRs over the base branch when resolving stacked conflicts.",
-    "If bun.lock is conflicted, do not hand-merge it. Delete bun.lock and run bun install after the code conflicts are resolved.",
-    "If a PR already deleted a file/directory, do not re-add it, instead apply changes in the new semantic location.",
-    "If a PR already changed an import, keep that change.",
-    "After resolving the conflicts, run `bun typecheck` at the repo root.",
-    "If typecheck fails, you may also update any files reported by typecheck.",
-    "Keep any non-conflict edits narrowly scoped to restoring a valid merged state for the current PR batch.",
-    "Fix any merge-caused typecheck errors before finishing.",
-    "Keep the merge in progress, do not abort the merge, and do not create a commit.",
-    "When done, leave the working tree with no unmerged files and a passing typecheck.",
-  ].join("\n")
-
-  try {
-    await $`opencode run -m ${model} ${prompt}`
-  } catch (err) {
-    console.log(`  opencode failed: ${err}`)
-    return false
-  }
-
-  const left = await conflicts()
-  if (left.length > 0) {
-    console.log(`  Conflicts remain: ${left.join(", ")}`)
-    return false
-  }
-
-  if (files.includes("bun.lock") && !(await install())) return false
-
-  if (!(await typecheck())) return false
-
-  console.log("  Conflicts resolved with opencode")
-  return true
-}
-
-async function smoke(prs: PR[], applied: number[]) {
-  console.log("\nRunning final smoke check...")
-
-  if (await validate()) return commitSmokeChanges()
-
-  console.log("\nTrying to fix final smoke check with opencode...")
-
-  const done = lines(prs.filter((x) => applied.includes(x.number)))
-  const prompt = [
-    "The beta merge batch is complete, but the deterministic final smoke check failed.",
-    `Merged PRs on HEAD:\n${done}`,
-    "Run `bun typecheck` at the repo root.",
-    "Run `./script/build.ts --single` in `packages/opencode`.",
-    "Fix any merge-caused issues until both commands pass.",
-    "Do not create a commit.",
-  ].join("\n")
-
-  try {
-    await $`opencode run -m ${model} ${prompt}`
-  } catch (err) {
-    console.log(`Smoke fix failed: ${err}`)
-    return false
-  }
-
-  if (!(await validate())) return false
-  return commitSmokeChanges()
-}
-
-async function main() {
-  console.log("Fetching open PRs with beta label...")
-
-  const stdout =
-    await $`gh pr list --state open --draft=false --label beta --json number,title,author,labels --limit 100`.text()
-  const prs: PR[] = JSON.parse(stdout).sort((a: PR, b: PR) => a.number - b.number)
-
-  console.log(`Found ${prs.length} open PRs with beta label`)
-
-  if (prs.length === 0) {
-    console.log("No team PRs to merge")
-    return
-  }
-
-  console.log("Fetching latest dev branch...")
-  await $`git fetch origin dev`
-
-  console.log("Checking out beta branch...")
-  await $`git checkout -B beta origin/dev`
-
-  const applied: number[] = []
-  const failed: FailedPR[] = []
-
-  for (const [idx, pr] of prs.entries()) {
-    console.log()
-    using _ = group(`Processing PR ${idx + 1}/${prs.length} #${pr.number}: ${pr.title}`)
-    console.log("  Fetching PR head...")
-    try {
-      await $`git fetch origin pull/${pr.number}/head:pr/${pr.number}`
-    } catch (err) {
-      console.log(`  Failed to fetch: ${err}`)
-      failed.push({ number: pr.number, title: pr.title, reason: "Fetch failed" })
-      await commentOnPR(pr.number, "Fetch failed")
-      continue
-    }
-
-    console.log("  Merging...")
-    try {
-      await $`git merge --no-commit --no-ff pr/${pr.number}`
-    } catch {
-      const files = await conflicts()
-      if (files.length > 0) {
-        console.log("  Failed to merge (conflicts)")
-        if (!(await fix(pr, files, prs, applied, idx))) {
-          await cleanup()
-          failed.push({ number: pr.number, title: pr.title, reason: "Merge conflicts" })
-          await commentOnPR(pr.number, "Merge conflicts with dev branch")
-          continue
-        }
-      } else {
-        console.log("  Failed to merge")
-        await cleanup()
-        failed.push({ number: pr.number, title: pr.title, reason: "Merge failed" })
-        await commentOnPR(pr.number, "Merge failed")
-        continue
-      }
-    }
-
-    try {
-      await $`git rev-parse -q --verify MERGE_HEAD`.text()
-    } catch {
-      console.log("  No changes, skipping")
-      continue
-    }
-
-    try {
-      await $`git add -A`
-    } catch {
-      console.log("  Failed to stage changes")
-      failed.push({ number: pr.number, title: pr.title, reason: "Staging failed" })
-      await commentOnPR(pr.number, "Failed to stage changes")
-      continue
-    }
-
-    const commitMsg = `Apply PR #${pr.number}: ${pr.title}`
-    try {
-      await $`git commit -m ${commitMsg}`
-    } catch (err) {
-      console.log(`  Failed to commit: ${err}`)
-      failed.push({ number: pr.number, title: pr.title, reason: "Commit failed" })
-      await commentOnPR(pr.number, "Failed to commit changes")
-      continue
-    }
-
-    console.log("  Applied successfully")
-    applied.push(pr.number)
-  }
-
-  console.log("\n--- Summary ---")
-  console.log(`Applied: ${applied.length} PRs`)
-  applied.forEach((num) => console.log(`  - PR #${num}`))
-
-  if (failed.length > 0) {
-    console.log(`Failed: ${failed.length} PRs`)
-    failed.forEach((f) => console.log(`  - PR #${f.number}: ${f.reason}`))
-    throw new Error(`${failed.length} PR(s) failed to merge`)
-  }
-
-  console.log("\nChecking if beta branch has changes...")
-  await $`git fetch origin beta`
-
-  const localTree = (await $`git rev-parse beta^{tree}`.text()).trim()
-  const remoteTrees = (await $`git log origin/dev..origin/beta --format=%T`.text()).split("\n")
-
-  const matchIdx = remoteTrees.indexOf(localTree)
-  if (matchIdx !== -1) {
-    if (matchIdx !== 0) {
-      console.log(`Beta branch contains this sync, but additional commits exist after it. Leaving beta branch as is.`)
-    } else {
-      console.log("Beta branch has identical contents, no push needed")
-    }
-    return
-  }
-
-  if (!(await smoke(prs, applied))) throw new Error("Final smoke check failed")
-
-  await $`git fetch origin beta`
-
-  const validatedTree = (await $`git rev-parse beta^{tree}`.text()).trim()
-  const remoteTreesAfterSmoke = (await $`git log origin/dev..origin/beta --format=%T`.text()).split("\n")
-  const matchIdxAfterSmoke = remoteTreesAfterSmoke.indexOf(validatedTree)
-  if (matchIdxAfterSmoke !== -1) {
-    if (matchIdxAfterSmoke !== 0) {
-      console.log(
-        `Beta branch contains this validated sync, but additional commits exist after it. Leaving beta branch as is.`,
-      )
-    } else {
-      console.log("Validated beta branch now matches remote contents, no push needed")
-    }
-    return
-  }
-
-  console.log("Force pushing validated beta branch...")
-  await $`git push origin beta --force --no-verify`
-
-  console.log("Successfully synced beta branch")
-}
-
-main().catch((err) => {
-  console.error("Error:", err)
-  process.exit(1)
-})

script/publish.ts

@@ -35,39 +35,53 @@ if (Script.release && !Script.preview) {
 
 await prepareReleaseFiles()
 
-if (Script.channel !== "beta") {
-  console.log("\n=== schema ===\n")
-  await $`bun ./packages/schema/script/publish.ts`
+console.log("\n=== schema ===\n")
+await $`bun ./packages/schema/script/publish.ts`
 
-  console.log("\n=== codemode ===\n")
-  await $`bun ./packages/codemode/script/publish.ts`
+console.log("\n=== codemode ===\n")
+await $`bun ./packages/codemode/script/publish.ts`
 
-  console.log("\n=== theme ===\n")
-  await $`bun ./packages/theme/script/publish.ts`
+console.log("\n=== theme ===\n")
+await $`bun ./packages/theme/script/publish.ts`
 
-  console.log("\n=== ai ===\n")
-  await $`bun ./packages/ai/script/publish.ts`
+console.log("\n=== ai ===\n")
+await $`bun ./packages/ai/script/publish.ts`
 
-  console.log("\n=== util ===\n")
-  await $`bun ./packages/util/script/publish.ts`
+console.log("\n=== util ===\n")
+await $`bun ./packages/util/script/publish.ts`
 
-  console.log("\n=== protocol ===\n")
-  await $`bun ./packages/protocol/script/publish.ts`
+console.log("\n=== protocol ===\n")
+await $`bun ./packages/protocol/script/publish.ts`
 
-  console.log("\n=== client ===\n")
-  await $`bun ./packages/client/script/publish.ts`
+console.log("\n=== client ===\n")
+await $`bun ./packages/client/script/publish.ts`
 
-  console.log("\n=== cli ===\n")
-  await $`bun ./packages/cli/script/publish.ts`
+console.log("\n=== cli ===\n")
+await $`bun ./packages/cli/script/publish.ts`
 
-  console.log("\n=== plugin ===\n")
-  await $`bun ./packages/plugin/script/publish.ts`
+console.log("\n=== plugin ===\n")
+await $`bun ./packages/plugin/script/publish.ts`
 
-  console.log("\n=== core ===\n")
-  await $`bun ./packages/core/script/publish.ts`
+console.log("\n=== core ===\n")
+await $`bun ./packages/core/script/publish.ts`
 
-  console.log("\n=== ui ===\n")
-  await $`bun ./packages/ui/script/publish.ts`
+console.log("\n=== ui ===\n")
+await $`bun ./packages/ui/script/publish.ts`
+
+if (Script.channel === "beta") {
+  const packages = [
+    "@opencode-ai/schema",
+    "@opencode-ai/codemode",
+    "@opencode-ai/theme",
+    "@opencode-ai/ai",
+    "@opencode-ai/util",
+    "@opencode-ai/protocol",
+    "@opencode-ai/client",
+    "@opencode-ai/plugin",
+    "@opencode-ai/core",
+    "@opencode-ai/ui",
+  ]
+  await Promise.all(packages.map((name) => $`npm dist-tag add ${`${name}@${Script.version}`} next`))
 }
 
 if (Script.release) {