fix(core): bypass Windows Git lookup

.changeset/device-authorization-url.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/core": patch
----
-
-Fix OpenCode Console device authorization URLs when the server returns an origin-rooted verification path.

bun.lock

@@ -365,6 +365,7 @@
         "@opencode-ai/codemode": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
         "@opencode-ai/schema": "workspace:*",
+        "@opencode-ai/shell-scan": "workspace:*",
         "@opencode-ai/util": "workspace:*",
         "@parcel/watcher": "2.5.1",
         "@silvia-odwyer/photon-node": "0.3.4",
@@ -629,7 +630,6 @@
         "@tsconfig/bun": "catalog:",
         "@types/bun": "catalog:",
         "@typescript/native-preview": "catalog:",
-        "prettier": "3.6.2",
         "typescript": "catalog:",
       },
     },
@@ -734,6 +734,15 @@
         "vite": "catalog:",
       },
     },
+    "packages/shell-scan": {
+      "name": "@opencode-ai/shell-scan",
+      "version": "0.0.0",
+      "devDependencies": {
+        "@tsconfig/bun": "catalog:",
+        "@types/bun": "catalog:",
+        "@typescript/native-preview": "catalog:",
+      },
+    },
     "packages/simulation": {
       "name": "@opencode-ai/simulation",
       "version": "1.17.13",
@@ -2054,6 +2063,8 @@
 
     "@opencode-ai/session-ui": ["@opencode-ai/session-ui@workspace:packages/session-ui"],
 
+    "@opencode-ai/shell-scan": ["@opencode-ai/shell-scan@workspace:packages/shell-scan"],
+
     "@opencode-ai/simulation": ["@opencode-ai/simulation@workspace:packages/simulation"],
 
     "@opencode-ai/stats-app": ["@opencode-ai/stats-app@workspace:packages/stats/app"],

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-xRvq8FkSjn+1q+1wcab+jAmQJdo8lHF8OGnzU+xPLyI=",
-    "aarch64-linux": "sha256-uAwwtOz81LLimTqiDH6E1W65srSMLGk1QV0cUJYanj0=",
-    "aarch64-darwin": "sha256-F28kZvtYRb+ri5T8JoIG/VMK6J7ad5R3QivwJDLtmWA=",
-    "x86_64-darwin": "sha256-NWNoBjwQTTNAESdFWItT4UYc+fTLD1RIe/Ibbqtem7Q="
+    "x86_64-linux": "sha256-PatsUdaitHvSUpS5gkC5J2rsUNB5vwJKqHdlOFaKk70=",
+    "aarch64-linux": "sha256-gTRQMAADH/SpQ8yh+YS2IcnmQxnJcU4FUah2YfrKeP8=",
+    "aarch64-darwin": "sha256-QTqlwmugYh+iu5Sh/Hxv01NXH/OhzcQ8ObVUbA9A8AM=",
+    "x86_64-darwin": "sha256-0DPAbNCVw2nUMWkIGEhB6saMdxRRwAJi7wAoWCQc7xQ="
   }
 }

packages/ai/src/protocols/gemini.ts

@@ -212,6 +212,7 @@ type GeminiEvent = Schema.Schema.Type<typeof GeminiEvent>
 interface ParserState {
   readonly finishReason?: string
   readonly hasToolCalls: boolean
+  readonly nextToolCallId: number
   readonly promptFeedback?: GeminiPromptFeedback
   readonly usage?: Usage
   readonly lifecycle: Lifecycle.State
@@ -579,6 +580,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
   const events: LLMEvent[] = []
   let hasToolCalls = nextState.hasToolCalls
   let lifecycle = nextState.lifecycle
+  let nextToolCallId = nextState.nextToolCallId
   let reasoningSignature = nextState.reasoningSignature
   let textSignature = nextState.textSignature
 
@@ -618,9 +620,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
 
     if ("functionCall" in part) {
       const input = part.functionCall.args === undefined ? {} : part.functionCall.args
-      // Gemini 2.0+ and Vertex supply a unique function call ID on the part; when omitted (e.g. Gemini 1.5),
-      // generate a globally unique ID rather than a per-request counter to prevent cross-request collisions in downstream registries.
-      const id = part.functionCall.id ?? `tool_${crypto.randomUUID().replaceAll("-", "")}`
+      const id = `tool_${nextToolCallId++}`
       const metadata = {
         ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),
         ...(part.thoughtSignature === undefined ? {} : { thoughtSignature: part.thoughtSignature }),
@@ -649,6 +649,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
       ...nextState,
       hasToolCalls,
       lifecycle,
+      nextToolCallId,
       reasoningSignature,
       textSignature,
       finishReason: candidate.finishReason ?? nextState.finishReason,
@@ -672,7 +673,7 @@ export const protocol = Protocol.make({
   },
   stream: {
     event: Protocol.jsonEvent(GeminiEvent),
-    initial: () => ({ hasToolCalls: false, lifecycle: Lifecycle.initial() }),
+    initial: () => ({ hasToolCalls: false, nextToolCallId: 0, lifecycle: Lifecycle.initial() }),
     step,
     onHalt: finish,
   },

packages/ai/src/protocols/openai-images.ts

@@ -110,7 +110,7 @@ export const model = (input: ModelInput) => {
       const multipartImages = yield* Effect.forEach(sourceImages, (image) => {
         if (image.type === "bytes") return Effect.succeed({ data: image.data, mediaType: image.mediaType })
         if (image.type === "url") return ImageInputs.decodeDataUrl(image.url, ADAPTER)
-        return Effect.undefined
+        return Effect.succeed(undefined)
       })
       const multipartMask =
         mask === undefined

packages/ai/src/protocols/utils/image-input.ts

@@ -16,7 +16,7 @@ export const decodeDataUrl = (
   url: string,
   module: string,
 ): Effect.Effect<{ readonly mediaType: string; readonly data: Uint8Array } | undefined, AIError> => {
-  if (!url.startsWith("data:")) return Effect.undefined
+  if (!url.startsWith("data:")) return Effect.succeed(undefined)
   const match = /^data:([^;,]+);base64,(.*)$/s.exec(url)
   if (!match) return Effect.fail(invalid(module, "Image data URLs must contain a MIME type and base64 data"))
   return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(

packages/ai/test/provider/gemini.test.ts

@@ -848,7 +848,7 @@ describe("Gemini route", () => {
         providerMetadata: { google: { thoughtSignature: "thought_sig" } },
       })
       expect(toolCall).toMatchObject({
-        id: "provider_call",
+        id: "tool_0",
         providerMetadata: { google: { functionCallId: "provider_call", thoughtSignature: "tool_sig" } },
       })
       expect(response.events.findIndex((event) => event.type === "reasoning-end")).toBeLessThan(
@@ -862,14 +862,14 @@ describe("Gemini route", () => {
             Message.assistant([
               { type: "reasoning", text: "thinking", providerMetadata: reasoningEnd?.providerMetadata },
               ToolCallPart.make({
-                id: "provider_call",
+                id: "tool_0",
                 name: "lookup",
                 input: { query: "weather" },
                 providerMetadata: toolCall?.providerMetadata,
               }),
             ]),
             Message.tool({
-              id: "provider_call",
+              id: "tool_0",
               name: "lookup",
               result: "done",
               resultType: "text",
@@ -1101,17 +1101,21 @@ describe("Gemini route", () => {
         providerMetadata: { google: { promptTokenCount: 5, candidatesTokenCount: 1 } },
       })
 
-      expect(response.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(response.toolCalls[0]).toMatchObject({
-        type: "tool-call",
-        name: "lookup",
-        input: { query: "weather" },
-      })
+      expect(response.toolCalls).toEqual([
+        {
+          type: "tool-call",
+          id: "tool_0",
+          name: "lookup",
+          input: { query: "weather" },
+          providerExecuted: undefined,
+          providerMetadata: undefined,
+        },
+      ])
       expect(response.events).toEqual([
         { type: "step-start", index: 0 },
         {
           type: "tool-call",
-          id: response.toolCalls[0].id,
+          id: "tool_0",
           name: "lookup",
           input: { query: "weather" },
           providerExecuted: undefined,
@@ -1154,8 +1158,7 @@ describe("Gemini route", () => {
         ),
       )
 
-      expect(response.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(response.toolCalls).toMatchObject([{ type: "tool-call", name: "ping", input: {} }])
+      expect(response.toolCalls).toEqual([{ type: "tool-call", id: "tool_0", name: "ping", input: {} }])
     }),
   )
 
@@ -1195,7 +1198,7 @@ describe("Gemini route", () => {
             content: {
               role: "model",
               parts: [
-                { functionCall: { id: "call_0", name: "lookup", args: { query: "weather" } } },
+                { functionCall: { id: "tool_0", name: "lookup", args: { query: "weather" } } },
                 { functionCall: { name: "lookup", args: { query: "news" } } },
               ],
             },
@@ -1209,20 +1212,16 @@ describe("Gemini route", () => {
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
-      expect(response.toolCalls[0]).toMatchObject({
-        type: "tool-call",
-        id: "call_0",
-        name: "lookup",
-        input: { query: "weather" },
-        providerMetadata: { google: { functionCallId: "call_0" } },
-      })
-      expect(response.toolCalls[1]).toMatchObject({
-        type: "tool-call",
-        name: "lookup",
-        input: { query: "news" },
-      })
-      expect(response.toolCalls[1].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(response.toolCalls[0].id).not.toBe(response.toolCalls[1].id)
+      expect(response.toolCalls).toEqual([
+        {
+          type: "tool-call",
+          id: "tool_0",
+          name: "lookup",
+          input: { query: "weather" },
+          providerMetadata: { google: { functionCallId: "tool_0" } },
+        },
+        { type: "tool-call", id: "tool_1", name: "lookup", input: { query: "news" } },
+      ])
       expect(response.events.at(-1)).toMatchObject({
         type: "finish",
         reason: { normalized: "tool-calls", raw: "STOP" },
@@ -1230,31 +1229,6 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("assigns distinct unique fallback ids across separate requests", () =>
-    Effect.gen(function* () {
-      const body = sseEvents({
-        candidates: [
-          {
-            content: {
-              role: "model",
-              parts: [{ functionCall: { name: "lookup", args: { query: "weather" } } }],
-            },
-            finishReason: "STOP",
-          },
-        ],
-      })
-      const req = LLMRequest.update(request, {
-        tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
-      })
-      const first = yield* LLMClient.generate(req).pipe(Effect.provide(fixedResponse(body)))
-      const second = yield* LLMClient.generate(req).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(first.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(second.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(first.toolCalls[0].id).not.toBe(second.toolCalls[0].id)
-    }),
-  )
-
   it.effect("maps length and content-filter finish reasons", () =>
     Effect.gen(function* () {
       const length = yield* LLMClient.generate(request).pipe(

packages/app/e2e/performance/timeline-stability/fixture.ts

@@ -259,18 +259,6 @@ export function event(
   return makeEvent(type, data)
 }
 
-export function toolInputStarted(data: Extract<OpenCodeEvent, { type: "session.tool.input.started" }>["data"]) {
-  return makeEvent("session.tool.input.started", data)
-}
-
-export function toolInputEnded(data: Extract<OpenCodeEvent, { type: "session.tool.input.ended" }>["data"]) {
-  return makeEvent("session.tool.input.ended", data)
-}
-
-export function toolCalled(data: Extract<OpenCodeEvent, { type: "session.tool.called" }>["data"]) {
-  return makeEvent("session.tool.called", data)
-}
-
 export function validateTimelineEvent(input: unknown): OpenCodeEvent {
   if (!input || typeof input !== "object") throw new Error("Timeline event must be an object")
   if (!("type" in input) || typeof input.type !== "string") throw new Error("Timeline event requires a type")

packages/app/e2e/performance/timeline-stability/scroll-interaction.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { createTwoFilesPatch } from "diff"
 import {
   defineVisualRegions,
   reportVisualStability,
@@ -14,63 +13,10 @@ import {
   setupTimeline,
   shell,
   textPart,
-  toolPart,
   userMessage,
   type TimelineMessage,
 } from "./fixture"
 
-test("follows an expanded patch that arrives as the user reaches the bottom", async ({ page }) => {
-  const toolID = "prt_bottom_follow_patch"
-  const input = { patchText: "Update src/edit.ts" }
-  const timeline = await setupTimeline(page, {
-    messages: [
-      ...history(20),
-      userMessage(),
-      assistantMessage([textPart("prt_bottom_follow_text", "Working")], { completed: false }),
-    ],
-    settings: { editToolPartsExpanded: true },
-    reducedMotion: true,
-  })
-  const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
-  await scroller.evaluate((element) => {
-    element.scrollTop = Math.max(0, element.scrollHeight - element.clientHeight - 300)
-    element.dispatchEvent(new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: 300 }))
-    element.scrollTop = element.scrollHeight
-  })
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeLessThanOrEqual(1)
-
-  await timeline.send(partUpdated(toolPart(toolID, "patch", "running", input)))
-  await timeline.send(
-    partUpdated(
-      toolPart(toolID, "patch", "completed", input, {
-        metadata: {
-          files: [
-            {
-              file: "src/edit.ts",
-              status: "modified",
-              patch: createTwoFilesPatch(
-                "a/src/edit.ts",
-                "b/src/edit.ts",
-                Array.from({ length: 40 }, (_, index) => `export const value${index} = ${index}\n`).join(""),
-                Array.from({ length: 40 }, (_, index) => `export const value${index} = ${index + 1}\n`).join(""),
-              ),
-              additions: 40,
-              deletions: 40,
-            },
-          ],
-        },
-      }),
-    ),
-  )
-
-  await timeline.waitForPart(toolID)
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeLessThanOrEqual(1)
-})
-
 test("does not reverse visible rows when the user wheels during shell remeasurement", async ({ page }, testInfo) => {
   const shellID = "prt_wheel_01_shell"
   const followingID = "prt_wheel_02_following"

packages/app/e2e/regression/session-timeline-file-projection.spec.ts

@@ -47,10 +47,5 @@ test("renders a completed single-file patch", async ({ page }) => {
     settings: { editToolPartsExpanded: true },
   })
 
-  const wrapper = page.locator(`[data-timeline-part-id="${id}"]`)
-  const file = wrapper.locator('[data-scope="apply-patch"]')
-  await expect(file.getByRole("button")).toHaveAttribute("aria-expanded", "false")
-  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toHaveCount(0)
-  await file.getByRole("button").click()
-  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toBeVisible()
+  await expect(page.locator(`[data-timeline-part-id="${id}"] [data-component="apply-patch-file-diff"]`)).toBeVisible()
 })

packages/app/e2e/regression/session-timeline-file-state.spec.ts

@@ -2,7 +2,7 @@ import { expect, test } from "@playwright/test"
 import { assistantMessage, setupTimeline, toolPart, userMessage } from "../performance/timeline-stability/fixture"
 import { createTwoFilesPatch } from "diff"
 
-test("keeps patch file disclosures independent", async ({ page }) => {
+test("preserves nested patch file state through outer collapse and reopen", async ({ page }) => {
   const patchID = "prt_nested_patch"
   const files = [patchFile("src/a.ts", "modified"), patchFile("src/b.ts", "added"), patchFile("src/old.ts", "deleted")]
   await setupTimeline(page, {
@@ -21,17 +21,15 @@ test("keeps patch file disclosures independent", async ({ page }) => {
     settings: { editToolPartsExpanded: true },
   })
   const wrapper = page.locator(`[data-timeline-part-id="${patchID}"]`)
-  const modified = wrapper.locator('[data-scope="apply-patch"] [data-type="update"]')
+  const outer = wrapper.locator('[data-slot="collapsible-trigger"]').first()
   const deleted = wrapper.locator('[data-scope="apply-patch"] [data-type="delete"]')
-  await expect(wrapper.locator('[data-scope="apply-patch"] [aria-expanded="false"]')).toHaveCount(3)
   await deleted.getByRole("button").click()
   await expect(deleted.getByRole("button")).toHaveAttribute("aria-expanded", "true")
-  await expect(modified.getByRole("button")).toHaveAttribute("aria-expanded", "false")
-  await modified.getByRole("button").click()
-  await expect(modified.getByRole("button")).toHaveAttribute("aria-expanded", "true")
-  await deleted.getByRole("button").click()
-  await expect(deleted.getByRole("button")).toHaveAttribute("aria-expanded", "false")
-  await expect(modified.getByRole("button")).toHaveAttribute("aria-expanded", "true")
+  await outer.click()
+  await expect(outer).toHaveAttribute("aria-expanded", "false")
+  await outer.click()
+  await expect(outer).toHaveAttribute("aria-expanded", "true")
+  await expect(deleted.getByRole("button")).toHaveAttribute("aria-expanded", "true")
 })
 
 function patchFile(file: string, status: "added" | "modified" | "deleted") {

packages/app/e2e/regression/session-timeline-lifecycle-state.spec.ts

@@ -1,6 +1,5 @@
 import { expect, test } from "@playwright/test"
 import {
-  assistantID,
   assistantMessage,
   completedAssistantInfo,
   messageUpdated,
@@ -9,13 +8,9 @@ import {
   renderedPartID,
   setupTimeline,
   shell,
-  sessionID,
   status,
   stepStarted,
   textPart,
-  toolCalled,
-  toolInputEnded,
-  toolInputStarted,
   userMessage,
 } from "../performance/timeline-stability/fixture"
 
@@ -39,55 +34,6 @@ for (const expanded of [false, true]) {
   })
 }
 
-test("transitions a streaming shell from writing through command execution", async ({ page }) => {
-  const id = "prt_shell_streaming_input"
-  const command = "printf ready"
-  const timeline = await setupTimeline(page, {
-    messages: [userMessage(), assistantMessage([], { completed: false })],
-  })
-  await timeline.send(toolInputStarted({ sessionID, assistantMessageID: assistantID, id, name: "shell" }))
-
-  const tool = page.locator(`[data-timeline-part-id="${id}"]`)
-  const title = tool.locator('[data-slot="basic-tool-tool-title"]')
-  const titleShimmer = title.locator('[data-component="text-shimmer"]')
-  const subtitle = tool.locator('[data-slot="basic-tool-tool-subtitle"]')
-  await expect(titleShimmer).toHaveAttribute("aria-label", "Shell")
-  await expect(titleShimmer).toHaveAttribute("data-active", "true")
-  await expect(subtitle).toHaveText("Writing command...")
-  await expect(subtitle.locator('[data-component="text-shimmer"]')).toHaveCount(0)
-  await expect(tool.locator('[data-component="shell-submessage"]')).toHaveCount(0)
-  await expect(tool.locator('[data-slot="collapsible-trigger"]')).toHaveCSS("height", "28px")
-  await expect(tool.locator('[data-component="tool-trigger"]')).toHaveCSS("gap", "6px")
-  await expect(title).toHaveCSS("font-size", "13px")
-  await expect(title).toHaveCSS("font-family", "Inter, sans-serif")
-  await expect(title).toHaveCSS("font-weight", "530")
-  await expect(title).toHaveCSS("line-height", "16px")
-  await expect(title).toHaveCSS("color", "rgb(22, 22, 22)")
-  await expect(subtitle).toHaveCSS("font-size", "13px")
-  await expect(subtitle).toHaveCSS("font-family", "Inter, sans-serif")
-  await expect(subtitle).toHaveCSS("font-weight", "440")
-  await expect(subtitle).toHaveCSS("line-height", "16px")
-  await expect(subtitle).toHaveCSS("color", "rgb(92, 92, 92)")
-
-  const input = JSON.stringify({ command })
-  await timeline.send(toolInputEnded({ sessionID, assistantMessageID: assistantID, id, text: input }))
-  await expect(titleShimmer).toHaveAttribute("data-active", "true")
-  await expect(subtitle).toHaveText(command)
-  await expect(tool).not.toContainText("Writing command...")
-
-  await timeline.send(
-    toolCalled({
-      sessionID,
-      assistantMessageID: assistantID,
-      id,
-      input: { command },
-      executed: true,
-    }),
-  )
-  await expect(titleShimmer).toHaveAttribute("data-active", "false")
-  await expect(subtitle).toHaveText(command)
-})
-
 test("shows and expands a running shell command without shimmering it", async ({ page }) => {
   const id = "prt_shell_running_command"
   const command = "sleep 10 && echo done"
@@ -97,11 +43,9 @@ test("shows and expands a running shell command without shimmering it", async ({
   })
 
   const tool = page.locator(`[data-timeline-part-id="${id}"]`)
-  await expect(tool.locator('[data-component="text-shimmer"]')).toHaveAttribute("data-active", "false")
-  await expect(tool).not.toContainText("Writing command...")
+  await expect(tool.locator('[data-component="text-shimmer"]')).toHaveAttribute("data-active", "true")
   await expect(tool.locator('[data-component="shell-submessage"]')).toHaveText(command)
   await expect(tool.locator('[data-component="shell-submessage"] [data-component="text-shimmer"]')).toHaveCount(0)
-  await expect(tool.locator('[data-slot="collapsible-trigger"]')).toHaveCSS("height", "28px")
   await tool.locator('[data-slot="collapsible-trigger"]').click()
   await expect(tool.locator('[data-slot="collapsible-trigger"]')).toHaveAttribute("aria-expanded", "true")
   await expect(tool.locator('[data-slot="bash-pre"]')).toContainText("still running")

packages/app/e2e/regression/session-timeline-notices.spec.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "@playwright/test"
 import type { SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client/promise"
-import { event, session, sessionID, setupTimeline, toolPart } from "../performance/timeline-stability/fixture"
+import { event, session, sessionID, setupTimeline } from "../performance/timeline-stability/fixture"
 
 const user = { id: "msg_user", type: "user", text: "Run it", time: { created: 1 } } satisfies SessionMessageInfo
 
@@ -73,81 +73,6 @@ test("renders current protocol notices in CLI order", async ({ page }) => {
   expect(ownerWarnings).toEqual([])
 })
 
-test("shows a delegating row while subagent input streams", async ({ page }) => {
-  await setupTimeline(page, {
-    sessionMessages: [
-      user,
-      {
-        ...assistant(false),
-        content: [toolPart("call_subagent", "subagent", "streaming", {})],
-      },
-    ],
-  })
-
-  const delegating = page.locator('[data-component="task-tool-delegating"]')
-  await expect(delegating).toBeVisible()
-  await expect(delegating.locator('[data-component="text-shimmer"]')).toHaveAttribute(
-    "aria-label",
-    "Delegating agent...",
-  )
-  const icon = delegating.locator('[data-slot="icon-svg"]')
-  await expect(icon.locator('use[href="#opencode-v2-icon-subagent"]')).toBeVisible()
-  await expect(icon).toHaveCSS("color", "rgb(174, 174, 174)")
-  await expect(page.locator('[data-component="task-tool-card"]')).toHaveCount(0)
-  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
-})
-
-test("renders the moved location notice in its compact timeline style", async ({ page }) => {
-  const directory = `/Users/usrnk1/Developer/opencode/${"nested-directory/".repeat(24)}session`
-  await page.setViewportSize({ width: 480, height: 720 })
-  await setupTimeline(page, {
-    sessionMessages: [
-      user,
-      {
-        id: "msg_location",
-        type: "location-switched",
-        location: { directory },
-        time: { created: 2 },
-      },
-    ],
-  })
-
-  const notice = page.locator('[data-slot="session-timeline-notice"][data-type="location-switched"]')
-  const label = notice.locator('[data-slot="session-timeline-notice-label"]')
-  const value = notice.locator('[data-slot="session-timeline-notice-value"]')
-  const tooltipTrigger = notice.locator('[data-component="tooltip-v2-trigger"]')
-
-  await expect(label).toHaveText("Moved to")
-  await expect(value).toHaveText(directory)
-  await expect(notice).not.toContainText("·")
-  await expect(notice.locator("svg")).toHaveCount(0)
-  await expect(notice).toHaveCSS("height", "28px")
-  await expect(notice).toHaveCSS("gap", "8px")
-  await expect(notice).toHaveCSS("padding-top", "4px")
-  await expect(notice).toHaveCSS("padding-bottom", "4px")
-  await expect(label).toHaveCSS("font-size", "13px")
-  await expect(label).toHaveCSS("font-weight", "530")
-  await expect(label).toHaveCSS("line-height", "13px")
-  await expect(label).toHaveCSS("color", "rgb(128, 128, 128)")
-  await expect(value).toHaveCSS("font-size", "13px")
-  await expect(value).toHaveCSS("font-weight", "440")
-  await expect(value).toHaveCSS("line-height", "13px")
-  await expect(value).toHaveCSS("color", "rgb(128, 128, 128)")
-  await expect(value).toHaveCSS("text-overflow", "ellipsis")
-  await expect(value).toHaveCSS("white-space", "nowrap")
-  await expect(value).toHaveAttribute("dir", "ltr")
-  await expect.poll(() => value.evaluate((element) => element.scrollWidth > element.clientWidth)).toBe(true)
-
-  const tooltip = page.getByText("Session working directory changed", { exact: true })
-  await label.hover()
-  await expect(tooltip).toBeVisible()
-  await page.mouse.move(0, 0)
-  await expect(tooltip).toBeHidden()
-  await tooltipTrigger.focus()
-  await expect(tooltipTrigger).toBeFocused()
-  await expect(tooltip).toBeVisible()
-})
-
 test("moves blocking work to the background with Ctrl+B", async ({ page }) => {
   await setupTimeline(page, { sessionMessages: [user, assistant(false, true)] })
   const card = page.locator('[data-component="task-tool-card"]')
@@ -156,24 +81,7 @@ test("moves blocking work to the background with Ctrl+B", async ({ page }) => {
   await expect(card).not.toContainText("(background)")
   await expect(page.getByText("Called `subagent`", { exact: false })).toHaveCount(0)
   await expect(page.locator('[data-component="background-tool-control"]')).toHaveCount(0)
-  const hint = page.locator('[data-component="session-background-hint"]')
-  const hintPrefix = hint.locator('[data-slot="session-background-hint-prefix"]')
-  await expect(hint).toBeVisible()
-  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
-  await expect
-    .poll(async () => {
-      const [cardBox, hintBox, prefixBox] = await Promise.all([
-        card.boundingBox(),
-        hint.boundingBox(),
-        hintPrefix.boundingBox(),
-      ])
-      if (!cardBox || !hintBox || !prefixBox) return undefined
-      return {
-        aligned: Math.abs(cardBox.x - prefixBox.x) < 2,
-        ordered: cardBox.y < hintBox.y,
-      }
-    })
-    .toEqual({ aligned: true, ordered: true })
+  await expect(page.locator('[data-action="session-background-toggle"]')).toContainText("Move 1 subagent to background")
 
   const request = page.waitForRequest(
     (request) =>
@@ -196,10 +104,10 @@ test("navigates from a running subagent card and hides background controls in th
     sessionStatus: { [sessionID]: { type: "busy" }, [childID]: { type: "busy" } },
   })
 
-  await expect(page.getByText(/move running work to the background/i)).toBeVisible()
+  await expect(page.locator('[data-action="session-background-toggle"]')).toContainText("Move 1 subagent to background")
   await page.locator('[data-component="task-tool-card"]').click()
   await expect(page).toHaveURL(new RegExp(`/session/${childID}$`))
-  await expect(page.getByText(/move running work to the background/i)).toHaveCount(0)
+  await expect(page.locator('[data-component="session-background-dock"]')).toHaveCount(0)
 })
 
 test("shows a badge for active background work", async ({ page }) => {
@@ -210,14 +118,7 @@ test("shows a badge for active background work", async ({ page }) => {
     sessionStatus: { [childID]: { type: "busy" } },
   })
 
-  await page.getByRole("button", { name: "Session details" }).click()
-  const summary = page.getByRole("button", { name: "1 item running in background" })
-  await expect(summary).toContainText("1")
-  await expect(summary).toContainText("Running work in background")
-  await summary.click()
-  await expect(
-    page.locator('[data-component="session-background-list"]').getByText("Agent", { exact: true }),
-  ).toBeVisible()
+  await expect(page.locator('[data-component="session-background-dock"]')).toContainText("1 subagent in background")
 })
 
 test("separates blocking and already-backgrounded work into two rows", async ({ page }) => {
@@ -292,15 +193,10 @@ test("separates blocking and already-backgrounded work into two rows", async ({
     },
   })
 
+  const dock = page.locator('[data-component="session-background-dock"]')
   const backgroundCard = page.locator('[data-timeline-part-id="call_backgrounded"]')
-  await expect(page.getByText(/move running work to the background/i)).toBeVisible()
-  await page.getByRole("button", { name: "Session details" }).click()
-  const summary = page.getByRole("button", { name: "2 items running in background" })
-  await expect(summary).toContainText("2")
-  await summary.click()
-  const list = page.locator('[data-component="session-background-list"]')
-  await expect(list).toContainText("Background task")
-  await expect(list).toContainText("sleep 120")
+  await expect(dock).toContainText("Move 1 subagent to background")
+  await expect(dock.getByText("Running 1 shell and 1 subagent in background", { exact: true })).toBeVisible()
   await expect(backgroundCard).toContainText("Background task (background)")
   await expect(backgroundCard.locator('[data-component="session-progress-indicator-v2"]')).toBeVisible()
   await expect(

packages/app/e2e/regression/session-timeline-projection.spec.ts

@@ -69,43 +69,9 @@ test.describe("session timeline projection", () => {
     ]) {
       await expect(page.locator(`[data-timeline-part-id="${id}"]`).first(), id).toBeVisible()
     }
-    const patch = page.locator('[data-timeline-part-id="prt_patch"]')
-    await expect(patch.getByText("1 file", { exact: true })).toBeVisible()
-    await expect(patch.getByRole("button", { name: "Patch 1 file", exact: true })).toHaveCount(0)
-    await expect(patch.getByRole("button")).toHaveCount(1)
-    await expect(patch.locator('[data-scope="apply-patch"] button[aria-expanded="false"]')).toHaveCount(1)
-    await expect(patch.locator('[data-slot="message-part-title-filename"]')).toHaveCount(0)
-    await expect(patch.locator('[data-slot="message-part-actions"]')).toHaveCount(0)
     await expect(page.locator('[data-timeline-part-id="prt_todo"]')).toHaveCount(0)
   })
 
-  test("combines adjacent patch calls into one file group", async ({ page }) => {
-    const first = "prt_patch_first"
-    const second = "prt_patch_second"
-    await setupTimeline(page, {
-      messages: [
-        userMessage(),
-        assistantMessage([
-          toolPart(first, "patch", "completed", { patchText: "Update src/first.ts" }, {
-            metadata: { files: [patchFile("src/first.ts", "modified")] },
-          }),
-          toolPart(second, "patch", "completed", { patchText: "Update src/second.ts" }, {
-            metadata: { files: [patchFile("src/second.ts", "added")] },
-          }),
-        ]),
-      ],
-    })
-
-    const group = page.locator(`[data-timeline-part-ids="${first},${second}"]`)
-    await expect(group).toBeVisible()
-    await expect(group.locator('[data-component="apply-patch-tool"]')).toHaveCount(1)
-    await expect(group.getByRole("button", { name: "Patch 2 files" })).toHaveCount(0)
-    await expect(group.getByRole("button")).toHaveCount(2)
-    await expect(group.locator('[data-scope="apply-patch"] button[aria-expanded="false"]')).toHaveCount(2)
-    await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["first.ts", "second.ts"])
-    await expect(page.locator(`[data-timeline-part-id="${first}"], [data-timeline-part-id="${second}"]`)).toHaveCount(0)
-  })
-
   test("projects gaps, dividers, assistant parts, and errors together", async ({ page }) => {
     const firstUser = userMessage(
       [
@@ -230,7 +196,11 @@ function patchPart(id: string) {
     { patchText: "Update the projected files" },
     {
       metadata: {
-        files: [patchFile("src/a.ts", "modified")],
+        files: [
+          patchFile("src/a.ts", "modified"),
+          patchFile("src/b.ts", "added"),
+          patchFile("src/old.ts", "deleted"),
+        ],
       },
     },
   )

packages/app/e2e/regression/session-timeline-tool-projection.spec.ts

@@ -127,16 +127,19 @@ test("labels skill tools from IDs and result metadata", async ({ page }) => {
     ],
   })
 
-  for (const [id, name] of [
-    [pending, "sample-skill"],
-    [completed, "OpenCode"],
-  ] as const) {
+  await expect(page.locator(`[data-timeline-part-id="${pending}"] [data-component="text-shimmer"]`)).toHaveAttribute(
+    "aria-label",
+    "sample-skill",
+  )
+  await expect(page.locator(`[data-timeline-part-id="${completed}"] [data-component="text-shimmer"]`)).toHaveAttribute(
+    "aria-label",
+    "OpenCode",
+  )
+  for (const id of [pending, completed]) {
     const skill = page.locator(`[data-timeline-part-id="${id}"]`)
-    const loaded = skill.locator('[data-component="tool-loaded-item"]')
-    await expect(loaded).toHaveAttribute("aria-label", `Loaded ${name} skill`)
-    await expect(loaded.locator('[data-slot="tool-loaded-label"]')).toHaveText("Loaded")
-    await expect(loaded.locator('[data-slot="tool-loaded-kind"]')).toHaveText("skill")
-    await expect(loaded.locator('[data-component="text-shimmer"]')).toHaveAttribute("aria-label", name)
+    await expect(skill.locator('[data-slot="skill-tool-label"]')).toHaveText("Skill")
+    await expect(skill.locator('[data-slot="skill-tool-separator"]')).toHaveText("·")
+    await expect(skill.locator('use[href="#opencode-v2-icon-post-skill"]')).toBeVisible()
   }
 })
 

packages/app/src/entry.tsx

@@ -61,9 +61,7 @@ if (import.meta.env.VITE_SENTRY_DSN) {
   })
 }
 
-if (root instanceof HTMLElement && root.dataset.opencodeMounted === undefined) {
-  // Lazy chunks can import the entry chunk back under a distinct URL, so claim the root before async startup.
-  root.dataset.opencodeMounted = ""
+if (root instanceof HTMLElement) {
   void loadInitialLocale().then((locale) => {
     const auth = authFromToken(new URLSearchParams(location.search).get("auth_token"))
     clearAuthToken()

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

@@ -1,5 +1,6 @@
 import { createPromptProjectController } from "@/new-session/project/selector"
 import { useSettingsDialog } from "@/settings/command"
+import { useTitlebarRightMount } from "@/shell/titlebar/titlebar"
 import { useSettings } from "@/settings/model"
 import { useTabs, type DraftTab } from "@/shell/tabs/tabs"
 import { useSearchParams } from "@solidjs/router"
@@ -14,6 +15,7 @@ import { useNewSessionCommands } from "./commands"
 /** The draft-only Session page. Submitting promotes the draft into a real Session. */
 export default function NewSessionPage(props: { draftId: string }) {
   const settings = useSettings()
+  const rightMount = useTitlebarRightMount()
   const [search, setSearch] = useSearchParams<{ draftId?: string; prompt?: string }>()
   const tabs = useTabs()
   const openWorkspaces = useSettingsDialog("workspaces")
@@ -67,7 +69,7 @@ export default function NewSessionPage(props: { draftId: string }) {
   return (
     <div class="relative size-full overflow-hidden flex flex-col">
       {suspendUntilPromptReady()}
-      <NewSessionStatus visible={settings.visibility.status()} />
+      <NewSessionStatus mount={rightMount()} visible={settings.visibility.status()} />
       <div class="flex-1 min-h-0 flex flex-col gap-2 p-2">
         <NewSessionView composer={model} project={project} workspace={workspace} />
       </div>

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

@@ -4,6 +4,7 @@ import { Icon } from "@opencode-ai/ui/icon"
 import { Wordmark } from "@opencode-ai/ui/wordmark"
 import { Show, createMemo, createSignal } from "solid-js"
 import { createStore } from "solid-js/store"
+import { Portal } from "solid-js/web"
 import createPresence from "solid-presence"
 import { Composer } from "@/composer/composer"
 import type { ComposerModel } from "@/composer/model"
@@ -14,7 +15,6 @@ import {
   type PromptProjectController,
 } from "@/new-session/project/selector"
 import { StatusPopover } from "@/shell/status/status-popover"
-import { TitlebarRight } from "@/shell/titlebar/right-slot"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useWorkspaceLocation } from "@/workspaces/location"
 import { useProviders } from "@/providers/catalog/providers"
@@ -87,16 +87,21 @@ export function NewSessionView(props: {
   )
 }
 
-export function NewSessionStatus(props: { visible: boolean }) {
+export function NewSessionStatus(props: { mount: HTMLElement | null; visible: boolean }) {
   const language = useLanguage()
+
   return (
-    <TitlebarRight>
-      <Show when={props.visible}>
-        <Tooltip appearance="standard" placement="bottom" value={language.t("status.popover.trigger")}>
-          <StatusPopover />
-        </Tooltip>
-      </Show>
-    </TitlebarRight>
+    <Show when={props.mount} keyed>
+      {(mount) => (
+        <Portal mount={mount}>
+          <Show when={props.visible}>
+            <Tooltip appearance="standard" placement="bottom" value={language.t("status.popover.trigger")}>
+              <StatusPopover />
+            </Tooltip>
+          </Show>
+        </Portal>
+      )}
+    </Show>
   )
 }
 

packages/app/src/runtime/i18n/en.ts

@@ -30,7 +30,6 @@ export const dict = {
   "command.project.previous": "Previous project",
   "command.project.next": "Next project",
   "command.project.index": "Switch to project {{index}}",
-  "command.project.copyID": "Copy Project ID",
   "command.provider.connect": "Connect provider",
   "command.server.switch": "Switch server",
   "command.settings.open": "Open settings",
@@ -94,7 +93,6 @@ export const dict = {
   "command.session.fork.description": "Create a new session from a previous message",
   "command.session.export": "Export session",
   "command.session.export.description": "Export the full session transcript as JSON",
-  "command.session.copyID": "Copy Session ID",
 
   "palette.search.placeholder": "Search files, commands, and sessions",
   "palette.search.placeholder.home": "Search commands and sessions",
@@ -546,6 +544,7 @@ export const dict = {
   "toast.context.noLineSelection.title": "No line selection",
   "toast.context.noLineSelection.description": "Select a line range in a file tab first.",
 
+
   "toast.session.unshare.success.title": "Session unshared",
   "toast.session.unshare.success.description": "Session unshared successfully!",
   "toast.session.unshare.failed.title": "Failed to unshare session",
@@ -555,10 +554,6 @@ export const dict = {
   "toast.session.export.success.description": "Saved session to {{filename}}",
   "toast.session.export.failed.title": "Failed to export session",
   "toast.session.export.failed.description": "An error occurred while exporting the session",
-  "toast.session.copyID.failed.title": "Failed to copy session ID",
-  "toast.session.copyID.failed.description": "An error occurred while copying the session ID",
-  "toast.project.copyID.failed.title": "Failed to copy project ID",
-  "toast.project.copyID.failed.description": "An error occurred while copying the project ID",
 
   "toast.session.listFailed.title": "Failed to load sessions for {{project}}",
   "toast.project.reloadFailed.title": "Failed to reload {{project}}",
@@ -662,10 +657,6 @@ export const dict = {
     "{{server}} is running OpenCode {{version}}, which isn't compatible with this app. Upgrade the server to OpenCode V2 to continue.",
   "session.background.moveTasks": "Move {{tasks}} to background",
   "session.background.inBackground": "Running {{tasks}} in background",
-  "session.background.moveInline": "Press {{keybind}} to move running work to the background",
-  "session.background.running": "Running work in background",
-  "session.background.runningCount.one": "{{count}} item running in background",
-  "session.background.runningCount.other": "{{count}} items running in background",
   "session.background.combine": "{{first}} and {{second}}",
   "session.background.shell.one": "{{count}} shell",
   "session.background.shell.other": "{{count}} shells",

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

@@ -89,7 +89,6 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   const focusInput = actions.focusInput
 
   const sessionCommand = withCategory(language.t("command.category.session"))
-  const projectCommand = withCategory(language.t("command.category.project"))
   const fileCommand = withCategory(language.t("command.category.file"))
   const contextCommand = withCategory(language.t("command.category.context"))
   const viewCommand = withCategory(language.t("command.category.view"))
@@ -127,46 +126,6 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     }
   }
 
-  const copySessionID = async () => {
-    const sessionID = actions.session.identity.params.id
-    if (!sessionID) return
-    try {
-      await navigator.clipboard.writeText(sessionID)
-      showToast({
-        variant: "success",
-        icon: "circle-check",
-        title: language.t("common.copied"),
-        description: sessionID,
-      })
-    } catch (err) {
-      showToast({
-        variant: "error",
-        title: language.t("toast.session.copyID.failed.title"),
-        description: err instanceof Error ? err.message : language.t("toast.session.copyID.failed.description"),
-      })
-    }
-  }
-
-  const copyProjectID = async () => {
-    const projectID = actions.session.data.info()?.projectID
-    if (!projectID) return
-    try {
-      await navigator.clipboard.writeText(projectID)
-      showToast({
-        variant: "success",
-        icon: "circle-check",
-        title: language.t("common.copied"),
-        description: projectID,
-      })
-    } catch (err) {
-      showToast({
-        variant: "error",
-        title: language.t("toast.project.copyID.failed.title"),
-        description: err instanceof Error ? err.message : language.t("toast.project.copyID.failed.description"),
-      })
-    }
-  }
-
   const openFile = () => {
     void openDialog(
       () => import("@/shell/commands/dialog"),
@@ -312,12 +271,6 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
       disabled: !actions.session.identity.params.id,
       onSelect: exportSession,
     }),
-    sessionCommand({
-      id: "session.copyID",
-      title: language.t("command.session.copyID"),
-      disabled: !actions.session.identity.params.id,
-      onSelect: copySessionID,
-    }),
   ]
 
   const fileCmds = () => {
@@ -341,15 +294,6 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     ].filter((v) => !!v)
   }
 
-  const projectCmds = () => [
-    projectCommand({
-      id: "project.copyID",
-      title: language.t("command.project.copyID"),
-      disabled: !actions.session.data.info()?.projectID,
-      onSelect: copyProjectID,
-    }),
-  ]
-
   const contextCmds = () => [
     contextCommand({
       id: "context.addSelection",
@@ -463,7 +407,6 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
 
   command.register("session", () => [
     ...sessionCmds(),
-    ...projectCmds(),
     ...fileCmds(),
     ...contextCmds(),
     ...viewCmds(),

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

@@ -2,12 +2,15 @@ import { Show, type JSX } from "solid-js"
 import { useLanguage } from "@/runtime/i18n/language"
 import { SessionPermissionDock } from "@/session/requests/session-permission-dock"
 import { SessionQuestionDock } from "@/session/requests/session-question-dock"
+import { SessionBackgroundDock } from "@/session/requests/session-background-dock"
 import type { SessionComposerRegionController } from "./session-composer-region-controller"
 
 type SessionComposerRegionState = Pick<
   SessionComposerRegionController["state"],
   "questionRequest" | "permissionRequest" | "permissionResponding" | "decide" | "blocked"
->
+> & {
+  background: Pick<SessionComposerRegionController["state"]["background"], "blocking" | "tasks" | "move">
+}
 
 export type SessionComposerRegionViewController = Pick<
   SessionComposerRegionController,
@@ -29,6 +32,9 @@ export function SessionComposerRegion(props: {
 }) {
   const language = useLanguage()
   const controller = props.controller
+  const background = () =>
+    controller.state.background.blocking().length > 0 || controller.state.background.tasks().length > 0
+
   return (
     <div
       ref={controller.setDockRef}
@@ -75,10 +81,22 @@ export function SessionComposerRegion(props: {
               </>
             }
           >
+            <Show when={background()}>
+              <div>
+                <SessionBackgroundDock
+                  blocking={controller.state.background.blocking()}
+                  tasks={controller.state.background.tasks()}
+                  onBackground={() => void controller.state.background.move()}
+                />
+              </div>
+            </Show>
             <div
               classList={{
                 "relative z-[70]": true,
               }}
+              style={{
+                "margin-top": `${background() ? -36 : 0}px`,
+              }}
             >
               <Show
                 when={controller.child()}

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

@@ -1,12 +1,13 @@
-import { createMemo } from "solid-js"
+import { createMemo, Show } from "solid-js"
 import { createMediaQuery } from "@solid-primitives/media"
+import { Portal } from "solid-js/web"
 import { useCommand } from "@/shell/commands/command"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useSettings } from "@/settings/model"
 import { useSessionLayout } from "@/session/session-layout"
 import { reviewTooltipKeybind } from "@/shell/commands/tooltip-keybind"
 import { StatusPopover } from "@/shell/status/status-popover"
-import { TitlebarRight } from "@/shell/titlebar/right-slot"
+import { useTitlebarRightMount } from "@/shell/titlebar/titlebar"
 import { SessionHeaderActions, type SessionHeaderActionsState } from "./session-header-actions"
 
 export function SessionHeader() {
@@ -27,9 +28,15 @@ export function SessionHeader() {
     onReviewToggle: () => view().reviewPanel.toggle(),
   }))
 
+  const rightMount = useTitlebarRightMount()
+
   return (
-    <TitlebarRight>
-      <SessionHeaderActions state={actions()} />
-    </TitlebarRight>
+    <Show when={rightMount()} keyed>
+      {(mount) => (
+        <Portal mount={mount}>
+          <SessionHeaderActions state={actions()} />
+        </Portal>
+      )}
+    </Show>
   )
 }

packages/app/src/session/requests/model.ts

@@ -63,7 +63,6 @@ export function createSessionRequestModel() {
       return [
         {
           type: part.name as "shell" | "subagent",
-          partID: part.id,
           id: typeof value === "string" ? value : undefined,
           label: typeof label === "string" ? label : undefined,
         },
@@ -94,13 +93,11 @@ export function createSessionRequestModel() {
         const sessionID = part.state.metadata.sessionID
         if (typeof sessionID !== "string" || completed.has(sessionID)) return []
         const description = part.state.input.description
-        const agent = part.state.input.agent
         return [
           {
             id: sessionID,
             type: "subagent" as const,
             label: typeof description === "string" ? description : sessionID,
-            agent: typeof agent === "string" ? agent : undefined,
           },
         ]
       })

packages/app/src/session/requests/session-background-dock.tsx

@@ -0,0 +1,83 @@
+import { useLanguage } from "@/runtime/i18n/language"
+import { useCommand } from "@/shell/commands/command"
+import { Keybind } from "@opencode-ai/ui/keybind"
+import { For, createMemo } from "solid-js"
+import { createStore } from "solid-js/store"
+import { SessionBackgroundPullout } from "./session-background-pullout"
+
+export function SessionBackgroundDock(props: {
+  blocking: { type: "shell" | "subagent"; id?: string; label?: string }[]
+  tasks: { id: string; type: "shell" | "subagent"; label: string }[]
+  onBackground: () => void
+}) {
+  const language = useLanguage()
+  const command = useCommand()
+  const [store, setStore] = createStore({ collapsed: true })
+  const describe = (shells: number, subagents: number) => {
+    const shell = shells ? language.plural("session.background.shell", shells, { count: shells }) : undefined
+    const subagent = subagents
+      ? language.plural("session.background.subagent", subagents, { count: subagents })
+      : undefined
+    if (shell && subagent) return language.t("session.background.combine", { first: shell, second: subagent })
+    return shell ?? subagent ?? ""
+  }
+  const summary = createMemo(() => {
+    const shells = props.tasks.filter((task) => task.type === "shell").length
+    return describe(shells, props.tasks.length - shells)
+  })
+  const moving = createMemo(() => {
+    const shells = props.blocking.filter((task) => task.type === "shell").length
+    const subagents = props.blocking.length - shells
+    const tasks = describe(shells, subagents)
+    return tasks ? language.t("session.background.moveTasks", { tasks }) : ""
+  })
+  const background = createMemo(() =>
+    summary() ? language.t("session.background.inBackground", { tasks: summary() }) : "",
+  )
+  const blocking = () => props.blocking.length > 0
+  const toggle = () => {
+    if (blocking()) {
+      props.onBackground()
+      return
+    }
+    setStore("collapsed", (value) => !value)
+  }
+
+  return (
+    <SessionBackgroundPullout
+      label={
+        <span class="flex flex-col items-start">
+          {blocking() && (
+            <span>
+              <span class="text-v2-text-text-muted">{moving()}</span>
+              <span class="pl-2">
+                <Keybind keys={command.keybindParts("session.background")} variant="neutral" />
+              </span>
+            </span>
+          )}
+          {!!props.tasks.length && <span class="text-v2-text-text-faint">{background()}</span>}
+        </span>
+      }
+      ariaLabel={[moving(), background()].filter(Boolean).join(". ")}
+      multiline={blocking() && props.tasks.length > 0}
+      collapsed={blocking() || store.collapsed}
+      collapsible={!blocking()}
+      onToggle={toggle}
+      collapseLabel={language.t("session.todo.collapse")}
+      expandLabel={language.t("session.todo.expand")}
+    >
+      <div class="px-4 pb-11 flex flex-col gap-1.5">
+        <For each={props.tasks}>
+          {(task) => (
+            <div class="flex min-w-0 items-baseline gap-2 text-13-regular">
+              <span class="shrink-0 text-13-medium text-text-strong">
+                {language.t(task.type === "shell" ? "ui.tool.shell" : "ui.tool.agent.default")}
+              </span>
+              <span class="truncate text-text-weak">{task.label}</span>
+            </div>
+          )}
+        </For>
+      </div>
+    </SessionBackgroundPullout>
+  )
+}

packages/app/src/session/requests/session-background-pullout.tsx

@@ -0,0 +1,114 @@
+import { IconButton } from "@opencode-ai/ui/icon-button"
+import { Icon } from "@opencode-ai/ui/icon"
+import { useSpring } from "@opencode-ai/ui/motion-spring"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
+import { createEffect, createMemo, type JSX } from "solid-js"
+import { createStore } from "solid-js/store"
+
+export function SessionBackgroundPullout(props: {
+  label: JSX.Element
+  ariaLabel: string
+  multiline?: boolean
+  collapsed: boolean
+  collapsible?: boolean
+  onToggle: () => void
+  collapseLabel: string
+  expandLabel: string
+  children: JSX.Element
+}) {
+  const [store, setStore] = createStore({ height: 78, header: 42 })
+  const collapse = useSpring(() => (props.collapsed ? 1 : 0), { visualDuration: 0.3, bounce: 0 })
+  const value = createMemo(() => Math.max(0, Math.min(1, collapse())))
+  const off = createMemo(() => value() > 0.98)
+  const base = createMemo(() => Math.max(78, store.header + 36))
+  const full = createMemo(() => Math.max(base(), store.height))
+  let contentRef: HTMLDivElement | undefined
+  let headerRef: HTMLDivElement | undefined
+
+  createEffect(() => {
+    const element = contentRef
+    const header = headerRef
+    if (!element || !header) return
+    const update = () => {
+      setStore("height", (height) => Math.max(height, element.scrollHeight))
+      setStore("header", header.getBoundingClientRect().height)
+    }
+    update()
+    createResizeObserver([element, header], update)
+  })
+
+  return (
+    <div
+      data-component="session-background-dock"
+      class="w-full overflow-hidden rounded-xl border-[0.5px] border-v2-border-border-base bg-v2-background-bg-layer-01"
+      style={{
+        "overflow-x": "visible",
+        "overflow-y": "hidden",
+        "max-height": `${Math.max(base(), full() - value() * (full() - base()))}px`,
+      }}
+    >
+      <div ref={contentRef}>
+        <div
+          ref={headerRef}
+          data-action="session-background-toggle"
+          class="flex items-center gap-2 overflow-visible pl-4 pr-2"
+          classList={{
+            "h-[42px]": !props.multiline,
+            "min-h-[42px] py-2": props.multiline,
+          }}
+          role="button"
+          tabIndex={0}
+          onClick={props.onToggle}
+          onKeyDown={(event) => {
+            if (event.key !== "Enter" && event.key !== " ") return
+            event.preventDefault()
+            props.onToggle()
+          }}
+        >
+          <span
+            class="cursor-default inline-flex items-baseline shrink-0 overflow-visible font-[440] text-[13px] leading-5 tracking-[-0.04px] text-v2-text-text-muted"
+            aria-label={props.ariaLabel}
+            style={{
+              "--tool-motion-odometer-ms": "600ms",
+              "--tool-motion-mask": "18%",
+              "--tool-motion-mask-height": "0px",
+              "--tool-motion-spring-ms": "560ms",
+              "white-space": "pre",
+            }}
+          >
+            {props.label}
+          </span>
+          {props.collapsible !== false && (
+            <div class="ml-auto">
+              <IconButton
+                data-action="session-background-toggle-button"
+                data-collapsed={props.collapsed ? "true" : "false"}
+                icon={<Icon name="chevron-down" />}
+                size="normal"
+                variant="ghost"
+                style={{ transform: `rotate(${value() * 180}deg)` }}
+                onMouseDown={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                }}
+                onClick={(event) => {
+                  event.stopPropagation()
+                  props.onToggle()
+                }}
+                aria-label={props.collapsed ? props.expandLabel : props.collapseLabel}
+              />
+            </div>
+          )}
+        </div>
+        <div
+          data-slot="session-background-list"
+          aria-hidden={props.collapsed || off()}
+          classList={{ "pointer-events-none": value() > 0.1 }}
+          style={{ visibility: off() ? "hidden" : "visible", opacity: `${Math.max(0, 1 - value())}` }}
+        >
+          {props.children}
+        </div>
+      </div>
+    </div>
+  )
+}

packages/app/src/session/screen.tsx

@@ -72,7 +72,6 @@ export function SessionScreen(props: { session: SessionModel }) {
               {(_id) => (
                 <MessageTimeline
                   session={session}
-                  background={composer.region.state.background}
                   actions={composer.actions.timeline}
                   scroll={timeline.scroll}
                   onResumeScroll={timeline.actions.resume}

packages/app/src/session/session-resolution.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createRoot } from "solid-js"
-import { createSessionResolution } from "./session-resolution"
-
-describe("session resolution", () => {
-  test("waits for a route session ID", () => {
-    createRoot((dispose) => {
-      let syncs = 0
-      const sessions = {
-        get: () => undefined,
-        sync: () => {
-          syncs++
-          return Promise.resolve()
-        },
-      }
-      const session = createSessionResolution(() => undefined, () => sessions)
-
-      expect(session()).toBeUndefined()
-      expect(syncs).toBe(0)
-      dispose()
-    })
-  })
-})

packages/app/src/session/session-resolution.ts

@@ -29,20 +29,15 @@ type Resolution<T> = { id: string; store: SessionStore<T> } & (
 // session that simply has not resolved yet. Resolve failures rethrow on read so
 // the enclosing SessionRouteErrorBoundary renders the scoped session error.
 export function createSessionResolution<T>(
-  sessionID: () => string | undefined,
+  sessionID: () => string,
   sessions: () => SessionStore<T>,
   options?: { children?: boolean },
 ) {
-  const cached = createMemo(() => {
-    const id = sessionID()
-    if (!id) return
-    return sessions().get(id)
-  })
+  const cached = createMemo(() => sessions().get(sessionID()))
   const [status, setStatus] = createSignal<Resolution<T>>()
 
   createEffect(
     on([sessionID, sessions] as const, ([id, store]) => {
-      if (!id) return
       let stale = false
       onCleanup(() => {
         stale = true
@@ -65,11 +60,10 @@ export function createSessionResolution<T>(
 
   return createMemo(() => {
     const id = sessionID()
-    if (!id) return
     const value = cached()
     if (value) return value
     const state = status()
-    if (!state || state.id !== id || state.store !== sessions()) return undefined
+    if (state?.id !== id || state.store !== sessions()) return undefined
     if (state.state === "failed") throw state.failure
     // A session missing after settlement was deleted, possibly by another client.
     // Match the resolve error so the boundary shows the

packages/app/src/session/story-model.tsx

@@ -84,6 +84,7 @@ export type SessionPreviewProps = {
   draft?: string
   request?: { type: "permission"; value: PermissionRequest } | { type: "question"; value: FormInfo }
   reviewOpened?: boolean
+  backgroundTasks?: { id: string; type: "shell" | "subagent"; label: string }[]
   child?: { parentID: string }
   terminal?: { title: string; lines: string[] }
 }
@@ -195,6 +196,13 @@ function SessionSurfaceState(props: SessionPreviewProps & { onReset: () => void
         setState("request", undefined)
         setState("activity", `Permission response: ${response}`)
       },
+      background: {
+        blocking: () => [],
+        tasks: () => props.backgroundTasks ?? [],
+        move: async () => {
+          setState("activity", "Requested background execution")
+        },
+      },
       blocked: () => state.request !== undefined,
     },
     centered: () => true,

packages/app/src/session/timeline/background-work.stories.tsx

@@ -1,36 +0,0 @@
-import { BackgroundMoveHint, BackgroundWorkSummary } from "./message-timeline"
-
-const tasks = [
-  { id: "task_explore", type: "subagent" as const, agent: "explore", label: "Reviewing component implementation" },
-  { id: "task_status", type: "shell" as const, label: "opencode2 service status" },
-  { id: "task_openapi", type: "shell" as const, label: "opencode2 api get /openapi.json" },
-  { id: "task_tests", type: "shell" as const, label: "bun test packages/app" },
-]
-
-export default {
-  title: "OpenCode/Session/Background work",
-  id: "session-background-work",
-  parameters: {
-    docs: {
-      description: {
-        component: "Production controls for moving blocking work and inspecting active background tasks.",
-      },
-    },
-  },
-}
-
-export const InlineMoveHint = {
-  render: () => (
-    <div class="flex w-[696px] max-w-full flex-col items-start gap-4">
-      <BackgroundMoveHint keybind={["Ctrl", "B"]} />
-    </div>
-  ),
-}
-
-export const SummaryPanelEntry = {
-  render: () => (
-    <div class="w-[280px] rounded-[6px] bg-v2-background-bg-base px-0.5 py-1.5 shadow-[var(--v2-elevation-raised)]">
-      <BackgroundWorkSummary tasks={tasks} />
-    </div>
-  ),
-}

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

@@ -1,15 +1,11 @@
-import { createEffect, createMemo, createSignal, For, on, Show, type Accessor } from "solid-js"
-import createPresence from "solid-presence"
+import { createEffect, createMemo, createSignal, on, Show, type Accessor } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { SessionUserActions } from "@opencode-ai/session-ui/actions"
-import { Badge } from "@opencode-ai/ui/badge"
 import { DiffChanges } from "@opencode-ai/ui/diff-changes"
 import { Icon } from "@opencode-ai/ui/icon"
 import { IconButton } from "@opencode-ai/ui/icon-button"
 import { InlineInput } from "@opencode-ai/ui/inline-input"
-import { Keybind } from "@opencode-ai/ui/keybind"
 import { Menu } from "@opencode-ai/ui/menu"
-import { TextShimmer } from "@opencode-ai/ui/text-shimmer"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { ProjectAvatar } from "@opencode-ai/ui/project-avatar"
 import type { Project } from "@/runtime/server/types"
@@ -19,7 +15,7 @@ import { SessionContextUsage } from "@/session/timeline/session-context-usage"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useData } from "@/runtime/server/current"
 import { useWorkspaceLocation } from "@/workspaces/location"
-import { Timeline, TimelineRow } from "@opencode-ai/session-ui/timeline/projection"
+import { Timeline } from "@opencode-ai/session-ui/timeline/projection"
 import { createSessionTimelineRowRenderer } from "@opencode-ai/session-ui/timeline/row"
 import { createTimelineController, type TimelineController, type TimelineSessionSource } from "./controller"
 import { createTimelineVirtualizer } from "./virtualizer"
@@ -28,129 +24,6 @@ import { SessionWorkspaceMenu } from "@/session/timeline/session-workspace-menu"
 import { getProjectAvatarVariant } from "@/shell/state/layout"
 import { displayName, getProjectAvatarSource } from "@/shell/layout/helpers"
 import { parseCommentNote, readPromptPresentation } from "@/composer/comment-note"
-import { useCommand } from "@/shell/commands/command"
-
-type BackgroundTask = {
-  id: string
-  type: "shell" | "subagent"
-  label: string
-  agent?: string
-}
-
-type SessionBackground = {
-  blocking: Accessor<{ type: "shell" | "subagent"; partID: string; id?: string; label?: string }[]>
-  tasks: Accessor<BackgroundTask[]>
-  move: () => Promise<void>
-}
-
-export function BackgroundMoveHint(props: { keybind?: string[] }) {
-  const language = useLanguage()
-  const command = useCommand()
-  const marker = "__OPENCODE_BACKGROUND_KEYBIND__"
-  const parts = createMemo(() => language.t("session.background.moveInline", { keybind: marker }).split(marker))
-  const keys = () => props.keybind ?? command.keybindParts("session.background")
-  const keybind = () => props.keybind?.join("+") ?? command.keybind("session.background")
-
-  return (
-    <div
-      data-component="session-background-hint"
-      class="flex h-6 max-w-full items-center justify-center gap-[3px] overflow-hidden text-[13px] font-[530] leading-5 tracking-[-0.04px] text-v2-text-text-muted"
-      aria-label={language.t("session.background.moveInline", { keybind: keybind() })}
-    >
-      <span data-slot="session-background-hint-prefix" class="shrink-0">
-        {parts()[0].trim()}
-      </span>
-      <Keybind keys={keys()} variant="neutral" />
-      <span class="min-w-0 truncate">{parts()[1].trim()}</span>
-    </div>
-  )
-}
-
-function BackgroundMoveHintRow(props: { show: boolean; centered: boolean; padding: string }) {
-  const [ref, setRef] = createSignal<HTMLDivElement>()
-  const visibility = createMemo<{ show: boolean; animate: boolean }>(
-    (previous) => ({ show: props.show, animate: previous.animate || previous.show !== props.show }),
-    { show: props.show, animate: false },
-  )
-  const presence = createPresence({ show: () => visibility().show, element: () => ref() ?? null })
-  return (
-    <Show when={presence.present()}>
-      <div
-        classList={{
-          "min-w-0 w-full max-w-full": true,
-          "md:max-w-200 2xl:max-w-[1000px] md:mx-auto": props.centered,
-        }}
-      >
-        <div
-          ref={setRef}
-          class="duration-150 motion-reduce:animate-none"
-          classList={{
-            [`flex h-10 items-start pt-4 ${props.padding}`]: true,
-            "animate-in fade-in": visibility().animate && visibility().show,
-            "animate-out fade-out fill-mode-forwards": visibility().animate && !visibility().show,
-          }}
-        >
-          <BackgroundMoveHint />
-        </div>
-      </div>
-    </Show>
-  )
-}
-
-export function BackgroundWorkSummary(props: { tasks: BackgroundTask[] }) {
-  const language = useLanguage()
-  const [open, setOpen] = createSignal(false)
-  const taskType = (task: BackgroundTask) => {
-    if (task.type === "shell") return language.t("ui.tool.shell")
-    if (!task.agent) return language.t("ui.tool.agent.default")
-    return task.agent.slice(0, 1).toUpperCase() + task.agent.slice(1)
-  }
-
-  return (
-    <Popover
-      open={open()}
-      placement={language.direction() === "rtl" ? "right-end" : "left-end"}
-      gutter={4}
-      onOpenChange={setOpen}
-    >
-      <Popover.Trigger
-        as="button"
-        type="button"
-        data-component="session-background-summary"
-        class="flex h-7 w-full items-center gap-2 rounded-[4px] px-3 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed"
-        aria-label={language.plural("session.background.runningCount", props.tasks.length)}
-      >
-        <Badge class="!w-4 !px-0 !border-v2-border-border-strong !bg-v2-background-bg-layer-03">
-          {props.tasks.length}
-        </Badge>
-        <TextShimmer
-          as="span"
-          text={language.t("session.background.running")}
-          active
-          class="min-w-0 flex-1 truncate text-start"
-        />
-      </Popover.Trigger>
-      <Popover.Portal>
-        <Popover.Content
-          data-component="session-background-list"
-          class="z-[60] w-[200px] overflow-hidden rounded-[6px] bg-v2-background-bg-layer-01 p-0.5 shadow-[var(--v2-elevation-floating)] outline-none"
-        >
-          <For each={props.tasks.slice(0, 10)}>
-            {(task) => (
-              <div
-                data-component="session-background-list-item"
-                class="flex h-7 min-w-0 items-center gap-2 rounded-[4px] px-3 text-[13px] font-[440] leading-none tracking-[-0.04px]"
-              >
-                <span class="shrink-0 text-v2-text-text-base">{taskType(task)}</span>
-                <span class="min-w-0 flex-1 truncate text-v2-text-text-faint">{task.label}</span>
-              </div>
-            )}
-          </For>
-        </Popover.Content>
-      </Popover.Portal>
-    </Popover>
-  )
-}
 
 function WorkspaceMoveAction(props: {
   variant: "inline" | "panel"
@@ -221,7 +94,6 @@ function SessionSummaryPanel(props: {
   moveDismissed: boolean
   onMoveDismiss: () => void
   onReview: () => void
-  backgroundTasks: BackgroundTask[]
 }) {
   const language = useLanguage()
   const location = () => {
@@ -296,9 +168,6 @@ function SessionSummaryPanel(props: {
             )}
           </Show>
         </button>
-        <Show when={props.backgroundTasks.length > 0}>
-          <BackgroundWorkSummary tasks={props.backgroundTasks} />
-        </Show>
       </div>
       <Show when={props.local && props.diffs && props.diffs.length > 0 && props.moveEligible}>
         <WorkspaceMoveAction
@@ -317,7 +186,6 @@ function SessionSummaryPanel(props: {
 
 type MessageTimelineProps = {
   session: TimelineSessionSource
-  background: SessionBackground
   actions?: SessionUserActions
   scroll: { overflow: boolean; jump: boolean }
   onResumeScroll: () => void
@@ -482,18 +350,6 @@ function MessageTimelineView(
     padding: turnPadding,
     anchor: props.anchor,
   })
-  const backgroundHintPartID = createMemo(() => {
-    const blocking = new Set(props.background.blocking().map((task) => task.partID))
-    const row = projection
-      .rows()
-      .findLast(
-        (row) => row._tag === "AssistantPart" && row.group.type === "part" && blocking.has(row.group.ref.partID),
-      )
-    if (row?._tag !== "AssistantPart" || row.group.type !== "part") return
-    return row.group.ref.partID
-  })
-  const backgroundHint = (row: TimelineRow.TimelineRow) =>
-    row._tag === "AssistantPart" && row.group.type === "part" && row.group.ref.partID === backgroundHintPartID()
 
   return (
     <VirtualizedTimeline
@@ -501,14 +357,9 @@ function MessageTimelineView(
       deferred={(row) => {
         if (row._tag !== "AssistantPart" || row.group.type !== "part") return false
         const content = Timeline.resolveContent(messageByID().get(row.group.ref.messageID), row.group.ref.partID)
-        return content?.type === "tool" && ["edit", "write"].includes(content.name)
+        return content?.type === "tool" && ["edit", "write", "patch"].includes(content.name)
       }}
-      renderRow={(row, onSizeChange) => (
-        <>
-          <rowRenderer.Row row={row} onSizeChange={onSizeChange} />
-          <BackgroundMoveHintRow show={backgroundHint(row())} centered={props.centered} padding={turnPadding()} />
-        </>
-      )}
+      renderRow={(row, onSizeChange) => <rowRenderer.Row row={row} onSizeChange={onSizeChange} />}
       header={
         <div
           data-session-title
@@ -634,7 +485,6 @@ function MessageTimelineView(
                                 setSummary(false)
                                 props.onReview()
                               }}
-                              backgroundTasks={props.background.tasks()}
                             />
                           </Popover.Content>
                         </Popover.Portal>

packages/app/src/session/timeline/virtualizer.tsx

@@ -74,9 +74,7 @@ export function createTimelineVirtualizer(input: Input) {
   let prependLoading = false
   let resizePinnedIndexes: number[] = []
   let resizePinFrame: number | undefined
-  let gestureAnchorFrame: number | undefined
   let virtualContent: HTMLDivElement | undefined
-  let scrollTop = 0
 
   const clearPrependAnchor = () => {
     prependLoading = false
@@ -180,28 +178,12 @@ export function createTimelineVirtualizer(input: Input) {
   })
   const resizeItem = virtualizer.resizeItem
   let resizeAnchorScheduled = false
-  const anchorAfterGesture = () => {
-    if (gestureAnchorFrame !== undefined) return
-    const apply = () => {
-      gestureAnchorFrame = undefined
-      if (input.hasScrollGesture()) {
-        gestureAnchorFrame = requestAnimationFrame(apply)
-        return
-      }
-      if (input.shouldAnchorBottom()) virtualizer.scrollToEnd()
-    }
-    gestureAnchorFrame = requestAnimationFrame(apply)
-  }
   const anchorResizedBottom = () => {
-    if (resizeAnchorScheduled) return
+    if (resizeAnchorScheduled || input.hasScrollGesture()) return
     resizeAnchorScheduled = true
     queueMicrotask(() => {
       resizeAnchorScheduled = false
-      if (input.hasScrollGesture()) {
-        anchorAfterGesture()
-        return
-      }
-      if (!input.shouldAnchorBottom()) return
+      if (!input.shouldAnchorBottom() || input.hasScrollGesture()) return
       virtualizer.scrollToEnd()
     })
   }
@@ -262,11 +244,7 @@ export function createTimelineVirtualizer(input: Input) {
 
   const maybeAnchorBottom = () => {
     if (rows().length === 0) return
-    if (input.hasScrollGesture()) {
-      anchorAfterGesture()
-      return
-    }
-    if (!input.shouldAnchorBottom()) return
+    if (!input.shouldAnchorBottom() || input.hasScrollGesture()) return
     if (resizePinFrame !== undefined) cancelAnimationFrame(resizePinFrame)
     clearPrependAnchor()
     if (prependAnchorFrame !== undefined) cancelAnimationFrame(prependAnchorFrame)
@@ -287,7 +265,6 @@ export function createTimelineVirtualizer(input: Input) {
   const bindListRoot = (root: HTMLDivElement) => {
     if (root === listRoot()) return
     setListRoot(root)
-    scrollTop = root.scrollTop
     input.setScrollRef(root)
   }
 
@@ -347,17 +324,13 @@ export function createTimelineVirtualizer(input: Input) {
   }
 
   const handleListScroll = (event: Event & { currentTarget: HTMLDivElement }) => {
-    const root = event.currentTarget
-    const movedUp = root.scrollTop < scrollTop - 0.5
-    scrollTop = root.scrollTop
     if (prependLoading) updatePrependAnchor()
-    input.onScheduleScrollState(root)
+    input.onScheduleScrollState(event.currentTarget)
     input.onHistoryScroll()
     if (!input.hasScrollGesture()) return
-    if (!movedUp && root.scrollHeight - root.clientHeight - root.scrollTop >= 10) return
     input.onUserScroll()
     input.onAutoScrollHandleScroll()
-    input.onMarkScrollGesture(root)
+    input.onMarkScrollGesture(event.currentTarget)
   }
 
   function View(props: ViewProps) {
@@ -490,7 +463,6 @@ export function createTimelineVirtualizer(input: Input) {
     cache.set(ownerSessionKey, { measurements: virtualizer.takeSnapshot(), toolOpen: { ...toolOpen } })
     while (cache.size > 16) cache.delete(cache.keys().next().value!)
     if (resizePinFrame !== undefined) cancelAnimationFrame(resizePinFrame)
-    if (gestureAnchorFrame !== undefined) cancelAnimationFrame(gestureAnchorFrame)
     if (overscanFrame !== undefined) cancelAnimationFrame(overscanFrame)
     input.setScrollRef(undefined)
     input.setRevealMessage?.(() => {})

packages/app/src/settings/workspaces/workspaces.tsx

@@ -93,24 +93,14 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
       activeDirectory: props.activeDirectory,
     }
   }
-  // Fetch sessions per workspace directory instead of paging through every session on the server.
-  const loadSessions = async (directories: readonly string[], context = captureDeleteContext()) => {
-    const fetched = await Promise.all(
-      directories.map((directory) => listAllSessions(context.sdk.api.session, { order: "desc", directory })),
-    )
-    const sessions = fetched.flat()
-    return mergeWorkspaceSessionInventory(sessions, context.data.session.list())
+  const loadSessions = async (context = captureDeleteContext()) => {
+    const fetched = await listAllSessions(context.sdk.api.session, { order: "desc" })
+    fetched.forEach(context.data.session.remember)
+    return mergeWorkspaceSessionInventory(fetched, context.data.session.list())
   }
-  const workspaceDirectories = createMemo(() => workspaces().map((workspace) => workspace.directory))
   const sessionQuery = useQuery(() => ({
-    queryKey: [
-      serverSDK.scope,
-      null,
-      "settings-workspace-sessions",
-      workspaceDirectories().map((directory) => String(pathKey(directory))),
-    ] as const,
-    queryFn: () => loadSessions(workspaceDirectories()),
-    enabled: workspaceDirectories().length > 0,
+    queryKey: [serverSDK.scope, null, "settings-workspace-sessions"] as const,
+    queryFn: () => loadSessions().then(() => Date.now()),
     refetchOnMount: "always",
   }))
   const sessionsByWorkspace = createMemo(
@@ -118,7 +108,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
       new Map(
         workspaces().map((workspace) => [
           pathKey(workspace.directory),
-          sessionQuery.data ? sessionsForWorkspace(sessionQuery.data, workspace.directory) : [],
+          sessionQuery.isSuccess ? sessionsForWorkspace(data.session.list(), workspace.directory) : [],
         ]),
       ),
   )
@@ -146,7 +136,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     const [working, branch, sessions] = await Promise.all([
       context.sdk.api.vcs.status({ location: { directory: workspace.directory } }),
       context.sdk.api.vcs.diff({ location: { directory: workspace.directory }, mode: "branch" }),
-      loadSessions([workspace.directory], context),
+      loadSessions(context),
     ])
     const result = inspectWorkspaceDeletion({
       workspace: workspace.directory,

packages/app/src/shell/shell.tsx

@@ -3,7 +3,6 @@ import { createStore } from "solid-js/store"
 import { Titlebar, type TitlebarUpdate } from "@/shell/titlebar/titlebar"
 import { usePlatform } from "@/runtime/platform/platform"
 import { ToastRegion } from "@/shell/notifications/toast"
-import { TitlebarRightProvider } from "@/shell/titlebar/right-slot"
 
 const DebugBar = lazy(() => import("@/shell/debug/debug-bar").then((module) => ({ default: module.DebugBar })))
 
@@ -24,32 +23,30 @@ export default function Layout(props: ParentProps) {
   }
 
   return (
-    <TitlebarRightProvider>
-      <div
-        class="relative bg-v2-background-bg-deep flex-1 min-h-0 min-w-0 flex flex-col select-none [&_input]:select-text [&_textarea]:select-text [&_[contenteditable]]:select-text"
-        style={{
-          "padding-top": "env(safe-area-inset-top, 0px)",
-          "padding-bottom": "env(safe-area-inset-bottom, 0px)",
-        }}
-      >
-        <Titlebar
-          update={update}
-          debugTools={
-            import.meta.env.DEV
-              ? { visible: state.debugTools, toggle: () => setState("debugTools", (value) => !value) }
-              : undefined
-          }
-        />
-        <main class="flex-1 min-h-0 min-w-0 overflow-x-hidden flex flex-col items-start contain-strict">
-          <Suspense>{props.children}</Suspense>
-        </main>
-        <Show when={import.meta.env.DEV && state.debugTools}>
-          <Suspense>
-            <DebugBar inline />
-          </Suspense>
-        </Show>
-        <ToastRegion />
-      </div>
-    </TitlebarRightProvider>
+    <div
+      class="relative bg-v2-background-bg-deep flex-1 min-h-0 min-w-0 flex flex-col select-none [&_input]:select-text [&_textarea]:select-text [&_[contenteditable]]:select-text"
+      style={{
+        "padding-top": "env(safe-area-inset-top, 0px)",
+        "padding-bottom": "env(safe-area-inset-bottom, 0px)",
+      }}
+    >
+      <Titlebar
+        update={update}
+        debugTools={
+          import.meta.env.DEV
+            ? { visible: state.debugTools, toggle: () => setState("debugTools", (value) => !value) }
+            : undefined
+        }
+      />
+      <main class="flex-1 min-h-0 min-w-0 overflow-x-hidden flex flex-col items-start contain-strict">
+        <Suspense>{props.children}</Suspense>
+      </main>
+      <Show when={import.meta.env.DEV && state.debugTools}>
+        <Suspense>
+          <DebugBar inline />
+        </Suspense>
+      </Show>
+      <ToastRegion />
+    </div>
   )
 }

packages/app/src/shell/titlebar/right-slot.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createRoot } from "solid-js"
-import { createTitlebarRightSlot } from "./right-slot"
-
-describe("titlebar right slot", () => {
-  test("selects the latest owner and restores the previous owner after overlap", () => {
-    createRoot((dispose) => {
-      const slot = createTitlebarRightSlot()
-      const committed = slot.createRegistration()
-      committed.register()
-      expect(committed.active()).toBe(true)
-
-      const shadow = slot.createRegistration()
-      shadow.register()
-      expect(committed.active()).toBe(false)
-      expect(shadow.active()).toBe(true)
-
-      shadow.unregister()
-      expect(committed.active()).toBe(true)
-      expect(shadow.active()).toBe(false)
-
-      committed.unregister()
-      expect(committed.active()).toBe(false)
-      dispose()
-    })
-  })
-})

packages/app/src/shell/titlebar/right-slot.tsx

@@ -1,65 +0,0 @@
-import { createContext, onCleanup, onMount, Show, useContext, type ParentProps } from "solid-js"
-import { createStore } from "solid-js/store"
-import { Portal } from "solid-js/web"
-
-type Registration = {
-  active: () => boolean
-  register: () => void
-  unregister: () => void
-}
-
-type TitlebarRightSlot = {
-  createRegistration: () => Registration
-  mount: () => HTMLElement | undefined
-  setMount: (mount: HTMLElement) => void
-}
-
-const TitlebarRightContext = createContext<TitlebarRightSlot>()
-
-export function TitlebarRightProvider(props: ParentProps) {
-  return (
-    <TitlebarRightContext.Provider value={createTitlebarRightSlot()}>{props.children}</TitlebarRightContext.Provider>
-  )
-}
-
-export function createTitlebarRightSlot(): TitlebarRightSlot {
-  const [store, setStore] = createStore<{ mount?: HTMLElement; registrations: symbol[] }>({ registrations: [] })
-  return {
-    mount: () => store.mount,
-    setMount: (mount) => setStore("mount", mount),
-    createRegistration() {
-      const id = Symbol()
-      return {
-        active: () => store.registrations.at(-1) === id,
-        register: () => setStore("registrations", (items) => [...items, id]),
-        unregister: () => setStore("registrations", (items) => items.filter((item) => item !== id)),
-      }
-    },
-  }
-}
-
-export function TitlebarRightMount() {
-  const slot = useTitlebarRightSlot()
-  return <div ref={slot.setMount} id="opencode-titlebar-right" class="flex shrink-0 items-center justify-end gap-0" />
-}
-
-export function TitlebarRight(props: ParentProps) {
-  const slot = useTitlebarRightSlot()
-  const registration = slot.createRegistration()
-  onMount(() => {
-    registration.register()
-    onCleanup(registration.unregister)
-  })
-
-  return (
-    <Show when={registration.active() && slot.mount()} keyed>
-      {(mount) => <Portal mount={mount}>{props.children}</Portal>}
-    </Show>
-  )
-}
-
-function useTitlebarRightSlot() {
-  const slot = useContext(TitlebarRightContext)
-  if (!slot) throw new Error("TitlebarRight must be used within TitlebarRightProvider")
-  return slot
-}

packages/app/src/shell/titlebar/titlebar.tsx

@@ -1,4 +1,15 @@
-import { createEffect, createMemo, createResource, Match, createSignal, Show, Switch, untrack } from "solid-js"
+import {
+  createEffect,
+  createMemo,
+  createResource,
+  createSignal,
+  Match,
+  on,
+  onMount,
+  Show,
+  Switch,
+  untrack,
+} from "solid-js"
 import { createStore } from "solid-js/store"
 import { useLocation, useNavigate } from "@solidjs/router"
 import { IconButton } from "@opencode-ai/ui/icon-button"
@@ -23,7 +34,6 @@ import { tabKey, useTabs } from "@/shell/tabs/tabs"
 import type { ComposerState } from "@/composer/persistence"
 import "./titlebar.css"
 import { newTabTooltipKeybind } from "@/shell/commands/tooltip-keybind"
-import { TitlebarRightMount } from "@/shell/titlebar/right-slot"
 
 const titlebarHeight = 36
 const minTitlebarZoom = 0.25
@@ -36,6 +46,15 @@ export type TitlebarUpdate = {
   install: () => void
 }
 
+export function useTitlebarRightMount() {
+  const language = useLanguage()
+  const [mount, setMount] = createSignal<HTMLElement | null>(null)
+  const sync = () => setMount(document.getElementById("opencode-titlebar-right"))
+  onMount(sync)
+  createEffect(on(language.direction, sync, { defer: true }))
+  return mount
+}
+
 export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visible: boolean; toggle: () => void } }) {
   const platform = usePlatform()
   const command = useCommand()
@@ -402,7 +421,7 @@ function TitlebarRight(props: { state: TitlebarRightState }) {
       <Show when={props.state.update.visible}>
         <TitlebarUpdateIconButton state={props.state.update} />
       </Show>
-      <TitlebarRightMount />
+      <div id="opencode-titlebar-right" class="flex shrink-0 items-center justify-end gap-0" />
     </div>
   )
 }

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

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

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

@@ -263,8 +263,6 @@ export type SessionInboxCompaction = {
 
 export type InstructionEntryInfo = { key: InstructionEntryKey; value: JsonValue }
 
-export type InstructionEntrySnapshot = Array<{ key: InstructionEntryKey; value: JsonValue; removed: boolean }>
-
 export type SessionCreated = {
   id: string
   created: number
@@ -326,16 +324,6 @@ 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; idle: number }
-}
-
 export type SessionDeleted = {
   id: string
   created: number
@@ -346,6 +334,16 @@ export type SessionDeleted = {
   data: { sessionID: string }
 }
 
+export type SessionForked = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.forked"
+  durable: { aggregateID: string; seq: number; version: 2 }
+  location?: LocationRef
+  data: { sessionID: string; parentID: string; boundary: SessionForkBoundary; instructions?: { [x: string]: string } }
+}
+
 export type SessionInboxDelivered = {
   id: string
   created: number
@@ -1089,7 +1087,7 @@ export type PtyUpdated = {
   data: { info: Pty }
 }
 
-export type SessionStatusUpdated = {
+export type SessionStatus2 = {
   id: string
   created: number
   metadata?: { [x: string]: any }
@@ -1304,22 +1302,6 @@ export type FormWhen = {
 
 export type ToolContent = ToolTextContent | ToolFileContent
 
-export type SessionForked = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.forked"
-  durable: { aggregateID: string; seq: number; version: 2 }
-  location?: LocationRef
-  data: {
-    sessionID: string
-    parentID: string
-    boundary: SessionForkBoundary
-    instructions?: { [x: string]: string }
-    instructionEntries?: InstructionEntrySnapshot
-  }
-}
-
 export type SessionShellStarted = {
   id: string
   created: number
@@ -1682,8 +1664,7 @@ export type SessionInfo = {
   model?: ModelRef
   cost: MoneyUSD
   tokens: TokenUsageInfo
-  outcome?: "succeeded" | "failed" | "interrupted"
-  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
+  time: { created: number; updated: number; archived?: number }
   title?: string
   location: LocationRef
   subpath?: string
@@ -1968,7 +1949,6 @@ export type SessionEventDurable =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
-  | SessionViewed
   | SessionDeleted
   | SessionForked
   | SessionInboxDelivered
@@ -2054,7 +2034,6 @@ export type V2Event =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
-  | SessionViewed
   | SessionUsageUpdated
   | SessionDeleted
   | SessionForked
@@ -2117,7 +2096,7 @@ export type V2Event =
   | FormReplied
   | FormCancelled
   | WebsearchUpdated
-  | SessionStatusUpdated
+  | SessionStatus2
   | SessionIdle
   | TuiPromptAppend
   | TuiCommandExecute
@@ -2531,14 +2510,7 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly outcome?: "succeeded" | "failed" | "interrupted"
-      readonly time: {
-        readonly created: number
-        readonly updated: number
-        readonly idle?: number
-        readonly viewed?: number
-        readonly archived?: number
-      }
+      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -2806,14 +2778,7 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly outcome?: "succeeded" | "failed" | "interrupted"
-      readonly time: {
-        readonly created: number
-        readonly updated: number
-        readonly idle?: number
-        readonly viewed?: number
-        readonly archived?: number
-      }
+      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -3081,14 +3046,7 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly outcome?: "succeeded" | "failed" | "interrupted"
-      readonly time: {
-        readonly created: number
-        readonly updated: number
-        readonly idle?: number
-        readonly viewed?: number
-        readonly archived?: number
-      }
+      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -4022,13 +3980,6 @@ export type SessionEnvironmentInput = {
 
 export type SessionEnvironmentOutput = void
 
-export type SessionViewInput = {
-  readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly idle: { readonly idle: number }["idle"]
-}
-
-export type SessionViewOutput = void
-
 export type MessageListInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
   readonly limit?: {

packages/client/src/solid/data.ts

@@ -1,7 +1,7 @@
 // Client data layer: apply server events and cache API reads into a Solid store.
-// Prefer straightforward projection. Invalidated reads revalidate serially so an older
-// response cannot commit after its replacement. Reconnect invalidates cached reads;
-// active UI owners decide what to sync again.
+// Prefer straightforward projection. Do not add generation counters, stale-response
+// merges, live/history overlays, or other race machinery here—last write wins.
+// Reconnect invalidates cached reads; active UI owners decide what to sync again.
 
 import type {
   AgentInfo,
@@ -120,46 +120,32 @@ function locationQuery(ref?: LocationRef) {
 }
 
 function createSync() {
-  type Pending = { promise: Promise<void>; invalidated: boolean }
-  const state = new Map<string, true | Pending>()
-  const start = (key: string, load: () => Promise<void>, wait?: Promise<void>) => {
-    const entry: Pending = { promise: Promise.resolve(), invalidated: false }
-    state.set(key, entry)
-    entry.promise = (wait ? wait.catch(() => undefined).then(load) : load())
-      .then(() => {
-        if (state.get(key) === entry) state.set(key, true)
-      })
-      .finally(() => {
-        if (state.get(key) === entry) state.delete(key)
-      })
-    return entry.promise
-  }
+  const state = new Map<string, true | Promise<void>>()
   return {
     run(key: string, load: () => Promise<void>) {
       const active = state.get(key)
       if (active === true) return Promise.resolve()
-      if (!active) return start(key, load)
-      if (!active.invalidated) return active.promise
-      return start(key, load, active.promise)
+      if (active) return active
+      const pending = load()
+        .then(() => {
+          if (state.get(key) === pending) state.set(key, true)
+        })
+        .finally(() => {
+          if (state.get(key) === pending) state.delete(key)
+        })
+      state.set(key, pending)
+      return pending
     },
     complete(key: string) {
       if (state.has(key)) return
       state.set(key, true)
     },
-    has(key: string) {
-      return state.has(key)
-    },
     invalidate(key?: string) {
       if (key) {
-        const active = state.get(key)
-        if (active === true) state.delete(key)
-        if (active !== undefined && active !== true) active.invalidated = true
+        state.delete(key)
         return
       }
-      state.forEach((active, current) => {
-        if (active === true) state.delete(current)
-        if (active !== true) active.invalidated = true
-      })
+      state.clear()
     },
   }
 }
@@ -896,16 +882,6 @@ export function createData(config: CreateDataInput) {
           const currentAssistant = message.activeAssistant(draft)
           if (currentAssistant) currentAssistant.retry = undefined
         })
-        if (event.type === "session.execution.interrupted" && event.data.reason === "shutdown") return
-        // An event can overtake the first read; queue a revalidation when that read is still active.
-        if (!store.session.info[event.data.sessionID] && !sync.has(`session:${event.data.sessionID}`)) return
-        result.session.invalidate(event.data.sessionID)
-        void result.session.sync(event.data.sessionID)
-        return
-      case "session.viewed":
-        if (!store.session.info[event.data.sessionID] && !sync.has(`session:${event.data.sessionID}`)) return
-        result.session.invalidate(event.data.sessionID)
-        void result.session.sync(event.data.sessionID)
         return
       case "session.revert.staged":
         if (store.session.info[event.data.sessionID])

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

@@ -19,8 +19,8 @@ test("effect entrypoint exposes canonical Schema contracts", () => {
 test("generated Effect API names canonical and composed outputs", async () => {
   const source = await Bun.file(new URL("../src/effect/api/api.ts", import.meta.url)).text()
 
-  expect(source).toContain("export type SessionGetOutput = Session.Info")
-  expect(source).toContain("export type EventSubscribeOutput = OpenCodeEvent")
+  expect(source).toContain("export type Endpoint5_5Output = Session.Info")
+  expect(source).toContain("export type Endpoint19_0Output = OpenCodeEvent")
   expect(source).not.toContain("HttpApiClient.ForApi")
 })
 

packages/client/test/effect.test.ts

@@ -136,10 +136,8 @@ 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(
@@ -185,7 +183,6 @@ 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"), idle: session.data.time.idle })
     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"),
@@ -210,11 +207,7 @@ 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)
 
-  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(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
   expect(result.active).toEqual({ ses_test: { type: "running" } })
   expect(Object.getPrototypeOf(result.page.data[0])).toBe(Object.prototype)
   expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
@@ -224,7 +217,6 @@ 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" && logged[0].created).toBe(1_717_171_717_000)
@@ -266,8 +258,6 @@ 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

@@ -524,7 +524,6 @@ 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", idle: session.data.time.idle })
   await client.session.switchAgent({ sessionID: "ses_test", agent: "build" })
   await client.session.switchModel({
     sessionID: "ses_test",
@@ -551,7 +550,6 @@ 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")
@@ -564,7 +562,6 @@ 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"],
@@ -577,9 +574,6 @@ test("session methods use the public HTTP contract", async () => {
     ["POST", "http://localhost:3000/api/session/ses_test/interrupt?continue=true"],
     ["GET", "http://localhost:3000/api/session/ses_test/message/msg_model"],
   ])
-  const viewBody = requests.find((request) => request.url.endsWith("/api/session/ses_test/view"))?.init?.body
-  if (typeof viewBody !== "string") throw new Error("Expected JSON view request body")
-  expect(JSON.parse(viewBody)).toEqual({ idle: session.data.time.idle })
   const body = requests.find((request) => request.url.endsWith("/api/session/ses_test/prompt"))?.init?.body
   if (typeof body !== "string") throw new Error("Expected JSON request body")
   expect(JSON.parse(body)).toEqual({
@@ -642,8 +636,6 @@ 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/solid-data.test.ts

@@ -1,81 +0,0 @@
-import { test } from "bun:test"
-import { createRoot } from "solid-js"
-import { createData, type CreateDataInput } from "../src/solid"
-import { OpenCode, type OpenCodeEvent, type SessionInfo } from "../src/promise"
-
-const session = (viewed: number): SessionInfo => ({
-  id: "ses_refresh",
-  projectID: "project",
-  cost: 0,
-  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  outcome: "succeeded",
-  time: { created: 0, updated: 0, idle: 2, viewed },
-  location: { directory: "/project" },
-})
-
-test("revalidates after an event overtakes an active session read", async () => {
-  let release!: () => void
-  const gate = new Promise<void>((resolve) => (release = resolve))
-  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
-  let requests = 0
-  const api = OpenCode.make({
-    baseUrl: "http://opencode.local",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      if (!request.url.endsWith("/api/session/ses_refresh")) throw new Error(`Unexpected request: ${request.url}`)
-      requests++
-      if (requests === 1) {
-        await gate
-        return Response.json({ data: session(1) })
-      }
-      return Response.json({ data: session(2) })
-    },
-  })
-  const event: CreateDataInput["event"] = {
-    on:
-      <Type extends OpenCodeEvent["type"]>(
-        _type: Type,
-        _handler: (event: Extract<OpenCodeEvent, { type: Type }>) => void,
-      ) =>
-      () => {},
-    listen(handler) {
-      listeners.add(handler)
-      return () => listeners.delete(handler)
-    },
-  }
-  const setup = createRoot((dispose) => ({
-    data: createData({ api: () => api, directory: "/project", event, connection: { status: () => "connected" } }),
-    dispose,
-  }))
-
-  try {
-    setup.data.session.remember(session(1))
-    setup.data.session.invalidate("ses_refresh")
-    const initial = setup.data.session.sync("ses_refresh")
-    await wait(() => requests === 1)
-
-    const viewed: OpenCodeEvent = {
-      id: "evt_viewed",
-      created: 2,
-      type: "session.viewed",
-      durable: { aggregateID: "ses_refresh", seq: 1, version: 1 },
-      data: { sessionID: "ses_refresh", idle: 2 },
-    }
-    listeners.forEach((listener) => listener({ name: viewed.type, details: viewed }))
-    await Bun.sleep(20)
-    release()
-    await initial
-
-    await wait(() => requests === 2 && setup.data.session.get("ses_refresh")?.time.viewed === 2)
-  } finally {
-    setup.dispose()
-  }
-})
-
-async function wait(check: () => boolean) {
-  const started = Date.now()
-  while (!check()) {
-    if (Date.now() - started > 2_000) throw new Error("Timed out waiting for condition")
-    await Bun.sleep(10)
-  }
-}

packages/codemode/src/interpreter/runtime.ts

@@ -841,17 +841,17 @@ export class Interpreter<R> {
 
   private customIterator(value: unknown, node: AstNode, allowAsync = true) {
     if (value instanceof CodeModeGenerator) {
-      if (value.asynchronous && !allowAsync) return Effect.undefined
+      if (value.asynchronous && !allowAsync) return Effect.succeed(undefined)
       return Effect.succeed({
         iterator: value,
         next: new GeneratorMethodReference(value, "next"),
         asynchronous: value.asynchronous,
       })
     }
-    if (!isRecord(value) || isRuntimeReference(value)) return Effect.undefined
+    if (!isRecord(value) || isRuntimeReference(value)) return Effect.succeed(undefined)
     const asyncMethod = allowAsync ? Reflect.get(value, AsyncIteratorSymbol) : undefined
     const method = asyncMethod ?? Reflect.get(value, IteratorSymbol)
-    if (method === undefined || method === null) return Effect.undefined
+    if (method === undefined || method === null) return Effect.succeed(undefined)
     const self = this
     return Effect.map(
       this.invokeCallable(this.requireIteratorMethod(method, "Iterator method", node), [], node),

packages/core/package.json

@@ -118,6 +118,7 @@
     "@opencode-ai/ai": "workspace:*",
     "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",
+    "@opencode-ai/shell-scan": "workspace:*",
     "@opencode-ai/util": "workspace:*",
     "@standard-schema/spec": "catalog:",
     "@parcel/watcher": "2.5.1",

packages/core/schema.json

@@ -1,8 +1,8 @@
 {
   "version": "7",
   "dialect": "sqlite",
-  "id": "3fb67508-0196-4bae-b2bd-c08ece7583fd",
-  "prevIds": ["dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936"],
+  "id": "dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936",
+  "prevIds": ["5c1aa56b-c3ee-4283-9a84-c0bf626dc604"],
   "ddl": [
     {
       "name": "account_state",
@@ -1350,36 +1350,6 @@
       "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": "text",
-      "notNull": false,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "idle_outcome",
-      "entityType": "columns",
-      "table": "session_v2"
-    },
     {
       "type": "integer",
       "notNull": false,

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

@@ -46,7 +46,7 @@ export const Plugin = define({
 
     function firstMissing(target: string): Effect.Effect<string | undefined> {
       const parent = path.dirname(target)
-      if (parent === target) return Effect.undefined
+      if (parent === target) return Effect.succeed(undefined)
       return fs.isDir(parent).pipe(Effect.flatMap((exists) => (exists ? Effect.succeed(target) : firstMissing(parent))))
     }
 

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

@@ -43,7 +43,6 @@ 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/20260819222447_session_viewed_state.js"
 
 export const migrations = [
   m00,
@@ -90,5 +89,4 @@ export const migrations = [
   m41,
   m42,
   m43,
-  m44,
 ] satisfies DatabaseMigration.Migration[]

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

@@ -1,15 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration.js"
-
-const migration: DatabaseMigration.Migration = {
-  id: "20260819222447_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;`)
-      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`idle_outcome\` text;`)
-    })
-  },
-}
-
-export default migration

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

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

packages/core/src/file-mutation.ts

@@ -109,7 +109,7 @@ const layer = Layer.effect(
           const next = Bom.split(input.content)
           const current = yield* environment.files.read(input.target.absolute, { offset: 0, length: 3 }).pipe(
             Effect.map((result) => result.bytes),
-            Effect.catchTag("Environment.NotFound", () => Effect.undefined),
+            Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)),
           )
           yield* environment.files.write(
             input.target.absolute,

packages/core/src/git.ts

@@ -9,6 +9,7 @@ import { AppProcess } from "@opencode-ai/util/process"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { File } from "./file.js"
 import { KeyedMutex } from "./effect/keyed-mutex.js"
+import { gitExecutable } from "./util/git-executable.js"
 
 export class Repository extends Schema.Class<Repository>("Git.Repository")({
   worktree: AbsolutePath,
@@ -314,7 +315,7 @@ const layer = Layer.effect(
     ) {
       const result = yield* proc
         .run(
-          ChildProcess.make("git", repositoryArgs(repository, args), {
+          ChildProcess.make(gitExecutable, repositoryArgs(repository, args), {
             cwd: repository.worktree,
             env: options?.env,
             extendEnv: true,
@@ -449,10 +450,14 @@ const layer = Layer.effect(
       if (!input.paths.length) return new Set<RelativePath>()
       const result = yield* proc
         .run(
-          ChildProcess.make("git", repositoryArgs(input.repository, ["check-ignore", "--no-index", "--stdin", "-z"]), {
-            cwd: input.repository.worktree,
-            extendEnv: true,
-          }),
+          ChildProcess.make(
+            gitExecutable,
+            repositoryArgs(input.repository, ["check-ignore", "--no-index", "--stdin", "-z"]),
+            {
+              cwd: input.repository.worktree,
+              extendEnv: true,
+            },
+          ),
           { stdin: input.paths.join("\0") + "\0" },
         )
         .pipe(
@@ -625,7 +630,7 @@ const layer = Layer.effect(
       cwd = repository.worktree,
     ) {
       const result = yield* proc
-        .run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" }))
+        .run(ChildProcess.make(gitExecutable, args, { cwd, extendEnv: true, stdin: "ignore" }))
         .pipe(
           Effect.mapError(
             (cause) => new WorktreeError({ operation, directory: worktreeDirectory, message: cause.message, cause }),
@@ -722,7 +727,7 @@ function execute(cwd: string, proc: AppProcess.Interface) {
   return (args: string[]) =>
     proc
       .run(
-        ChildProcess.make("git", args, {
+        ChildProcess.make(gitExecutable, args, {
           cwd,
           extendEnv: true,
           stdin: "ignore",

packages/core/src/location-mutation.ts

@@ -78,8 +78,9 @@ const layer = Layer.effect(
           ? "Directory"
           : input.kind === "file"
             ? "File"
-            : (yield* fs.stat(absolute).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.undefined)))
-                ?.type
+            : (yield* fs
+                .stat(absolute)
+                .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined))))?.type
       const externalDirectory = type === "Directory" ? absolute : path.dirname(absolute)
       const externalResource = slash(path.join(externalDirectory, "*"))
       return {

packages/core/src/location-services.ts

@@ -1,5 +1,4 @@
 import { Effect, Layer, LayerMap } from "effect"
-import { existsSync } from "fs"
 import path from "path"
 import { Agent } from "./agent.js"
 import { AISDK } from "./aisdk.js"
@@ -147,7 +146,7 @@ export function buildLocationServiceMap(
             Layer.provide(LayerNode.compile(location.hoisted)),
           )
         },
-        { idleTimeToLive: (ref) => (existsSync(ref.directory) ? "60 minutes" : 0) },
+        { idleTimeToLive: "60 minutes" },
       ),
       (inner) => ({
         ...inner,

packages/core/src/models-dev.ts

@@ -624,11 +624,11 @@ export const layer = (options?: Options) =>
             Effect.map((input) => input as Record<string, SourceProvider>),
             Effect.orElseSucceed(() => undefined),
           )
-        : Effect.undefined
+        : Effect.succeed(undefined)
 
       // The bundled snapshot is the boot-time floor for the catalog; the
       // periodic fetch below still refreshes on top.
-      const loadSnapshot = options?.snapshot === false ? Effect.undefined : bundledSnapshot
+      const loadSnapshot = options?.snapshot === false ? Effect.succeed(undefined) : bundledSnapshot
 
       const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
         const text = yield* fetchApi()

packages/core/src/permission.ts

@@ -302,7 +302,7 @@ const layer = Layer.effect(
           const rememberedRules = yield* savedRules()
           for (const [id, item] of pending) {
             const rules = yield* configured(item.request.sessionID, item.agent).pipe(
-              Effect.catchTag("Session.NotFoundError", () => Effect.undefined),
+              Effect.catchTag("Session.NotFoundError", () => Effect.succeed(undefined)),
             )
             if (!rules) continue
             if (denied(item.request, rules)) continue

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

@@ -46,18 +46,15 @@ function oauth(http: HttpClient.HttpClient) {
       Effect.gen(function* () {
         const server = yield* normalizeServer(answer.server ?? defaultServer)
         const device = yield* post(http, `${server}/auth/device/code`, { client_id: clientID }, Device)
-        const verification = yield* Effect.try({
-          try: () => {
-            const url = new URL(device.verification_uri_complete, `${server}/`)
-            if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("expected HTTP(S)")
-            return url
-          },
-          catch: (cause) =>
-            new Error(`Invalid device verification URL: ${cause instanceof Error ? cause.message : String(cause)}`),
-        })
+        const verification = URL.canParse(device.verification_uri_complete)
+          ? new URL(device.verification_uri_complete)
+          : undefined
+        if (verification && verification.protocol !== "http:" && verification.protocol !== "https:") {
+          return yield* Effect.fail(new Error("Invalid device verification URL: expected HTTP(S)"))
+        }
         return {
           mode: "auto" as const,
-          url: verification.href,
+          url: verification?.href ?? `${server}/${device.verification_uri_complete.replace(/^\/+/, "")}`,
           instructions: `Enter code: ${device.user_code}`,
           callback: poll(http, server, device.device_code, Duration.seconds(device.interval)),
         }
@@ -216,7 +213,7 @@ function fetchProviders(http: HttpClient.HttpClient, value: Credential.Value) {
     )
     .pipe(
       Effect.flatMap((response) => {
-        if (response.status === 404) return Effect.undefined
+        if (response.status === 404) return Effect.succeed(undefined)
         return HttpClientResponse.filterStatusOk(response).pipe(
           Effect.flatMap(HttpClientResponse.schemaBodyJson(RemoteResponse)),
           Effect.map((remote) => remote.config.provider),

packages/core/src/plugin/websearch/mcp.ts

@@ -10,7 +10,7 @@ export const parseResponse = <F extends Schema.Struct.Fields>(body: string, resu
   const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })))
   const parse = (payload: string) => {
     const trimmed = payload.trim()
-    if (!trimmed.startsWith("{")) return Effect.undefined
+    if (!trimmed.startsWith("{")) return Effect.succeed(undefined)
     return decode(trimmed).pipe(Effect.map((response) => response.result))
   }
   return Effect.gen(function* () {

packages/core/src/ripgrep.ts

@@ -235,7 +235,7 @@ const layer = Layer.effect(
               Effect.mapError((cause) => failure("Invalid ripgrep JSON output", cause)),
               Effect.flatMap((json) => {
                 if (!json || typeof json !== "object" || !("type" in json) || json.type !== "match")
-                  return Effect.undefined
+                  return Effect.succeed(undefined)
                 return Schema.decodeUnknownEffect(RawMatch)(json).pipe(
                   Effect.map((match) => ({
                     ...match.data,

packages/core/src/session.ts

@@ -1,7 +1,7 @@
 export * as Session from "./session.js"
 export * from "./session/schema.js"
 
-import { Cause, Effect, Layer, Schema, Context, RcMap, Stream, Scope } from "effect"
+import { Effect, Layer, Schema, Context, RcMap, Stream, Scope } from "effect"
 import { ListAnchor } from "@opencode-ai/schema/session"
 import { and, asc, desc, eq, gt, isNull, like, lt, or, type SQL } from "drizzle-orm"
 import { Project } from "./project.js"
@@ -54,7 +54,6 @@ import { KeyedMutex } from "./effect/keyed-mutex.js"
 import { fileURLToPath } from "url"
 import { SessionEnvironment } from "./session/environment.js"
 import { SessionHistory } from "./session/history.js"
-import { InstructionEntry } from "./session/instruction-entry.js"
 
 // get project -> project.locations
 //
@@ -157,11 +156,6 @@ export class DestinationNotDirectoryError extends Schema.TaggedError<Destination
   "Session.DestinationNotDirectoryError",
   { directory: AbsolutePath },
 ) {}
-
-export class DestinationUnavailableError extends Schema.TaggedError<DestinationUnavailableError>()(
-  "Session.DestinationUnavailableError",
-  { directory: AbsolutePath },
-) {}
 export const MessageNotFoundError = SessionRevert.MessageNotFoundError
 export type MessageNotFoundError = SessionRevert.MessageNotFoundError
 
@@ -178,7 +172,6 @@ export interface Interface {
     readonly sessionID: SessionSchema.ID
     readonly variables?: SessionEnvironment.Variables
   }) => Effect.Effect<SessionEnvironment.Variables | undefined, NotFoundError>
-  readonly view: (input: { sessionID: SessionSchema.ID; idle: number }) => Effect.Effect<void, NotFoundError>
   readonly remove: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
   readonly messages: (input: {
     sessionID: SessionSchema.ID
@@ -225,10 +218,7 @@ export interface Interface {
     directory: AbsolutePath
     workspaceID?: Location.Ref["workspaceID"]
     delivery?: SessionInbox.Delivery
-  }) => Effect.Effect<
-    void,
-    NotFoundError | DestinationNotFoundError | DestinationNotDirectoryError | DestinationUnavailableError
-  >
+  }) => Effect.Effect<void, NotFoundError | DestinationNotFoundError | DestinationNotDirectoryError>
   readonly prompt: (input: {
     id?: SessionMessage.ID
     sessionID: SessionSchema.ID
@@ -438,14 +428,6 @@ const layer = Layer.effect(
           })
         if (!boundary) return yield* new ForkEmptyError({ sessionID: input.sessionID })
         const sessionID = SessionSchema.ID.create()
-        const inherited = yield* db
-          .transaction(() =>
-            Effect.all({
-              instructions: InstructionState.current(db, parent.id),
-              instructionEntries: InstructionEntry.snapshot(db, parent.id),
-            }),
-          )
-          .pipe(Effect.orDie)
         // The fork adopts the parent's newest instruction values rather than the
         // values in effect at the boundary; copied history may contain frozen
         // instruction-update text the initial baseline already reflects.
@@ -453,7 +435,7 @@ const layer = Layer.effect(
           sessionID,
           parentID: parent.id,
           boundary: { ...input.boundary, messageID: boundary.id },
-          ...inherited,
+          instructions: yield* InstructionState.current(db, parent.id),
         })
         return yield* result.get(sessionID).pipe(Effect.orDie)
       }),
@@ -467,18 +449,6 @@ const layer = Layer.effect(
         if (input.variables !== undefined) yield* environments.set(input.sessionID, input.variables)
         return yield* environments.get(input.sessionID)
       }),
-      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 || input.idle > row.idle || (row.viewed !== null && row.viewed >= input.idle))
-          return yield* Effect.void
-        yield* bus.publish(SessionEvent.Viewed, { sessionID: input.sessionID, idle: input.idle })
-      }),
       remove: Effect.fn("Session.remove")(function* (sessionID) {
         const session = yield* result.get(sessionID)
         yield* execution.interrupt(sessionID)
@@ -802,22 +772,12 @@ const layer = Layer.effect(
         if (!info) return yield* new DestinationNotFoundError({ directory })
         if (info.type !== "Directory") return yield* new DestinationNotDirectoryError({ directory })
         const project = yield* projects.resolve(directory)
+        yield* persistProject(project)
         const payload: SessionInbox.MovePayload = {
           location: Location.Ref.make({ directory, workspaceID: input.workspaceID }),
           projectID: project.id,
           subpath: RelativePath.make(path.relative(project.directory, directory).replaceAll("\\", "/")),
         }
-        yield* Location.Service.pipe(
-          Effect.provide(locations.get(payload.location)),
-          Effect.scoped,
-          Effect.catchCause((cause) => {
-            if (Cause.hasInterruptsOnly(cause)) return Effect.failCause(cause)
-            return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(
-              Effect.andThen(Effect.fail(new DestinationUnavailableError({ directory }))),
-            )
-          }),
-        )
-        yield* persistProject(project)
         const item = SessionInbox.Item.make({
           type: "move",
           payload,

packages/core/src/session/info.ts

@@ -50,12 +50,9 @@ export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.In
     }),
     subpath: row.path ? RelativePath.make(row.path) : undefined,
     revert: row.revert ? decodeRevert(row.revert) : undefined,
-    outcome: row.idle_outcome ?? undefined,
     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/instruction-entry.ts

@@ -13,59 +13,9 @@ export const Key = InstructionEntry.Key
 export type Key = typeof Key.Type
 export const Info = InstructionEntry.Info
 export type Info = typeof Info.Type
-export const Snapshot = InstructionEntry.Snapshot
-export type Snapshot = typeof Snapshot.Type
 export const MaxValueBytes = InstructionEntry.MaxValueBytes
 export const ValueTooLargeError = InstructionEntry.ValueTooLargeError
 
-type DatabaseService = Database.Interface["db"]
-const InsertBatchSize = 10
-
-export const snapshot = Effect.fn("InstructionEntry.snapshot")(function* (
-  db: DatabaseService,
-  sessionID: SessionSchema.ID,
-) {
-  return yield* db
-    .select({
-      key: InstructionEntryTable.key,
-      value: InstructionEntryTable.value,
-      removed: InstructionEntryTable.removed,
-    })
-    .from(InstructionEntryTable)
-    .where(eq(InstructionEntryTable.session_id, sessionID))
-    .orderBy(asc(InstructionEntryTable.key))
-    .all()
-    .pipe(Effect.orDie)
-})
-
-export const initialize = Effect.fn("InstructionEntry.initialize")(function* (
-  db: DatabaseService,
-  sessionID: SessionSchema.ID,
-  entries: Snapshot,
-  created: number,
-) {
-  const batches = Array.from({ length: Math.ceil(entries.length / InsertBatchSize) }, (_, index) =>
-    entries.slice(index * InsertBatchSize, (index + 1) * InsertBatchSize),
-  )
-  yield* Effect.forEach(
-    batches,
-    (batch) =>
-      db
-        .insert(InstructionEntryTable)
-        .values(
-          batch.map((entry) => ({
-            ...entry,
-            session_id: sessionID,
-            time_created: created,
-            time_updated: created,
-          })),
-        )
-        .run()
-        .pipe(Effect.orDie),
-    { discard: true },
-  )
-})
-
 export interface Interface {
   readonly list: (sessionID: SessionSchema.ID) => Effect.Effect<ReadonlyArray<Info>>
   readonly put: (input: {

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

@@ -70,7 +70,6 @@ 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) =>
         Effect.gen(function* () {

packages/core/src/session/projector.ts

@@ -15,7 +15,6 @@ import { SessionInbox } from "./inbox.js"
 import { Workspace } from "../workspace.js"
 import { InstructionState } from "./instruction-state.js"
 import { SessionInboxTable, SessionMessageTable, SessionTable } from "./sql.js"
-import { InstructionEntry } from "./instruction-entry.js"
 import { Slug } from "../util/slug.js"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Money } from "@opencode-ai/schema/money"
@@ -172,9 +171,6 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
     .pipe(Effect.orDie)
   if (!stored) return yield* Effect.die(new SessionAlreadyProjected())
 
-  if (event.data.instructionEntries)
-    yield* InstructionEntry.initialize(db, event.data.sessionID, event.data.instructionEntries, event.created)
-
   let cursor = -1
   while (copiedSeq !== undefined) {
     const rows = yield* db
@@ -187,7 +183,6 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
           lt(SessionMessageTable.seq, copiedSeq + 1),
           // Terminal events for active projections stay on the parent, so forks copy only settled history.
           sql`${SessionMessageTable.type} != 'assistant' or json_extract(${SessionMessageTable.data}, '$.time.completed') is not null`,
-          sql`${SessionMessageTable.type} != 'shell' or json_extract(${SessionMessageTable.data}, '$.status') != 'running'`,
           sql`${SessionMessageTable.type} != 'compaction' or json_extract(${SessionMessageTable.data}, '$.status') != 'running'`,
         ),
       )
@@ -201,7 +196,7 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
       .insert(SessionMessageTable)
       .values(
         rows.map((row) => ({
-          id: SessionMessage.ID.make(`${SessionMessage.ID.fromEvent(event.id)}_${row.seq}`),
+          id: SessionMessage.ID.create(),
           session_id: event.data.sessionID,
           type: row.type,
           seq: row.seq,
@@ -395,37 +390,6 @@ 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
-    const outcome =
-      event.type === SessionEvent.Execution.Succeeded.type
-        ? "succeeded"
-        : event.type === SessionEvent.Execution.Failed.type
-          ? "failed"
-          : "interrupted"
-    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}))`,
-        idle_outcome: outcome,
-        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
@@ -547,20 +511,6 @@ const layer = Layer.effectDiscard(
         .run()
         .pipe(Effect.orDie),
     )
-    yield* bus.project(SessionEvent.Viewed, (event) => {
-      const idle = event.data.idle
-      return db
-        .update(SessionTable)
-        .set({
-          // Monotone watermark: a duplicate or stale view never regresses, and a terminal event
-          // committing after the viewer's observation keeps the newer idle transition unread.
-          time_viewed: sql`max(${idle}, coalesce(${SessionTable.time_viewed}, ${idle}))`,
-          time_updated: sql`${SessionTable.time_updated}`,
-        })
-        .where(eq(SessionTable.id, event.data.sessionID))
-        .run()
-        .pipe(Effect.orDie)
-    })
     yield* bus.project(SessionEvent.UsageRecorded, (event) => applyUsage(db, event.data.sessionID, event.data))
     yield* bus.project(SessionEvent.Forked, (event) => projectFork(db, event))
     yield* bus.project(SessionEvent.InboxDelivered, (event) =>
@@ -625,9 +575,9 @@ const layer = Layer.effectDiscard(
         delivery: event.data.delivery,
       }),
     )
-    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.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.InstructionsUpdated, (event) =>
       Effect.gen(function* () {
         yield* run(db, event)

packages/core/src/session/sql.ts

@@ -57,9 +57,6 @@ export const SessionTable = sqliteTable(
       variant?: string
     }>(),
     ...Timestamps,
-    time_idle: integer(),
-    time_viewed: integer(),
-    idle_outcome: text().$type<NonNullable<Session.Info["outcome"]>>(),
     time_compacting: integer(),
     time_archived: integer(),
     /** The execution claim timestamp (historical column name; see SessionStore.claim). */

packages/core/src/session/transfer.ts

@@ -53,7 +53,7 @@ const layer = Layer.effect(
       export: Effect.fn("SessionTransfer.export")(function* (input) {
         const data = {
           info: yield* sessions.get(input.sessionID),
-          messages: (yield* sessions.messages({ sessionID: input.sessionID, order: "asc" })).filter(isSettled),
+          messages: yield* sessions.messages({ sessionID: input.sessionID, order: "asc" }),
         }
         return input.sanitize ? sanitize(data) : data
       }),
@@ -68,7 +68,7 @@ const layer = Layer.effect(
         if (recorded) return yield* new ImportConflictError({ sessionID })
         const project = yield* projects.resolve(input.location.directory)
         yield* upsertProject(db, project).pipe(Effect.orDie)
-        const messages = input.data.messages.filter(isSettled).map((message, index) => {
+        const messages = input.data.messages.map((message, index) => {
           const encoded = encodeMessage(message)
           const { id: _, type, ...data } = encoded
           return {
@@ -115,15 +115,6 @@ 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.idle && input.data.info.time.viewed
-                          ? Math.min(
-                              DateTime.toEpochMillis(input.data.info.time.idle),
-                              DateTime.toEpochMillis(input.data.info.time.viewed),
-                            )
-                          : null,
-                      idle_outcome: input.data.info.time.idle ? (input.data.info.outcome ?? null) : null,
                       time_archived: input.data.info.time.archived
                         ? DateTime.toEpochMillis(input.data.info.time.archived)
                         : null,
@@ -153,12 +144,6 @@ export const node = makeGlobalNode({
   deps: [App.node, Bus.node, Database.node, Project.node, Session.node],
 })
 
-function isSettled(message: SessionMessage.Info) {
-  if (message.type === "assistant") return message.time.completed !== undefined
-  if (message.type === "shell" || message.type === "compaction") return message.status !== "running"
-  return true
-}
-
 function redact(kind: string, id: string, value: string) {
   return value.trim() ? `[redacted:${kind}:${id}]` : value
 }

packages/core/src/shell/parse.ts

@@ -198,7 +198,7 @@ const scanLegacy = Effect.fnUntraced(function* (command: string, shell: string,
 })
 
 async function scanPortable(command: string, shell: string, cwd: string) {
-  const { ShellScan } = await import("./scan.js")
+  const { ShellScan } = await import("@opencode-ai/shell-scan")
   const powershell = ShellSelect.ps(shell)
   const result = powershell ? ShellScan.scanPowerShell(command) : ShellScan.scan(command)
   if (result.kind === "opaque") return { commands: [{ resource: command, save: command }], directories: [] }

packages/core/src/snapshot.ts

@@ -201,7 +201,7 @@ export const noopLayer = Layer.succeed(
   Service.of({
     transform: () => Effect.succeed({ dispose: Effect.void }),
     reload: () => Effect.void,
-    capture: () => Effect.undefined,
+    capture: () => Effect.succeed(undefined),
     files: () => Effect.succeed([]),
     diff: () => Effect.succeed([]),
     restore: () => Effect.void,

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

@@ -78,7 +78,7 @@ export const Plugin = {
                   source,
                 })
               const current = yield* FileMutation.readText(environment.files, target.absolute).pipe(
-                Effect.catchTag("Environment.NotFound", () => Effect.undefined),
+                Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)),
               )
               const next = Bom.split(input.content)
               const preview = fileDiff(target.resource, current?.text ?? "", next.text, current ? "modified" : "added")

packages/core/src/util/git-executable.ts

@@ -0,0 +1,6 @@
+import path from "path"
+import { which } from "./which.js"
+
+const resolved = process.platform === "win32" ? which("git") : undefined
+
+export const gitExecutable = resolved ? path.resolve(resolved) : "git"

packages/core/src/vcs/git.ts

@@ -8,6 +8,7 @@ import { AppProcess } from "@opencode-ai/util/process"
 import type { DiffOptions, Interface } from "../vcs.js"
 import { chunksByFile, emptyPatch, MAX_PATCH_BYTES, MAX_TOTAL_PATCH_BYTES, PATCH_CONTEXT_LINES } from "./patch.js"
 import type { Patch } from "./patch.js"
+import { gitExecutable } from "../util/git-executable.js"
 
 /**
  * Git adapter for the Vcs service. Ported from the V1 pipeline: patches are
@@ -128,7 +129,7 @@ function makeGit(proc: AppProcess.Interface) {
   const run = Effect.fnUntraced(
     function* (args: string[], opts: { cwd: string; maxOutputBytes?: number }) {
       const result = yield* proc.run(
-        ChildProcess.make("git", [...cfg, ...args], {
+        ChildProcess.make(gitExecutable, [...cfg, ...args], {
           cwd: opts.cwd,
           extendEnv: true,
           stdin: "ignore",

packages/core/src/worktree/git.ts

@@ -31,7 +31,7 @@ export const make = Effect.gen(function* () {
       return yield* Effect.forEach(entries, (entry) =>
         canonical(fs, entry.directory).pipe(
           Effect.map((directory) => ({ directory, type: entry.kind === "main" ? "root" : "worktree" }) as const),
-          Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined),
+          Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed(undefined)),
         ),
       ).pipe(Effect.map((items) => items.filter((item): item is ListEntry => item !== undefined)))
     }),

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

@@ -17,7 +17,6 @@ import previousV2Migration from "@opencode-ai/core/database/migration/2026080423
 import workspaceMigration from "@opencode-ai/core/database/migration/20260808023530_workspace_domain"
 import executionClaimsMigration from "@opencode-ai/core/database/migration/20260811161259_execution_claim_attempts"
 import sessionInboxMigration from "@opencode-ai/core/database/migration/20260812181746_session_inbox"
-import sessionViewedStateMigration from "@opencode-ai/core/database/migration/20260819222447_session_viewed_state"
 import { Global } from "@opencode-ai/util/global"
 
 const run = <A, E>(
@@ -78,28 +77,6 @@ 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, idle_outcome FROM session_v2`)).toEqual({
-          id: "ses_existing",
-          title: "Existing",
-          time_idle: null,
-          time_viewed: null,
-          idle_outcome: 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/fixture/config-nodes.ts

@@ -10,7 +10,7 @@ export const emptyCredentialNode = makeGlobalNode({
     Credential.Service.of({
       all: () => Effect.succeed([]),
       list: () => Effect.succeed([]),
-      get: () => Effect.undefined,
+      get: () => Effect.succeed(undefined),
       create: () => Effect.die("unused Credential.create"),
       update: () => Effect.die("unused Credential.update"),
       remove: () => Effect.die("unused Credential.remove"),

packages/core/test/fixture/mcp.ts

@@ -19,9 +19,9 @@ export const emptyMcpLayer = Layer.succeed(
     callTool: () => Effect.die("unused mcp.callTool"),
     instructions: () => Effect.succeed([]),
     prompts: () => Effect.succeed([]),
-    prompt: () => Effect.undefined,
+    prompt: () => Effect.succeed(undefined),
     resourceCatalog: () => Effect.succeed(MCP.ResourceCatalog.make({ resources: [], templates: [] })),
-    readResource: () => Effect.undefined,
+    readResource: () => Effect.succeed(undefined),
   }),
 )
 

packages/core/test/generate.test.ts

@@ -21,7 +21,7 @@ const runtime = LanguageModel.make({ id: "gemini", provider: "test-provider", ro
 
 const catalog = Layer.mock(Catalog.Service, {
   provider: {
-    get: () => Effect.undefined,
+    get: () => Effect.succeed(undefined),
     all: () => Effect.die("unused"),
     available: () => Effect.die("unused"),
   },
@@ -35,7 +35,7 @@ const catalog = Layer.mock(Catalog.Service, {
 })
 const integrations = Layer.mock(Integration.Service, {
   connection: {
-    active: () => Effect.undefined,
+    active: () => Effect.succeed(undefined),
     resolve: () => Effect.die("unused"),
     key: () => Effect.die("unused"),
     update: () => Effect.die("unused"),

packages/core/test/instruction-discovery.test.ts

@@ -405,7 +405,7 @@ describe("ConfigInstructionPlugin.Plugin", () => {
           FSUtil.Service.of({
             ...fs,
             up: () => Effect.succeed([discovered]),
-            readFileStringSafe: () => Effect.undefined,
+            readFileStringSafe: () => Effect.succeed(undefined),
           }),
         ),
       ),

packages/core/test/integration.test.ts

@@ -17,7 +17,7 @@ const failingCredentialNode = makeGlobalNode({
     Credential.Service.of({
       all: () => Effect.succeed([]),
       list: () => Effect.succeed([]),
-      get: () => Effect.undefined,
+      get: () => Effect.succeed(undefined),
       create: () => Effect.die(new Error("credential persistence failed")),
       update: () => Effect.void,
       remove: () => Effect.void,

packages/core/test/location-layer.test.ts

@@ -43,28 +43,6 @@ const itWithSdk = testEffect(
 )
 
 describe("LocationServiceMap", () => {
-  it.live("retries a location after its missing directory is recreated", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((dir) =>
-        Effect.gen(function* () {
-          const locations = yield* LocationServiceMap.Service
-          const directory = path.join(dir.path, "recreated")
-          const ref = Location.Ref.make({ directory: AbsolutePath.make(directory) })
-
-          const first = yield* Location.Service.pipe(Effect.provide(locations.get(ref)), Effect.scoped, Effect.exit)
-          expect(first._tag).toBe("Failure")
-
-          yield* Effect.promise(() => fs.mkdir(directory))
-          const location = yield* Location.Service.pipe(Effect.provide(locations.get(ref)), Effect.scoped)
-          expect(location.directory).toBe(ref.directory)
-        }),
-      ),
-    ),
-  )
-
   itWithSdk.live("preserves embedded SDK plugins after Location eviction", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),

packages/core/test/model-resolver.test.ts

@@ -309,7 +309,7 @@ describe("ModelResolver", () => {
     })
     const integrations = Layer.mock(Integration.Service, {
       connection: {
-        active: () => Effect.undefined,
+        active: () => Effect.succeed(undefined),
         resolve: () => Effect.die("unused"),
         key: () => Effect.die("unused"),
         update: () => Effect.die("unused"),

packages/core/test/plugin/fixture.ts

@@ -33,7 +33,7 @@ const npmLayer = Layer.succeed(
   Npm.Service.of({
     add: () => Effect.succeed({ directory: "", entrypoint: undefined }),
     resolve: () => Effect.succeed({ directory: "", entrypoint: undefined }),
-    which: () => Effect.undefined,
+    which: () => Effect.succeed(undefined),
   }),
 )
 

packages/core/test/plugin/provider-dynamic.test.ts

@@ -24,7 +24,7 @@ function npmEntrypoint(entrypoint?: string) {
   return Npm.Service.of({
     add: () => Effect.succeed({ directory: "", entrypoint }),
     resolve: () => Effect.succeed({ directory: "", entrypoint }),
-    which: () => Effect.undefined,
+    which: () => Effect.succeed(undefined),
   })
 }
 

packages/core/test/plugin/provider-opencode.test.ts

@@ -105,7 +105,7 @@ describe("OpencodePlugin", () => {
               return Response.json({
                 device_code: "device",
                 user_code: "user",
-                verification_uri_complete: "/console/device?user_code=user&client_id=opencode-cli",
+                verification_uri_complete: `${url.origin}/verify`,
                 expires_in: 60,
                 interval: 0,
               })
@@ -130,7 +130,7 @@ describe("OpencodePlugin", () => {
             methodID: Integration.MethodID.make("device"),
             answer: { server: `${server.url.origin}/console///?ignored=true#ignored` },
           })
-          expect(attempt.url).toBe(`${server.url.origin}/console/device?user_code=user&client_id=opencode-cli`)
+          expect(attempt.url).toBe(`${server.url.origin}/verify`)
           yield* eventually(
             integrations.oauth.status({ integrationID, attemptID: attempt.attemptID }),
             (status) => status.status === "complete",
@@ -148,38 +148,6 @@ describe("OpencodePlugin", () => {
     ),
   )
 
-  it.live("rejects malformed device verification URLs", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() =>
-        Bun.serve({
-          port: 0,
-          fetch: () =>
-            Response.json({
-              device_code: "device",
-              user_code: "user",
-              verification_uri_complete: "http://[::1",
-              expires_in: 60,
-              interval: 0,
-            }),
-        }),
-      ),
-      (server) =>
-        Effect.gen(function* () {
-          yield* addPlugin()
-          const error = yield* (yield* Integration.Service).oauth
-            .connect({
-              integrationID: Integration.ID.make("opencode"),
-              methodID: Integration.MethodID.make("device"),
-              answer: { server: server.url.origin },
-            })
-            .pipe(Effect.flip)
-          expect(error).toBeInstanceOf(Integration.AuthorizationError)
-          expect(String(error.cause)).toContain("Invalid device verification URL")
-        }),
-      (server) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
   it.effect("rejects non-HTTP OpenCode servers", () =>
     Effect.gen(function* () {
       yield* addPlugin()

packages/core/test/plugin/provider-sap-ai-core.test.ts

@@ -15,7 +15,7 @@ const it = testEffect(PluginTestLayer)
 const npm = Npm.Service.of({
   add: () => Effect.succeed({ directory: "", entrypoint: undefined }),
   resolve: () => Effect.succeed({ directory: "", entrypoint: undefined }),
-  which: () => Effect.undefined,
+  which: () => Effect.succeed(undefined),
 })
 
 const addPlugin = Effect.fn(function* () {

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

@@ -4,7 +4,6 @@ import fs from "fs/promises"
 import path from "path"
 import { DateTime, Effect, Layer, Stream } from "effect"
 import { Money } from "@opencode-ai/schema/money"
-import { Shell } from "@opencode-ai/schema/shell"
 import { Agent } from "@opencode-ai/core/agent"
 import { asc, eq } from "drizzle-orm"
 import { Database } from "@opencode-ai/core/database/database"
@@ -13,7 +12,6 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Hash } from "@opencode-ai/util/hash"
 import { Bus } from "@opencode-ai/core/bus"
 import { EventTable } from "@opencode-ai/core/event/sql"
-import { Instructions } from "@opencode-ai/core/instructions/index"
 import { Location } from "@opencode-ai/core/location"
 import { Model } from "@opencode-ai/core/model"
 import { Project } from "@opencode-ai/core/project"
@@ -25,7 +23,6 @@ import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionInbox } from "@opencode-ai/core/session/inbox"
-import { InstructionEntry } from "@opencode-ai/core/session/instruction-entry"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
@@ -44,7 +41,6 @@ const it = testEffect(
       SessionStore.node,
       Session.node,
       SessionTransfer.node,
-      InstructionEntry.node,
     ]),
     [
       [Bus.node, Bus.configured({ persist: true })],
@@ -405,95 +401,6 @@ describe("Session.create", () => {
     }),
   )
 
-  it.effect("replays a fork with stable projected identities", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const parent = yield* session.create({ location, title: "Parent" })
-      yield* session.prompt({ sessionID: parent.id, text: "First", resume: false })
-      yield* SessionInbox.promote(db, bus, parent.id, "steer")
-      yield* session.synthetic({ sessionID: parent.id, text: "Second", resume: false })
-      yield* SessionInbox.promote(db, bus, parent.id, "steer")
-      const forked = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })
-      const original = (yield* session.context(forked.id)).map((message) => message.id)
-      const recorded = yield* db
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, forked.id))
-        .get()
-        .pipe(Effect.orDie)
-      if (!recorded) return yield* Effect.die(new Error("Fork event not found"))
-
-      yield* bus.remove(forked.id)
-      yield* db.delete(SessionTable).where(eq(SessionTable.id, forked.id)).run().pipe(Effect.orDie)
-      yield* bus.replay({
-        id: recorded.id,
-        created: recorded.created,
-        aggregateID: recorded.aggregate_id,
-        seq: recorded.seq,
-        type: recorded.type,
-        data: recorded.data,
-      })
-
-      expect((yield* session.context(forked.id)).map((message) => message.id)).toEqual(original)
-    }),
-  )
-
-  it.effect("inherits instruction entries when forking", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const entries = yield* InstructionEntry.Service
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const parent = yield* session.create({ location })
-      yield* session.prompt({ sessionID: parent.id, text: "Fork context", resume: false })
-      yield* SessionInbox.promote(db, bus, parent.id, "steer")
-      yield* entries.put({ sessionID: parent.id, key: "deploy-target", value: "production" })
-      yield* entries.put({ sessionID: parent.id, key: "retired", value: true })
-      yield* entries.remove({ sessionID: parent.id, key: "retired" })
-      yield* Effect.forEach(
-        Array.from({ length: 20 }, (_, index) => index),
-        (index) => entries.put({ sessionID: parent.id, key: `entry-${String(index).padStart(2, "0")}`, value: index }),
-        { discard: true },
-      )
-
-      const forked = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })
-      const inheritedList = yield* entries.list(forked.id)
-      const inheritedValues = yield* entries.load(forked.id).pipe(Effect.flatMap(Instructions.read))
-
-      expect(inheritedList).toHaveLength(21)
-      expect(inheritedList).toContainEqual({ key: "deploy-target", value: "production" })
-      expect(inheritedValues).toContainEqual({
-        key: Instructions.Key.make("api/retired"),
-        value: Instructions.removed,
-      })
-
-      const recorded = yield* db
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, forked.id))
-        .get()
-        .pipe(Effect.orDie)
-      if (!recorded) return yield* Effect.die(new Error("Fork event not found"))
-      yield* entries.put({ sessionID: parent.id, key: "deploy-target", value: "staging" })
-      yield* entries.put({ sessionID: parent.id, key: "new-parent-entry", value: true })
-      yield* bus.remove(forked.id)
-      yield* db.delete(SessionTable).where(eq(SessionTable.id, forked.id)).run().pipe(Effect.orDie)
-      yield* bus.replay({
-        id: recorded.id,
-        created: recorded.created,
-        aggregateID: recorded.aggregate_id,
-        seq: recorded.seq,
-        type: recorded.type,
-        data: recorded.data,
-      })
-
-      expect(yield* entries.list(forked.id)).toEqual(inheritedList)
-      expect(yield* entries.load(forked.id).pipe(Effect.flatMap(Instructions.read))).toEqual(inheritedValues)
-    }),
-  )
-
   it.effect("does not copy a running assistant into a fork", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
@@ -544,49 +451,6 @@ describe("Session.create", () => {
     }),
   )
 
-  it.effect("copies only settled shell messages into forks", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const parent = yield* session.create({ location })
-      yield* session.prompt({ sessionID: parent.id, text: "Run a shell", resume: false })
-      yield* SessionInbox.promote(db, bus, parent.id, "steer")
-      const shell = Shell.Info.make({
-        id: Shell.ID.make("sh_fork_running"),
-        status: "running",
-        command: "sleep 10",
-        cwd: location.directory,
-        shell: "/bin/sh",
-        file: "/tmp/sh_fork_running.out",
-        metadata: {},
-        time: { started: 0 },
-      })
-      yield* bus.publish(SessionEvent.Shell.Started, { sessionID: parent.id, shell })
-
-      const running = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })
-
-      expect(yield* session.context(parent.id)).toMatchObject([
-        { type: "user", text: "Run a shell" },
-        { type: "shell", command: "sleep 10", status: "running" },
-      ])
-      expect(yield* session.context(running.id)).toMatchObject([{ type: "user", text: "Run a shell" }])
-
-      yield* bus.publish(SessionEvent.Shell.Ended, {
-        sessionID: parent.id,
-        shell: { ...shell, status: "exited", exit: 0, time: { started: 0, completed: 1 } },
-        output: { output: "complete", cursor: 8, size: 8, truncated: false },
-      })
-      const completed = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })
-
-      expect(yield* session.context(running.id)).toMatchObject([{ type: "user", text: "Run a shell" }])
-      expect(yield* session.context(completed.id)).toMatchObject([
-        { type: "user", text: "Run a shell" },
-        { type: "shell", command: "sleep 10", status: "exited", output: { output: "complete" } },
-      ])
-    }),
-  )
-
   it.effect("rejects forking an empty session", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
@@ -1023,134 +887,6 @@ describe("Session.create", () => {
 })
 
 describe("SessionTransfer", () => {
-  it.effect("exports only settled projected messages", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const transfer = yield* SessionTransfer.Service
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const source = yield* session.create({ location })
-      yield* session.prompt({ sessionID: source.id, text: "Settled", resume: false })
-      yield* SessionInbox.promote(db, bus, source.id, "steer")
-      yield* bus.publish(SessionEvent.Step.Started, {
-        sessionID: source.id,
-        assistantMessageID: SessionMessage.ID.create(),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ id: Model.ID.make("model"), providerID: Provider.ID.make("provider") }),
-      })
-      yield* bus.publish(SessionEvent.Shell.Started, {
-        sessionID: source.id,
-        shell: Shell.Info.make({
-          id: Shell.ID.make("sh_transfer_export"),
-          status: "running",
-          command: "sleep 10",
-          cwd: location.directory,
-          shell: "/bin/sh",
-          file: "/tmp/sh_transfer_export.out",
-          metadata: {},
-          time: { started: 0 },
-        }),
-      })
-      yield* bus.publish(SessionEvent.Compaction.Started, {
-        sessionID: source.id,
-        reason: "manual",
-        recent: "pending",
-      })
-
-      expect((yield* transfer.export({ sessionID: source.id })).messages).toMatchObject([
-        { type: "user", text: "Settled" },
-      ])
-    }),
-  )
-
-  it.effect("imports only settled projected messages", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const transfer = yield* SessionTransfer.Service
-      const { db } = yield* Database.Service
-      const template = yield* session.create({ location, title: "Transfer source" })
-      const sessionID = Session.ID.create()
-      const userID = SessionMessage.ID.create()
-      const runningAssistantID = SessionMessage.ID.create()
-      const completedAssistantID = SessionMessage.ID.create()
-      const runningShellID = SessionMessage.ID.create()
-      const completedShellID = SessionMessage.ID.create()
-      const runningCompactionID = SessionMessage.ID.create()
-      const completedCompactionID = SessionMessage.ID.create()
-      const model = Model.Ref.make({ id: Model.ID.make("model"), providerID: Provider.ID.make("provider") })
-
-      yield* transfer.import({
-        data: {
-          info: { ...template, id: sessionID },
-          messages: [
-            { id: userID, type: "user", text: "Settled", time: { created: DateTime.makeUnsafe(1) } },
-            {
-              id: runningAssistantID,
-              type: "assistant",
-              agent: Agent.ID.make("build"),
-              model,
-              content: [],
-              time: { created: DateTime.makeUnsafe(2) },
-            },
-            {
-              id: completedAssistantID,
-              type: "assistant",
-              agent: Agent.ID.make("build"),
-              model,
-              content: [],
-              time: { created: DateTime.makeUnsafe(3), completed: DateTime.makeUnsafe(4) },
-            },
-            {
-              id: runningShellID,
-              type: "shell",
-              shellID: Shell.ID.make("sh_transfer_running"),
-              command: "sleep 10",
-              status: "running",
-              time: { created: DateTime.makeUnsafe(5) },
-            },
-            {
-              id: completedShellID,
-              type: "shell",
-              shellID: Shell.ID.make("sh_transfer_completed"),
-              command: "pwd",
-              status: "exited",
-              exit: 0,
-              output: { output: "/project", cursor: 8, size: 8, truncated: false },
-              time: { created: DateTime.makeUnsafe(6), completed: DateTime.makeUnsafe(7) },
-            },
-            {
-              id: runningCompactionID,
-              type: "compaction",
-              status: "running",
-              reason: "manual",
-              summary: "pending",
-              recent: "pending",
-              time: { created: DateTime.makeUnsafe(8) },
-            },
-            {
-              id: completedCompactionID,
-              type: "compaction",
-              status: "completed",
-              reason: "manual",
-              summary: "summary",
-              recent: "recent",
-              time: { created: DateTime.makeUnsafe(9) },
-            },
-          ],
-        },
-        location,
-      })
-
-      expect((yield* session.messages({ sessionID, order: "asc" })).map((message) => message.id)).toEqual([
-        userID,
-        completedAssistantID,
-        completedShellID,
-        completedCompactionID,
-      ])
-      expect(yield* Bus.latestSequence(db, sessionID)).toBe(4)
-    }),
-  )
-
   it.effect("imports projected messages and reserves their aggregate sequence", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
@@ -1164,15 +900,7 @@ describe("SessionTransfer", () => {
 
       const imported = yield* transfer.import({
         data: {
-          info: {
-            ...template,
-            id: sessionID,
-            time: {
-              ...template.time,
-              idle: DateTime.makeUnsafe(200),
-              viewed: DateTime.makeUnsafe(150),
-            },
-          },
+          info: { ...template, id: sessionID },
           messages: [
             {
               id: sourceMessageID,
@@ -1195,18 +923,13 @@ 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)
-      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([
+      expect((yield* transfer.export({ sessionID })).messages).toEqual(messages)
+      expect((yield* transfer.export({ sessionID, sanitize: true })).messages).toMatchObject([
         { id: sourceMessageID, text: `[redacted:text:${sourceMessageID}]` },
         { id: errorMessageID, error: { type: "test_error", message: "Original error" } },
       ])
@@ -1235,31 +958,4 @@ describe("SessionTransfer", () => {
       expect(yield* session.messages({ sessionID: existing.id })).toEqual([])
     }),
   )
-
-  it.effect("clamps an imported viewed watermark to its idle transition", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const transfer = yield* SessionTransfer.Service
-      const template = yield* session.create({ location })
-      const imported = yield* transfer.import({
-        data: {
-          info: {
-            ...template,
-            id: Session.ID.create(),
-            outcome: "succeeded",
-            time: {
-              ...template.time,
-              idle: DateTime.makeUnsafe(200),
-              viewed: DateTime.makeUnsafe(250),
-            },
-          },
-          messages: [],
-        },
-        location,
-      })
-
-      expect(imported.time).toMatchObject({ idle: DateTime.makeUnsafe(200), viewed: DateTime.makeUnsafe(200) })
-      expect(imported.outcome).toBe("succeeded")
-    }),
-  )
 })

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

@@ -1,14 +1,12 @@
 import { describe, expect } from "bun:test"
 import path from "path"
 import { mkdir, rm } from "fs/promises"
-import { Effect, Layer, LayerMap } from "effect"
+import { Effect } from "effect"
 import { Worktree } from "@opencode-ai/schema/worktree"
 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 { Location } from "@opencode-ai/core/location"
-import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
-import type { LocationServices } from "@opencode-ai/core/location-services"
 import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
@@ -30,47 +28,8 @@ const it = testEffect(
     ],
   ),
 )
-const unavailableLocations = Layer.effect(
-  LocationServiceMap.Service,
-  LayerMap.make(
-    () => Layer.effectDiscard(Effect.fail(new Error("broken location"))) as unknown as Layer.Layer<LocationServices>,
-  ),
-)
-const itWithUnavailableDestination = testEffect(
-  AppNodeBuilder.build(
-    LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
-    [
-      [Project.node, globalProjectLayer],
-      [SessionExecution.node, SessionExecution.noopLayer],
-      [LocationServiceMap.node, unavailableLocations],
-    ],
-  ),
-)
 
 describe("Session.move", () => {
-  itWithUnavailableDestination.effect("rejects an unavailable destination before admitting the move", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const session = yield* Session.Service
-          const source = AbsolutePath.make(path.join(tmp.path, "source"))
-          const destination = AbsolutePath.make(path.join(tmp.path, "destination"))
-          yield* Effect.promise(() => Promise.all([mkdir(source), mkdir(destination)]))
-          const created = yield* session.create({ location: Location.Ref.make({ directory: source }) })
-
-          const error = yield* session.move({ sessionID: created.id, directory: destination }).pipe(Effect.flip)
-
-          expect(error).toEqual(new Session.DestinationUnavailableError({ directory: destination }))
-          expect((yield* session.get(created.id)).location.directory).toBe(source)
-          expect(yield* session.inbox(created.id)).toEqual([])
-        }),
-      ),
-    ),
-  )
-
   it.effect("applies a move immediately when the source directory no longer exists", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),

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

@@ -74,7 +74,7 @@ const locations = Layer.effect(
             }),
             Layer.mock(Snapshot.Service, {
               capture: () =>
-                ready ? Effect.undefined : Effect.die(new Error("Snapshot used before plugins were ready")),
+                ready ? Effect.succeed(undefined) : Effect.die(new Error("Snapshot used before plugins were ready")),
               restore: () =>
                 ready ? Effect.void : Effect.die(new Error("Snapshot used before plugins were ready")),
             }),

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

@@ -88,16 +88,16 @@ const config = Config.testLayer()
 const pluginSupervisor = Layer.succeed(PluginSupervisor.Service, PluginSupervisor.Service.of({ flush: Effect.void }))
 const promptCatalog = Layer.mock(Catalog.Service, {
   provider: {
-    get: () => Effect.undefined,
+    get: () => Effect.succeed(undefined),
     all: () => Effect.succeed([]),
     available: () => Effect.succeed([]),
   },
   model: {
-    get: () => Effect.undefined,
+    get: () => Effect.succeed(undefined),
     all: () => Effect.succeed([]),
     available: () => Effect.succeed([]),
-    default: () => Effect.undefined,
-    small: () => Effect.undefined,
+    default: () => Effect.succeed(undefined),
+    small: () => Effect.succeed(undefined),
   },
 })
 const runnerLayer = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>

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

@@ -378,16 +378,16 @@ const pluginSupervisor = Layer.succeed(
 )
 const promptCatalog = Layer.mock(Catalog.Service, {
   provider: {
-    get: () => Effect.undefined,
+    get: () => Effect.succeed(undefined),
     all: () => Effect.succeed([]),
     available: () => Effect.succeed([]),
   },
   model: {
-    get: () => Effect.undefined,
+    get: () => Effect.succeed(undefined),
     all: () => Effect.succeed([]),
     available: () => Effect.succeed([]),
-    default: () => Effect.undefined,
-    small: () => Effect.undefined,
+    default: () => Effect.succeed(undefined),
+    small: () => Effect.succeed(undefined),
   },
 })
 const runnerLayer = AppNodeBuilder.build(SessionRunnerLLM.node, [

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

@@ -1,216 +0,0 @@
-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()
-      expect(created.outcome).toBeUndefined()
-
-      yield* session.view({ sessionID: created.id, idle: 0 })
-      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)
-      expect(idle.outcome).toBe("succeeded")
-
-      if (!idle.time.idle) return yield* Effect.die(new Error("Expected idle time"))
-      yield* session.view({ sessionID: created.id, idle: DateTime.toEpochMillis(idle.time.idle) })
-      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, idle: DateTime.toEpochMillis(viewed.time.idle) })
-      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))
-      expect(unread.outcome).toBe("failed")
-
-      yield* session.view({ sessionID: created.id, idle: DateTime.toEpochMillis(unread.time.idle) })
-      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)
-      expect((yield* session.get(created.id)).outcome).toBe("failed")
-
-      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(interrupted.outcome).toBe("interrupted")
-      expect(
-        (yield* db
-          .select({ type: EventTable.type })
-          .from(EventTable)
-          .where(eq(EventTable.aggregate_id, created.id))
-          .all()).filter((event) => event.type === Bus.versionedType(SessionEvent.Viewed.type, 1)),
-      ).toHaveLength(2)
-    }),
-  )
-
-  it.effect("keeps a newer completion unread when the viewed watermark is stale", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const bus = yield* Bus.Service
-      const created = yield* session.create({ location })
-      yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: created.id })
-      const observed = (yield* session.get(created.id)).time.idle
-      if (!observed) return yield* Effect.die(new Error("Expected idle time"))
-
-      // A failure commits between the viewer's observation and the viewed event.
-      yield* bus.publish(SessionEvent.Execution.Failed, {
-        sessionID: created.id,
-        error: { type: "unknown", message: "failed" },
-      })
-      yield* session.view({ sessionID: created.id, idle: DateTime.toEpochMillis(observed) })
-      const stale = yield* session.get(created.id)
-      if (!stale.time.idle || !stale.time.viewed) return yield* Effect.die(new Error("Expected attention times"))
-      expect(stale.time.viewed).toEqual(observed)
-      expect(DateTime.toEpochMillis(stale.time.idle)).toBeGreaterThan(DateTime.toEpochMillis(stale.time.viewed))
-
-      yield* session.view({ sessionID: created.id, idle: DateTime.toEpochMillis(stale.time.idle) + 1 })
-      expect((yield* session.get(created.id)).time.viewed).toEqual(observed)
-
-      // A duplicate stale watermark never regresses a newer acknowledgement.
-      yield* session.view({ sessionID: created.id, idle: DateTime.toEpochMillis(stale.time.idle) })
-      const acked = yield* session.get(created.id)
-      expect(acked.time.viewed).toEqual(acked.time.idle)
-      yield* bus.publish(SessionEvent.Viewed, { sessionID: created.id, idle: DateTime.toEpochMillis(observed) })
-      expect((yield* session.get(created.id)).time.viewed).toEqual(acked.time.viewed)
-    }),
-  )
-
-  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, idle: 0 }))).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 })
-      const idle = (yield* session.get(created.id)).time.idle
-      if (!idle) return yield* Effect.die(new Error("Expected idle time"))
-      yield* session.view({ sessionID: created.id, idle: DateTime.toEpochMillis(idle) })
-      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 })
-
-        const replayed = yield* store.get(created.id)
-        expect(replayed?.time).toEqual(expected.time)
-        expect(replayed?.outcome).toBe("failed")
-        expect(expected.time.updated).toEqual(created.time.updated)
-        expect(expectedIdle).toBeGreaterThan(expectedViewed)
-      }).pipe(Effect.provide(Layer.fresh(targetLayer)))
-    }),
-  )
-})

packages/core/test/shell-parse-parity.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test"
+import { ShellScan } from "@opencode-ai/shell-scan"
 import { Effect } from "effect"
 import { ShellParse } from "../src/shell/parse.js"
-import { ShellScan } from "../src/shell/scan.js"
 
 describe("ShellParse portable parity", () => {
   test("matches tree-sitter for generated supported syntax", async () => {

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

@@ -878,7 +878,6 @@ describe("ShellTool", () => {
         ),
       (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
     ),
-    { timeout: 15_000 },
   )
 
   if (!isWindows) {

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

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

packages/desktop/src/main/lifecycle/index.ts

@@ -147,9 +147,8 @@ const platform = Layer.merge(DesktopLogging.layer, Shutdown.layer)
 
 export const layer = Layer.unwrap(
   Effect.gen(function* () {
-    // Electron scopes the single-instance lock to userData.
-    yield* configureApplication()
     if (!acquireApplicationLock()) return yield* Effect.interrupt
+    yield* configureApplication()
     return runtime.pipe(Layer.provideMerge(platform))
   }),
 )

packages/httpapi-codegen/src/index.ts

@@ -216,17 +216,12 @@ export function compile<Id extends string, Groups extends HttpApiGroup.Constrain
   const modules = new Set(["client", "client-error", "index"])
   const groups = Array.from(
     Map.groupBy(endpoints, (endpoint) => endpoint.group),
-    ([identifier, endpoints]) => {
+    ([identifier, endpoints], index) => {
       if (new Set(endpoints.map((endpoint) => endpoint.sourceGroup)).size > 1) {
         throw new GenerationError({ reason: `Client group name collision: ${identifier}` })
       }
-      // Module names derive from the group identifier so unrelated groups never rename.
-      const sanitized = identifier.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "")
-      const reserved = /^(aux|client|client-error|con|index|nul|prn|com[1-9]|lpt[1-9])$/i.test(sanitized)
-      const module = sanitized === "" || reserved ? `group-${sanitized}` : sanitized
-      if (modules.has(module.toLowerCase())) {
-        throw new GenerationError({ reason: `Client module name collision: ${module}` })
-      }
+      const base = /^[A-Za-z0-9_-]+$/.test(identifier) ? identifier : `group-${index}`
+      const module = uniqueModule(base, index, modules)
       modules.add(module.toLowerCase())
       return { identifier, sourceIdentifier: endpoints[0].sourceGroup, module, endpoints }
     },
@@ -368,28 +363,9 @@ function renderEffectShape(
 ) {
   const references = effectTypeReferences(typeReferences)
   const imports = new Set<string>()
-  const externalNames = new Set([
-    "AppApi",
-    "Effect",
-    "Stream",
-    ...typeReferences.flatMap((reference) => reference.name.match(/^[A-Za-z_$][A-Za-z0-9_$]*/) ?? []),
-    ...Object.values(outputTypes ?? {}).flatMap((output) => output.name.match(/^[A-Za-z_$][A-Za-z0-9_$]*/) ?? []),
-  ])
-  const generatedNames = groups.flatMap((group) => [
-    groupShapeName(group),
-    ...group.endpoints.flatMap((endpoint) => [
-      ...(endpoint.operation.inputMode === "none" ? [] : [`${endpointTypeName(group, endpoint)}Input`]),
-      `${endpointTypeName(group, endpoint)}Output`,
-      groupShapeTypeName(group, endpoint),
-    ]),
-  ])
-  const collision = generatedNames.find((name) => externalNames.has(name))
-  if (collision !== undefined) {
-    throw new GenerationError({ reason: `Generated Effect type collides with imported type: ${collision}` })
-  }
-  const endpointTypes = groups.map((group) => {
-    const endpoints = group.endpoints.map((endpoint) => {
-      const prefix = endpointTypeName(group, endpoint)
+  const endpointTypes = groups.map((group, groupIndex) => {
+    const endpoints = group.endpoints.map((endpoint, endpointIndex) => {
+      const prefix = `Endpoint${groupIndex}_${endpointIndex}`
       const input = endpoint.input
         .map((field) => {
           const schema = effectInputSchema(endpoint, field)
@@ -554,23 +530,8 @@ function groupShapeName(group: Group) {
   return `${identifierPart(group.identifier)}Api`
 }
 
-// Generated symbol names derive from group and endpoint identity, never from traversal
-// position, so adding an endpoint or group cannot rename unrelated generated code.
-// Uniqueness is validated by compile (groupTypeNames/endpointTypeNames).
-function groupTypeName(group: Group) {
-  return identifierPart(group.identifier)
-}
-
-function endpointTypeName(group: Group, endpoint: Endpoint) {
-  return `${groupTypeName(group)}${endpoint.clientPath.map(identifierPart).join("")}`
-}
-
-function endpointAdapterName(group: Group, endpoint: Endpoint) {
-  return `Endpoint${endpointTypeName(group, endpoint)}`
-}
-
 function groupShapeTypeName(group: Group, endpoint: Endpoint) {
-  return `${endpointTypeName(group, endpoint)}Operation`
+  return `${identifierPart(group.identifier)}${endpoint.clientPath.map(identifierPart).join("")}Operation`
 }
 
 function assertPromiseEndpoint(endpoint: Endpoint) {
@@ -624,7 +585,7 @@ function promiseOperations(groups: ReadonlyArray<Group>) {
 
 function renderEffectFiles(groups: ReadonlyArray<Group>): Output["files"] {
   return [
-    ...groups.map((group) => ({ path: `${group.module}.ts`, content: renderGroup(group) })),
+    ...groups.map((group, index) => ({ path: `${group.module}.ts`, content: renderGroup(group, index) })),
     {
       path: "client-error.ts",
       content:
@@ -649,11 +610,10 @@ function renderImportedEffectFiles(
         readonly shapeModule?: string
       },
 ): Output["files"] {
-  const adapters = groups.map((group) => {
+  const adapters = groups.map((group, groupIndex) => {
     const rawGroup = group.endpoints[0]?.topLevel ? "RawClient" : `RawClient[${JSON.stringify(group.sourceIdentifier)}]`
-    const methods = group.endpoints.map((item) => {
-      const prefix = endpointTypeName(group, item)
-      const adapter = endpointAdapterName(group, item)
+    const methods = group.endpoints.map((item, endpointIndex) => {
+      const prefix = `Endpoint${groupIndex}_${endpointIndex}`
       const schemaBySource = {
         params: item.params,
         query: item.query,
@@ -700,22 +660,20 @@ function renderImportedEffectFiles(
           : isOpaquePayload(item)
             ? `type ${prefix}Request = Parameters<${rawGroup}[${JSON.stringify(item.endpoint.identifier)}]>[0]\n`
             : ""
-      return `${declarations}const ${adapter} = (raw: ${rawGroup}) => (${argument}) => ${output}`
+      return `${declarations}const ${prefix} = (raw: ${rawGroup}) => (${argument}) => ${output}`
     })
     const fields = renderClientTree(
       group.endpoints,
-      (item) => `${endpointAdapterName(group, item)}(raw)`,
+      (_item, endpointIndex) => `Endpoint${groupIndex}_${endpointIndex}(raw)`,
       (name, value) => `${JSON.stringify(name)}: ${value}`,
       ", ",
     )
-    return `${methods.join("\n\n")}\n\nconst adaptGroup${groupTypeName(group)} = (raw: ${rawGroup}) => ({ ${fields} })`
+    return `${methods.join("\n\n")}\n\nconst adaptGroup${groupIndex} = (raw: ${rawGroup}) => ({ ${fields} })`
   })
-  const fields = groups.flatMap((group) =>
+  const fields = groups.flatMap((group, index) =>
     group.endpoints[0]?.topLevel
-      ? [`...adaptGroup${groupTypeName(group)}(raw)`]
-      : [
-          `${JSON.stringify(group.identifier)}: adaptGroup${groupTypeName(group)}(raw[${JSON.stringify(group.sourceIdentifier)}])`,
-        ],
+      ? [`...adaptGroup${index}(raw)`]
+      : [`${JSON.stringify(group.identifier)}: adaptGroup${index}(raw[${JSON.stringify(group.sourceIdentifier)}])`],
   )
   const usesStream = groups.some((group) => group.endpoints.some((item) => item.operation.success === "stream"))
   const imported = "api" in options
@@ -725,24 +683,15 @@ function renderImportedEffectFiles(
       ? renderImportedGroup(options.group)
       : renderImportedProjection(groups, options.endpoints)
   const api = imported ? options.api : "Api"
-  const adapterNames = new Set(
-    groups.flatMap((group) => group.endpoints.map((endpoint) => endpointAdapterName(group, endpoint))),
-  )
-  const adapterCollision = (projection?.imports ?? [api]).find((name) => adapterNames.has(name))
-  if (adapterCollision !== undefined) {
-    throw new GenerationError({
-      reason: `Generated Effect adapter collides with imported endpoint: ${adapterCollision}`,
-    })
-  }
   const imports =
     projection === undefined
       ? `import { ${api} } from ${JSON.stringify(options.module)}`
       : `import { HttpApi, HttpApiClient${"endpoints" in options ? ", HttpApiGroup" : ""} } from "effect/unstable/httpapi"\nimport { ${projection.imports.join(", ")} } from ${JSON.stringify(options.module)}`
   const httpApiImport = projection === undefined ? 'import { HttpApiClient } from "effect/unstable/httpapi"\n' : ""
-  const shapeTypes = groups.flatMap((group) =>
-    group.endpoints.flatMap((endpoint) => [
-      ...(endpoint.operation.inputMode === "none" ? [] : [`${endpointTypeName(group, endpoint)}Input`]),
-      `${endpointTypeName(group, endpoint)}Output`,
+  const shapeTypes = groups.flatMap((group, groupIndex) =>
+    group.endpoints.flatMap((endpoint, endpointIndex) => [
+      ...(endpoint.operation.inputMode === "none" ? [] : [`Endpoint${groupIndex}_${endpointIndex}Input`]),
+      `Endpoint${groupIndex}_${endpointIndex}Output`,
     ]),
   )
   const shapeImport =
@@ -1026,12 +975,11 @@ function renderClientTree(
 }
 
 function identifierPart(value: string) {
-  const identifier = value
+  return value
     .split(/[^A-Za-z0-9]+/)
     .filter(Boolean)
     .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
     .join("")
-  return /^[A-Za-z_$]/.test(identifier) ? identifier : `_${identifier}`
 }
 
 function structuralTypes(schemas: ReadonlyArray<Schema.Top>, mutable: boolean, reservedNames: ReadonlySet<string>) {
@@ -1291,6 +1239,14 @@ function promisePath(path: string, input: ReadonlyArray<InputField>, wildcard?:
   return `\`${template}${wildcard === undefined ? "" : `\${encodePath(input.${wildcard.name})}`}\``
 }
 
+function uniqueModule(base: string, index: number, modules: ReadonlySet<string>) {
+  if (!modules.has(base.toLowerCase())) return base
+  const seed = `${base}-${index}`
+  let suffix = 0
+  while (modules.has(`${seed}${suffix === 0 ? "" : `-${suffix}`}`.toLowerCase())) suffix++
+  return `${seed}${suffix === 0 ? "" : `-${suffix}`}`
+}
+
 function normalizeTransport(
   schema: Schema.Top | undefined,
   source: InputField["source"] | "success" | "error",
@@ -1470,7 +1426,7 @@ export function write(
       output.files,
       (file) =>
         fs.exists(join(directory, file.path)).pipe(
-          Effect.flatMap((exists) => (exists ? fs.stat(join(directory, file.path)) : Effect.undefined)),
+          Effect.flatMap((exists) => (exists ? fs.stat(join(directory, file.path)) : Effect.succeed(undefined))),
           Effect.flatMap((info) =>
             info?.type === "SymbolicLink"
               ? new GenerationError({ reason: `Unsafe output path: ${file.path}` })
@@ -1741,10 +1697,10 @@ function streamEffectPortable(schema: Schema.Top) {
   return sameEncoding(schema.events.ast, rebuilt.events.ast)
 }
 
-function renderGroup(group: Group) {
+function renderGroup(group: Group, groupIndex: number) {
   const slots: Array<Slot> = []
   const adapters: Array<string> = []
-  const endpointSources = group.endpoints.map((operation) => {
+  const endpointSources = group.endpoints.map((operation, endpointIndex) => {
     const {
       endpoint,
       errors,
@@ -1754,7 +1710,7 @@ function renderGroup(group: Group) {
       query: endpointQuery,
       successes,
     } = operation
-    const prefix = `Endpoint${operation.clientPath.map(identifierPart).join("")}`
+    const prefix = `Endpoint${endpointIndex}`
     const params = addSlot(endpointParams, `${prefix}Params`)
     const query = addSlot(endpointQuery, `${prefix}Query`)
     const headers = addSlot(endpointHeaders, `${prefix}Headers`)
@@ -1849,16 +1805,15 @@ function renderGroup(group: Group) {
   const usesHttpApiSchema = endpointSources.some((source) => source.includes("HttpApiSchema."))
   const methods = renderClientTree(
     group.endpoints,
-    (item) => `Endpoint${item.clientPath.map(identifierPart).join("")}(raw)`,
+    (_item, index) => `Endpoint${index}(raw)`,
     (name, value) => `${JSON.stringify(name)}: ${value}`,
     ", ",
   )
-  const name = groupTypeName(group)
   const rawGroup = group.endpoints[0]?.topLevel
-    ? `HttpApiClient.Client<typeof Group${name}>`
-    : `HttpApiClient.Client.Group<typeof Group${name}, never, never>`
+    ? `HttpApiClient.Client<typeof Group${groupIndex}>`
+    : `HttpApiClient.Client.Group<typeof Group${groupIndex}, never, never>`
   const usesStream = group.endpoints.some((item) => item.operation.success === "stream")
-  return `// Generated by @opencode-ai/httpapi-codegen. Do not edit.\nimport { Effect, Schema${usesStream ? ", Stream" : ""} } from "effect"\nimport { Sse } from "effect/unstable/encoding"\nimport { HttpClientError } from "effect/unstable/http"\nimport { HttpApiClient, HttpApiEndpoint, HttpApiGroup${usesHttpApiSchema ? ", HttpApiSchema" : ""} } from "effect/unstable/httpapi"\nimport { ClientError } from "./client-error.js"\n\n${declarations}\n\nexport const Group${name} = ${groupSource}\n\ntype RawGroup = ${rawGroup}\n\n${adapters.join("\n\n")}\n\nexport const adaptGroup${name} = (raw: RawGroup) => ({ ${methods} })\n`
+  return `// Generated by @opencode-ai/httpapi-codegen. Do not edit.\nimport { Effect, Schema${usesStream ? ", Stream" : ""} } from "effect"\nimport { Sse } from "effect/unstable/encoding"\nimport { HttpClientError } from "effect/unstable/http"\nimport { HttpApiClient, HttpApiEndpoint, HttpApiGroup${usesHttpApiSchema ? ", HttpApiSchema" : ""} } from "effect/unstable/httpapi"\nimport { ClientError } from "./client-error.js"\n\n${declarations}\n\nexport const Group${groupIndex} = ${groupSource}\n\ntype RawGroup = ${rawGroup}\n\n${adapters.join("\n\n")}\n\nexport const adaptGroup${groupIndex} = (raw: RawGroup) => ({ ${methods} })\n`
 }
 
 function renderEffectRequestPart(
@@ -1928,20 +1883,15 @@ function renderSchemas(slots: ReadonlyArray<Slot>) {
 
 function renderClient(groups: ReadonlyArray<Group>) {
   const imports = groups
-    .map(
-      (group) =>
-        `import { adaptGroup${groupTypeName(group)}, Group${groupTypeName(group)} } from ${JSON.stringify(`./${group.module}`)}`,
-    )
+    .map((group, index) => `import { adaptGroup${index}, Group${index} } from ${JSON.stringify(`./${group.module}`)}`)
     .join("\n")
-  const api = `HttpApi.make("generated")${groups.map((group) => `.add(Group${groupTypeName(group)})`).join("")}`
-  const fields = groups.flatMap((group) => {
+  const api = `HttpApi.make("generated")${groups.map((_, index) => `.add(Group${index})`).join("")}`
+  const fields = groups.flatMap((group, index) => {
     if (!group.endpoints[0]?.topLevel) {
-      return [
-        `${JSON.stringify(group.identifier)}: adaptGroup${groupTypeName(group)}(raw[${JSON.stringify(group.identifier)}])`,
-      ]
+      return [`${JSON.stringify(group.identifier)}: adaptGroup${index}(raw[${JSON.stringify(group.identifier)}])`]
     }
     const raw = `{ ${group.endpoints.map((item) => `${JSON.stringify(item.endpoint.identifier)}: raw[${JSON.stringify(item.endpoint.identifier)}]`).join(", ")} }`
-    return [`...adaptGroup${groupTypeName(group)}(${raw})`]
+    return [`...adaptGroup${index}(${raw})`]
   })
   return `// Generated by @opencode-ai/httpapi-codegen. Do not edit.\nimport { Effect } from "effect"\nimport { HttpApi, HttpApiClient } from "effect/unstable/httpapi"\n${imports}\n\nconst Api = ${api}\nconst adaptClient = (raw: HttpApiClient.ForApi<typeof Api>) => ({ ${fields.join(", ")} })\n\nexport const make = (options?: { readonly baseUrl?: URL | string }) =>\n  HttpApiClient.make(Api, options).pipe(Effect.map(adaptClient))\n`
 }

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

@@ -120,8 +120,8 @@ describe("HttpApiCodegen.generate", () => {
     const source = output.files[0]?.content
 
     expect(source).toContain('import type { Session } from "@example/schema/session"')
-    expect(source).toContain('export type SessionGetInput = { readonly "id": string }')
-    expect(source).toContain("export type SessionGetOutput = Session.Info")
+    expect(source).toContain('export type Endpoint0_0Input = { readonly "id": string }')
+    expect(source).toContain("export type Endpoint0_0Output = Session.Info")
     expect(source).not.toContain("HttpApiClient")
     expect(source).not.toContain("@example/api")
   })
@@ -141,53 +141,7 @@ describe("HttpApiCodegen.generate", () => {
     const source = output.files[0]?.content
 
     expect(source).toContain('import type { OpenCodeEvent } from "@example/protocol/event"')
-    expect(source).toContain("export type SessionEventsOutput = OpenCodeEvent")
-  })
-
-  test("rejects authoritative Effect types colliding with generated aliases", () => {
-    expect(() =>
-      emitEffectShape(compileContract(api(HttpApiEndpoint.get("get", "/session", { success: Schema.String }))), {
-        outputTypes: {
-          "session.get": {
-            name: "SessionGetOutput",
-            import: 'import type { SessionGetOutput } from "@example/schema/session"',
-          },
-        },
-      }),
-    ).toThrow("Generated Effect type collides with imported type: SessionGetOutput")
-  })
-
-  test("rejects qualified Effect imports colliding with generated interfaces", () => {
-    const Info = Schema.Struct({ id: Schema.String }).annotate({ identifier: "Session.Info" })
-
-    expect(() =>
-      emitEffectShape(compileContract(api(HttpApiEndpoint.get("get", "/session", { success: Info }))), {
-        typeReferences: [
-          {
-            schema: Info,
-            name: "SessionApi.Info",
-            import: 'import type { SessionApi } from "@example/schema/session"',
-          },
-        ],
-      }),
-    ).toThrow("Generated Effect type collides with imported type: SessionApi")
-  })
-
-  test("rejects imported endpoints colliding with generated adapter values", () => {
-    const contract = compileContract(api(HttpApiEndpoint.get("session.get", "/session", { success: Schema.String })))
-
-    expect(() =>
-      emitEffectImported(contract, {
-        module: "@example/api",
-        endpoints: { "session.session.get": "EndpointSessionGet" },
-      }),
-    ).toThrow("Generated Effect adapter collides with imported endpoint: EndpointSessionGet")
-    expect(() =>
-      emitEffectImported(contract, {
-        module: "@example/api",
-        api: "EndpointSessionGet",
-      }),
-    ).toThrow("Generated Effect adapter collides with imported endpoint: EndpointSessionGet")
+    expect(source).toContain("export type Endpoint0_0Output = OpenCodeEvent")
   })
 
   test("exposes an imported Effect client through its generated shape", () => {
@@ -197,8 +151,8 @@ describe("HttpApiCodegen.generate", () => {
     )
     const source = output.files.find((file) => file.path === "client.ts")?.content
 
-    expect(source).toContain('import type { SessionGetOutput } from "../api"')
-    expect(source).toContain("preserveEffect<SessionGetOutput>()")
+    expect(source).toContain('import type { Endpoint0_0Output } from "../api"')
+    expect(source).toContain("preserveEffect<Endpoint0_0Output>()")
   })
 
   test("projects imported endpoint constants into a generated API", () => {
@@ -317,12 +271,12 @@ describe("HttpApiCodegen.generate", () => {
 
     const effect = emitEffect(contract)
     expect(effect.files.find((file) => file.path === "session.ts")?.content).toContain(
-      '"instructions": { "list": EndpointInstructionsList(raw), "put": EndpointInstructionsPut(raw), "remove": EndpointInstructionsRemove(raw) }',
+      '"instructions": { "list": Endpoint0(raw), "put": Endpoint1(raw), "remove": Endpoint2(raw) }',
     )
 
     const imported = emitEffectImported(contract, { module: "@example/api", api: "Api" })
     expect(imported.files.find((file) => file.path === "client.ts")?.content).toContain(
-      '"instructions": { "list": EndpointSessionInstructionsList(raw), "put": EndpointSessionInstructionsPut(raw), "remove": EndpointSessionInstructionsRemove(raw) }',
+      '"instructions": { "list": Endpoint0_0(raw), "put": Endpoint0_1(raw), "remove": Endpoint0_2(raw) }',
     )
 
     const shape = emitEffectShape(contract)
@@ -442,13 +396,8 @@ describe("HttpApiCodegen.generate", () => {
   })
 
   test("rejects normalized group, operation-key, and group prototype collisions", () => {
-    const sanitized = HttpApi.make("test")
-      .add(HttpApiGroup.make("foo-bar").add(HttpApiEndpoint.get("get", "/first", { success: Schema.String })))
-      .add(HttpApiGroup.make("foo.bar").add(HttpApiEndpoint.get("get", "/second", { success: Schema.String })))
-    expect(() => compileContract(sanitized)).toThrow("Client module name collision: foo-bar")
-
     const normalized = HttpApi.make("test")
-      .add(HttpApiGroup.make("foo_bar").add(HttpApiEndpoint.get("get", "/first", { success: Schema.String })))
+      .add(HttpApiGroup.make("foo-bar").add(HttpApiEndpoint.get("get", "/first", { success: Schema.String })))
       .add(HttpApiGroup.make("foo.bar").add(HttpApiEndpoint.get("get", "/second", { success: Schema.String })))
     expect(() => compileContract(normalized)).toThrow("Client group type collision: FooBar")
 
@@ -550,9 +499,7 @@ describe("HttpApiCodegen.generate", () => {
 
     expect(contract.groups[0]?.endpoints[0]?.operation.name).toBe("get")
     expect(promise).toContain('"get": (input: SessionGetInput, requestOptions?: RequestOptions)')
-    expect(effect).toContain(
-      'const adaptGroupSession = (raw: RawClient["session"]) => ({ "get": EndpointSessionGet(raw) })',
-    )
+    expect(effect).toContain('const adaptGroup0 = (raw: RawClient["session"]) => ({ "get": Endpoint0_0(raw) })')
     expect(effect).toContain('raw["session.get"]')
   })
 
@@ -1531,7 +1478,7 @@ describe("HttpApiCodegen.generate", () => {
 
     expect(output.operations[0]).toBeDefined()
     expect(output.files.find((file) => file.path === "session.ts")?.content).toContain(
-      'extends Schema.TaggedError<EndpointGetError0Class>("Unauthorized")',
+      'extends Schema.TaggedError<Endpoint0Error0Class>("Unauthorized")',
     )
   })
 
@@ -1547,7 +1494,7 @@ describe("HttpApiCodegen.generate", () => {
     )
 
     expect(output.files.find((file) => file.path === "session.ts")?.content).toContain(
-      'EndpointGetError0Class.annotate({ "httpApiStatus": 404 })',
+      'Endpoint0Error0Class.annotate({ "httpApiStatus": 404 })',
     )
   })
 
@@ -1557,35 +1504,35 @@ describe("HttpApiCodegen.generate", () => {
     expect(output.files.find((file) => file.path === "session.ts")?.content).toContain('HttpApiEndpoint.make("TRACE")')
   })
 
-  test("uses safe identity-derived module paths without changing public group identifiers", () => {
+  test("uses safe unique module paths without changing public group identifiers", () => {
     const output = compile(
       HttpApi.make("test")
         .add(HttpApiGroup.make("../session").add(HttpApiEndpoint.get("get", "/session", { success: Schema.String })))
         .add(HttpApiGroup.make("GROUP-0").add(HttpApiEndpoint.get("list", "/session", { success: Schema.String }))),
     )
 
-    expect(output.files.slice(0, 2).map((file) => file.path)).toEqual(["session.ts", "GROUP-0.ts"])
+    expect(output.files.slice(0, 2).map((file) => file.path)).toEqual(["group-0.ts", "GROUP-0-1.ts"])
     expect(output.files[0]?.content).toContain('HttpApiGroup.make("../session"')
   })
 
-  test("prefixes group modules that collide with support or Windows-reserved names", () => {
+  test("reserves support module names case-insensitively", () => {
     const output = compile(
       HttpApi.make("test")
-        .add(HttpApiGroup.make("INDEX").add(HttpApiEndpoint.get("get", "/index", { success: Schema.String })))
-        .add(HttpApiGroup.make("CON").add(HttpApiEndpoint.get("get", "/con", { success: Schema.String }))),
+        .add(HttpApiGroup.make("client").add(HttpApiEndpoint.get("get", "/client", { success: Schema.String })))
+        .add(HttpApiGroup.make("INDEX").add(HttpApiEndpoint.get("get", "/index", { success: Schema.String }))),
     )
 
-    expect(output.files.slice(0, 2).map((file) => file.path)).toEqual(["group-INDEX.ts", "group-CON.ts"])
+    expect(output.files.slice(0, 2).map((file) => file.path)).toEqual(["client-0.ts", "INDEX-1.ts"])
   })
 
-  test("rejects module names colliding after normalization", () => {
-    expect(() =>
-      compile(
-        HttpApi.make("test")
-          .add(HttpApiGroup.make("my.group").add(HttpApiEndpoint.get("first", "/first", { success: Schema.String })))
-          .add(HttpApiGroup.make("my/group").add(HttpApiEndpoint.get("second", "/second", { success: Schema.String }))),
-      ),
-    ).toThrow("Client module name collision: my-group")
+  test("keeps searching when a reserved-name fallback is also occupied", () => {
+    const output = compile(
+      HttpApi.make("test")
+        .add(HttpApiGroup.make("client-1").add(HttpApiEndpoint.get("first", "/first", { success: Schema.String })))
+        .add(HttpApiGroup.make("client").add(HttpApiEndpoint.get("second", "/second", { success: Schema.String }))),
+    )
+
+    expect(output.files.slice(0, 2).map((file) => file.path)).toEqual(["client-1.ts", "client-1-1.ts"])
   })
 
   test("rejects collisions in the flattened client namespace", () => {
@@ -1611,7 +1558,7 @@ describe("HttpApiCodegen.generate", () => {
       ),
     )
 
-    expect(output.files[0]?.content).toContain("type RawGroup = HttpApiClient.Client<typeof GroupHealth")
+    expect(output.files[0]?.content).toContain("type RawGroup = HttpApiClient.Client<typeof Group0")
   })
 
   it.effect("reports compiler failures in the generate Effect", () =>

packages/httpapi-codegen/test/generated/client.ts

@@ -1,15 +1,15 @@
 // Generated by @opencode-ai/httpapi-codegen. Do not edit.
 import { Effect } from "effect"
 import { HttpApi, HttpApiClient } from "effect/unstable/httpapi"
-import { adaptGroupSession, GroupSession } from "./session"
-import { adaptGroupEvent, GroupEvent } from "./event"
-import { adaptGroupSystem, GroupSystem } from "./system"
+import { adaptGroup0, Group0 } from "./session"
+import { adaptGroup1, Group1 } from "./event"
+import { adaptGroup2, Group2 } from "./system"
 
-const Api = HttpApi.make("generated").add(GroupSession).add(GroupEvent).add(GroupSystem)
+const Api = HttpApi.make("generated").add(Group0).add(Group1).add(Group2)
 const adaptClient = (raw: HttpApiClient.ForApi<typeof Api>) => ({
-  session: adaptGroupSession(raw["session"]),
-  event: adaptGroupEvent(raw["event"]),
-  ...adaptGroupSystem({ status: raw["status"] }),
+  session: adaptGroup0(raw["session"]),
+  event: adaptGroup1(raw["event"]),
+  ...adaptGroup2({ status: raw["status"] }),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>